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