Allow self types after with

Author: odersky

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -196,6 +196,7 @@ object Parsers {
  def isTemplateIntro = templateIntroTokens contains in.token
  def isDclIntro = dclIntroTokens contains in.token
  def isStatSeqEnd = in.isNestedEnd || in.token == EOF || in.token == RPAREN
+ def isTemplateBodyStart = in.token == WITH || in.isNestedStart
  def mustStartStat = mustStartStatTokens contains in.token
 
  /** Is current token a hard or soft modifier (in modifier position or not)? */
@@ -919,6 +920,39 @@ object Parsers {
  val next = in.lookahead.token
  next == LBRACKET || next == LPAREN
 
+ /** Does a template start after `with`? This is the case if either
+ * - the next token is `{`
+ * - the `with` is at the end of a line
+ * (except for source = 3.0-migration, when a warning is issued)
+ * - the next tokens is `<ident>` or `this` and the one after it is `:` or `=>`
+ * (i.e. we see the start of a self type)
+ */
+ def followingIsTemplateStart() =
+ val lookahead = in.LookaheadScanner()
+ lookahead.nextToken()
+ lookahead.token == LBRACE
+ || lookahead.isAfterLineEnd
+ && {
+ if migrateTo3 then
+ warning(
+ em"""In Scala 3, `with` at the end of a line will start definitions,
+ |so it cannot be used in front of a parent constructor anymore.
+ |Place the `with` at the beginning of the next line instead.""")
+ false
+ else
+ true
+ }
+ || (lookahead.isIdent || lookahead.token == THIS)
+ && {
+ lookahead.nextToken()
+ lookahead.token == COLON
+ && { // needed only as long as we support significant colon at eol
+ lookahead.nextToken()
+ !lookahead.isAfterLineEnd
+ }
+ || lookahead.token == ARROW
+ }
+
 /* --------- OPERAND/OPERATOR STACK --------------------------------------- */
 
  var opStack: List[OpInfo] = Nil
@@ -1281,14 +1315,14 @@ object Parsers {
  in.sourcePos())
  patch(source, Span(in.offset), " ")
 
- def possibleTemplateStart(isNew: Boolean = false): Unit =
+ def possibleTemplateStart(): Unit =
  in.observeColonEOL()
- if in.token == COLONEOL || in.token == WITH then
+ if in.token == COLONEOL then
  if in.lookahead.isIdent(nme.end) then in.token = NEWLINE
  else
  in.nextToken()
  if in.token != INDENT && in.token != LBRACE then
- syntaxErrorOrIncomplete(i"indented definitions expected, ${in} found")
+ syntaxErrorOrIncomplete(ExpectedTokenButFound(INDENT, in.token))
  else
  newLineOptWhenFollowedBy(LBRACE)
 
@@ -2313,13 +2347,11 @@ object Parsers {
  val start = in.skipToken()
  def reposition(t: Tree) = t.withSpan(Span(start, in.lastOffset))
  possibleTemplateStart()
- val parents =
- if in.isNestedStart then Nil
- else constrApp() :: withConstrApps()
+ val parents = if isTemplateBodyStart then Nil else constrApp() :: withConstrApps()
  colonAtEOLOpt()
- possibleTemplateStart(isNew = true)
+ possibleTemplateStart()
  parents match {
- case parent :: Nil if !in.isNestedStart =>
+ case parent :: Nil if !isTemplateBodyStart =>
  reposition(if (parent.isType) ensureApplied(wrapNew(parent)) else parent)
  case _ =>
  New(reposition(templateBodyOpt(emptyConstructor, parents, Nil)))
@@ -3643,21 +3675,7 @@ object Parsers {
  /** `{`with` ConstrApp} but no EOL allowed after `with`.
  */
  def withConstrApps(): List[Tree] =
- def isTemplateStart =
- val la = in.lookahead
- la.token == LBRACE
- || la.isAfterLineEnd
- && {
- if migrateTo3 then
- warning(
- em"""In Scala 3, `with` at the end of a line will start definitions,
- |so it cannot be used in front of a parent constructor anymore.
- |Place the `with` at the beginning of the next line instead.""")
- false
- else
- true
- }
- if in.token == WITH && !isTemplateStart then
+ if in.token == WITH && !followingIsTemplateStart() then
  in.nextToken()
  constrApp() :: withConstrApps()
  else Nil
@@ -3701,32 +3719,66 @@ object Parsers {
  template(constr)
  else
  possibleTemplateStart()
- if in.isNestedStart then
+ if isTemplateBodyStart then
  template(constr)
  else
  checkNextNotIndented()
  Template(constr, Nil, Nil, EmptyValDef, Nil)
 
- /** TemplateBody ::= [nl] `{' TemplateStatSeq `}'
- * EnumBody ::= [nl] ‘{’ [SelfType] EnumStat {semi EnumStat} ‘}’
+ /** TemplateBody ::= [nl | ‘with’] `{' TemplateStatSeq `}'
+ * | ‘with’ [SelfType] indent TemplateStats outdent
+ * EnumBody ::= [nl | ‘with’] ‘{’ [SelfType] EnumStats ‘}’
+ * | ‘with’ [SelfType] indent EnumStats outdent
  */
  def templateBodyOpt(constr: DefDef, parents: List[Tree], derived: List[Tree]): Template =
  val (self, stats) =
- if in.isNestedStart then
+ if isTemplateBodyStart then
  templateBody()
  else
  checkNextNotIndented()
  (EmptyValDef, Nil)
  Template(constr, parents, derived, self, stats)
 
  def templateBody(): (ValDef, List[Tree]) =
- val r = inDefScopeBraces(templateStatSeq(), rewriteWithColon = true)
+ val givenSelf =
+ if in.token == WITH then
+ in.nextToken()
+ selfDefOpt()
+ else EmptyValDef
+ val r = inDefScopeBraces(templateStatSeq(givenSelf), rewriteWithColon = true)
  if in.token == WITH then
  syntaxError(EarlyDefinitionsNotSupported())
  in.nextToken()
  template(emptyConstructor)
  r
 
+ /** SelfType ::= id [‘:’ InfixType] ‘=>’
+ * | ‘this’ ‘:’ InfixType ‘=>’
+ * Only called immediately after a `with`, in which case it must in turn
+ * be followed by `INDENT`.
+ */
+ def selfDefOpt(): ValDef = atSpan(in.offset) {
+ val vd =
+ if in.isIdent then
+ val selfName = ident()
+ if in.token == COLON then
+ in.nextToken()
+ makeSelfDef(selfName, infixType())
+ else
+ makeSelfDef(selfName, TypeTree())
+ else if in.token == THIS then
+ in.nextToken()
+ accept(COLON)
+ makeSelfDef(nme.WILDCARD, infixType())
+ else
+ EmptyValDef
+ if !vd.isEmpty then
+ accept(ARROW)
+ if in.token != INDENT then
+ syntaxErrorOrIncomplete(ExpectedTokenButFound(INDENT, in.token))
+ vd
+ }
+
  /** with Template, with EOL <indent> interpreted */
  def withTemplate(constr: DefDef, parents: List[Tree]): Template =
  if in.token != WITH then syntaxError(em"`with` expected")
@@ -3800,10 +3852,10 @@ object Parsers {
  * EnumStat ::= TemplateStat
  * | Annotations Modifiers EnumCase
  */
- def templateStatSeq(): (ValDef, List[Tree]) = checkNoEscapingPlaceholders {
- var self: ValDef = EmptyValDef
+ def templateStatSeq(givenSelf: ValDef = EmptyValDef): (ValDef, List[Tree]) = checkNoEscapingPlaceholders {
+ var self = givenSelf
  val stats = new ListBuffer[Tree]
- if (isExprIntro && !isDefIntro(modifierTokens)) {
+ if (self.isEmpty && isExprIntro && !isDefIntro(modifierTokens)) {
  val first = expr1()
  if (in.token == ARROW) {
  first match {
@@ -3956,7 +4008,7 @@ object Parsers {
  possibleTemplateStart()
  if in.token == EOF then
  ts += makePackaging(start, pkg, List())
- else if in.isNestedStart then
+ else if isTemplateBodyStart then
  ts += inDefScopeBraces(makePackaging(start, pkg, topStatSeq()), rewriteWithColon = true)
  continue = true
  else
@@ -3994,6 +4046,7 @@ object Parsers {
  }
 
  override def templateBody(): (ValDef, List[Thicket]) = {
+ if in.token == WITH then in.nextToken()
  skipBraces()
  (EmptyValDef, List(EmptyTree))
  }

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -1126,6 +1126,7 @@ import transform.SymUtils._
  def msg =
  val expectedText =
  if (Tokens.isIdentifier(expected)) "an identifier"
+ else if expected == Tokens.INDENT then "indented definitions"
  else Tokens.showToken(expected)
  em"""${expectedText} expected, but ${foundText} found"""
 

docs/docs/internals/syntax.md

@@ -148,7 +148,7 @@ FunParamClause ::= ‘(’ TypedFunParam {‘,’ TypedFunParam } ‘)’
 TypedFunParam ::= id ‘:’ Type
 MatchType ::= InfixType `match` ‘{’ TypeCaseClauses ‘}’
 InfixType ::= RefinedType {id [nl] RefinedType} InfixOp(t1, op, t2)
-RefinedType ::= WithType {[nl] Refinement}  RefinedTypeTree(t, ds)
+RefinedType ::= WithType {[nl | ‘with’] Refinement} RefinedTypeTree(t, ds)
 WithType ::= AnnotType {‘with’ AnnotType} (deprecated)
 AnnotType ::= SimpleType {Annotation} Annotated(t, annot)
 
@@ -401,6 +401,7 @@ ConstrExpr ::= SelfInvocation
 SelfInvocation ::= ‘this’ ArgumentExprs {ArgumentExprs}
 
 TemplateBody ::= [nl | ‘with’] ‘{’ [SelfType] TemplateStat {semi TemplateStat} ‘}’
+ | ‘with’ [SelfType] indent TemplateStats outdent
 TemplateStat ::= Import
  | Export
  | {Annotation [nl]} {Modifier} Def
@@ -412,7 +413,9 @@ TemplateStat ::= Import
 SelfType ::= id [‘:’ InfixType] ‘=>’ ValDef(_, name, tpt, _)
  | ‘this’ ‘:’ InfixType ‘=>’
 
-EnumBody ::= [nl | ‘with’] ‘{’ [SelfType] EnumStat {semi EnumStat} ‘}’
+EnumBody ::= [nl | ‘with’] ‘{’ [SelfType] EnumStats ‘}’
+ | ‘with’ [SelfType] indent EnumStats outdent
+EnumStats ::= EnumStat {semi EnumStat}
 EnumStat ::= TemplateStat
  | {Annotation [nl]} {Modifier} EnumCase
 EnumCase ::= ‘case’ (id ClassConstr [‘extends’ ConstrApps]] | ids)

tests/neg/with-template.check

@@ -0,0 +1,22 @@
+-- Error: tests/neg/with-template.scala:6:5 ----------------------------------------------------------------------------
+6 | B with // error // error this one allows an informative hint
+ | ^^^^
+ | end of statement expected but 'with' found
+ |
+ | Maybe you meant to write a mixin in an extends clause?
+ | Note that this requires the `with` to come first now.
+ | I.e.
+ |
+ | with B
+-- [E006] Not Found Error: tests/neg/with-template.scala:6:2 -----------------------------------------------------------
+6 | B with // error // error this one allows an informative hint
+ | ^
+ | Not found: B
+
+longer explanation available when compiling with `-explain`
+-- [E006] Not Found Error: tests/neg/with-template.scala:10:2 ----------------------------------------------------------
+10 | B { // error this one is harder since it is syntactically correct
+ | ^
+ | Not found: B
+
+longer explanation available when compiling with `-explain`

tests/neg/with-template.scala

@@ -0,0 +1,14 @@
+class A
+trait B
+trait C
+
+object Test extends A with
+ B with // error // error this one allows an informative hint
+ C
+
+object Test2 extends A with
+ B { // error this one is harder since it is syntactically correct
+ println("foo")
+ }
+
+

tests/pos/i10080.scala

@@ -1,5 +1,2 @@
-trait Foo with
-end Foo
-
 trait Bar
 end Bar

tests/pos/indent.scala

@@ -82,8 +82,7 @@ object Test with
  x < 10
  do ()
 
-class Test2 with
- self =>
+class Test2 with self: Test2 =>
  def foo(x: Int) =
  if x < 0 then throw
  val ex = new AssertionError()
@@ -98,9 +97,11 @@ class Test2 with
 end Test2
 
 class Test3 with
- self =>
+  self =>
  def foo = 1
 
+class Test4 with { val x = 5 }
+
 import collection.mutable.HashMap
 
 class Coder(words: List[String]) with