Allow with after class

Author: odersky

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

@@ -1288,7 +1288,7 @@ object Parsers {
         else
           in.nextToken()
           if in.token != INDENT && in.token != LBRACE then
-            syntaxErrorOrIncomplete(i"indented definitions expected, ${in}")
+            syntaxErrorOrIncomplete(i"indented definitions expected, ${in} found")
       else
         newLineOptWhenFollowedBy(LBRACE)
 
@@ -2315,7 +2315,7 @@ object Parsers {
       possibleTemplateStart()
       val parents =
         if in.isNestedStart then Nil
-        else constrApps(commaOK = false)
+        else constrApp() :: withConstrApps()
       colonAtEOLOpt()
       possibleTemplateStart(isNew = true)
       parents match {
@@ -3494,7 +3494,7 @@ object Parsers {
       val parents =
         if (in.token == EXTENDS) {
           in.nextToken()
-          constrApps(commaOK = true)
+          constrApps()
         }
         else Nil
       Template(constr, parents, Nil, EmptyValDef, Nil)
@@ -3626,24 +3626,37 @@ object Parsers {
         // Using Ident(tpnme.ERROR) to avoid causing cascade errors on non-user-written code
       if in.token == LPAREN then parArgumentExprss(wrapNew(t)) else t
 
-    /** ConstrApps  ::=  ConstrApp {(‘,’ | ‘with’) ConstrApp}
+    /** ConstrApps  ::=  ConstrApp ({‘,’ ConstrApp} | {‘with’ ConstrApp})
      */
-    def constrApps(commaOK: Boolean): List[Tree] =
+    def constrApps(): List[Tree] =
       val t = constrApp()
-      val ts =
-        if in.token == WITH || commaOK && in.token == COMMA then
-          in.nextToken()
-          constrApps(commaOK)
-        else Nil
+      val ts = if in.token == COMMA then commaConstrApps() else withConstrApps()
       t :: ts
 
+    /** `{`,` ConstrApp} */
+    def commaConstrApps(): List[Tree] =
+      if in.token == COMMA then
+        in.nextToken()
+        constrApp() :: commaConstrApps()
+      else Nil
 
     /** `{`with` ConstrApp} but no EOL allowed after `with`.
      */
     def withConstrApps(): List[Tree] =
       def isTemplateStart =
         val la = in.lookahead
-        la.isAfterLineEnd || la.token == LBRACE
+        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
         in.nextToken()
         constrApp() :: withConstrApps()
@@ -3662,7 +3675,7 @@ object Parsers {
               in.sourcePos())
             Nil
           }
-          else constrApps(commaOK = true)
+          else constrApps()
         }
         else Nil
       newLinesOptWhenFollowedBy(nme.derives)
@@ -3806,7 +3819,16 @@ object Parsers {
         }
         else {
           stats += first
-          acceptStatSepUnlessAtEnd(stats)
+          if in.token == WITH then
+            syntaxError(
+              i"""end of statement expected but ${showToken(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 $first""")
+          else acceptStatSepUnlessAtEnd(stats)
         }
       }
       var exitOnError = false

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

@@ -1338,7 +1338,7 @@ object Scanners {
    *   InBraces    a pair of braces { ... }
    *   Indented    a pair of <indent> ... <outdent> tokens
    */
-  abstract class Region:
+  abstract class Region(val code: String):
     /** The region enclosing this one, or `null` for the outermost region */
     def outer: Region | Null
 
@@ -1367,17 +1367,17 @@ object Scanners {
       knownWidth = enclosing.knownWidth
   end Region
 
-  case class InString(multiLine: Boolean, outer: Region) extends Region
-  case class InParens(prefix: Token, outer: Region) extends Region
-  case class InBraces(outer: Region) extends Region
-  case class InCase(outer: Region) extends Region
+  case class InString(multiLine: Boolean, outer: Region) extends Region("IS")
+  case class InParens(prefix: Token, outer: Region) extends Region("IP")
+  case class InBraces(outer: Region) extends Region("IB")
+  case class InCase(outer: Region) extends Region("IC")
 
   /** A class describing an indentation region.
    *  @param width   The principal indendation width
    *  @param others  Other indendation widths > width of lines in the same region
    *  @param prefix  The token before the initial <indent> of the region
    */
-  case class Indented(width: IndentWidth, others: Set[IndentWidth], prefix: Token, outer: Region | Null) extends Region:
+  case class Indented(width: IndentWidth, others: Set[IndentWidth], prefix: Token, outer: Region | Null) extends Region("II"):
     knownWidth = width
 
   def topLevelRegion(width: IndentWidth) = Indented(width, Set(), EMPTY, null)

docs/docs/internals/syntax.md

@@ -83,7 +83,6 @@ comment          ::=  ‘/*’ “any sequence of characters; nested comments ar
 
 nl               ::=  “new line character”
 semi             ::=  ‘;’ |  nl {nl}
-colonEol         ::=  ": at end of line that can start a template body"
 ```
 
 ## Keywords
@@ -218,9 +217,8 @@ SimpleExpr        ::=  SimpleRef
                     |  ‘$’ ‘{’ Block ‘}’
                     |  Quoted
                     |  quoteId                                                  -- only inside splices
-                    |  ‘new’ ConstrApp {‘with’ ConstrApp}                       New(constr | templ)
-                       [[colonEol] TemplateBody
-                    |  ‘new’ [colonEol] TemplateBody
+                    |  ‘new’ ConstrApp {‘with’ ConstrApp} [TemplateBody]        New(constr | templ)
+                    |  ‘new’ TemplateBody
                     |  ‘(’ ExprsInParens ‘)’                                    Parens(exprs)
                     |  SimpleExpr ‘.’ id                                        Select(expr, id)
                     |  SimpleExpr ‘.’ MatchClause
@@ -386,23 +384,23 @@ ClassDef          ::=  id ClassConstr [Template]
 ClassConstr       ::=  [ClsTypeParamClause] [ConstrMods] ClsParamClauses        with DefDef(_, <init>, Nil, vparamss, EmptyTree, EmptyTree) as first stat
 ConstrMods        ::=  {Annotation} [AccessModifier]
 ObjectDef         ::=  id [Template]                                            ModuleDef(mods, name, template)  // no constructor
-EnumDef           ::=  id ClassConstr InheritClauses [colonEol] EnumBody
+EnumDef           ::=  id ClassConstr InheritClauses EnumBody
 GivenDef          ::=  [GivenSig] (Type [‘=’ Expr] | StructuralInstance)
 GivenSig          ::=  [id] [DefTypeParamClause] {UsingParamClause} ‘:’         -- one of `id`, `DefParamClause`, `UsingParamClause` must be present
-StructuralInstance ::=  ConstrApp {‘with’ ConstrApp} ‘with’ TemplateBody
+StructuralInstance ::=  ConstrApp {‘with’ ConstrApp} TemplateBody
 Extension         ::=  ‘extension’ [DefTypeParamClause] ‘(’ DefParam ‘)’
                        {UsingParamClause}] ExtMethods
 ExtMethods        ::=  ExtMethod | [nl] ‘{’ ExtMethod {semi ExtMethod ‘}’
 ExtMethod         ::=  {Annotation [nl]} {Modifier} ‘def’ DefDef
-Template          ::=  InheritClauses [colonEol] [TemplateBody]                 Template(constr, parents, self, stats)
+Template          ::=  InheritClauses [TemplateBody]                           Template(constr, parents, self, stats)
 InheritClauses    ::=  [‘extends’ ConstrApps] [‘derives’ QualId {‘,’ QualId}]
 ConstrApps        ::=  ConstrApp ({‘,’ ConstrApp} | {‘with’ ConstrApp})
 ConstrApp         ::=  SimpleType1 {Annotation} {ParArgumentExprs}              Apply(tp, args)
 ConstrExpr        ::=  SelfInvocation
                     |  ‘{’ SelfInvocation {semi BlockStat} ‘}’
 SelfInvocation    ::=  ‘this’ ArgumentExprs {ArgumentExprs}
 
-TemplateBody      ::=  [nl] ‘{’ [SelfType] TemplateStat {semi TemplateStat} ‘}’
+TemplateBody      ::=  [nl | ‘with’] ‘{’ [SelfType] TemplateStat {semi TemplateStat} ‘}’
 TemplateStat      ::=  Import
                     |  Export
                     |  {Annotation [nl]} {Modifier} Def
@@ -414,7 +412,7 @@ TemplateStat      ::=  Import
 SelfType          ::=  id [‘:’ InfixType] ‘=>’                                  ValDef(_, name, tpt, _)
                     |  ‘this’ ‘:’ InfixType ‘=>’
 
-EnumBody          ::=  [nl] ‘{’ [SelfType] EnumStat {semi EnumStat} ‘}’
+EnumBody          ::=  [nl | ‘with’] ‘{’ [SelfType] EnumStat {semi EnumStat} ‘}’
 EnumStat          ::=  TemplateStat
                     |  {Annotation [nl]} {Modifier} EnumCase
 EnumCase          ::=  ‘case’ (id ClassConstr [‘extends’ ConstrApps]] | ids)
@@ -428,7 +426,7 @@ TopStat           ::=  Import
                     |  PackageObject
                     |  EndMarker
                     |
-Packaging         ::=  ‘package’ QualId [nl | colonEol] ‘{’ TopStatSeq ‘}’      Package(qid, stats)
+Packaging         ::=  ‘package’ QualId [nl| ‘with’] ‘{’ TopStatSeq ‘}’      Package(qid, stats)
 PackageObject     ::=  ‘package’ ‘object’ ObjectDef                             object with package in mods.
 
 CompilationUnit   ::=  {‘package’ QualId semi} TopStatSeq                       Package(qid, stats)

docs/docs/reference/changed-features/compiler-plugins.md

@@ -62,14 +62,14 @@ import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.plugins.{PluginPhase, StandardPlugin}
 import dotty.tools.dotc.transform.{Pickler, Staging}
 
-class DivideZero extends StandardPlugin:
+class DivideZero extends StandardPlugin with
    val name: String = "divideZero"
    override val description: String = "divide zero check"
 
    def init(options: List[String]): List[PluginPhase] =
       (new DivideZeroPhase) :: Nil
 
-class DivideZeroPhase extends PluginPhase:
+class DivideZeroPhase extends PluginPhase with
    import tpd._
 
    val phaseName = "divideZero"
@@ -108,7 +108,7 @@ import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.plugins.ResearchPlugin
 
-class DummyResearchPlugin extends ResearchPlugin:
+class DummyResearchPlugin extends ResearchPlugin with
    val name: String = "dummy"
    override val description: String = "dummy research plugin"
 

docs/docs/reference/changed-features/implicit-conversions-spec.md

@@ -16,7 +16,7 @@ The standard library defines an abstract class `Conversion`:
 ```scala
 package scala
 @java.lang.FunctionalInterface
-abstract class Conversion[-T, +U] extends Function1[T, U]:
+abstract class Conversion[-T, +U] extends Function1[T, U] with
    def apply(x: T): U
 ```
 

docs/docs/reference/changed-features/main-functions.md

@@ -61,7 +61,7 @@ The Scala compiler generates a program from a `@main` method `f` as follows:
 For instance, the `happyBirthDay` method above would generate additional code equivalent to the following class:
 
 ```scala
-final class happyBirthday:
+final class happyBirthday with
    import scala.util.{CommandLineParser => CLP}
    <static> def main(args: Array[String]): Unit =
       try

docs/docs/reference/changed-features/numeric-literals.md

@@ -130,7 +130,7 @@ class MalformedNumber(msg: String = "malformed number literal") extends FromDigi
 As a fully worked out example, here is an implementation of a new numeric class, `BigFloat`, that accepts numeric literals. `BigFloat` is defined in terms of a `BigInt` mantissa and an `Int` exponent:
 
 ```scala
-case class BigFloat(mantissa: BigInt, exponent: Int):
+case class BigFloat(mantissa: BigInt, exponent: Int) with
    override def toString = s"${mantissa}e${exponent}"
 ```
 
@@ -145,7 +145,7 @@ The companion object of `BigFloat` defines an `apply` constructor method to cons
 from a `digits` string. Here is a possible implementation:
 
 ```scala
-object BigFloat:
+object BigFloat with
    import scala.util.FromDigits
 
    def apply(digits: String): BigFloat =
@@ -206,7 +206,7 @@ To do this, replace the `FromDigits` instance in the `BigFloat` object by the fo
 object BigFloat:
    ...
 
-   class FromDigits extends FromDigits.Floating[BigFloat]:
+   class FromDigits extends FromDigits.Floating[BigFloat] with
       def fromDigits(digits: String) = apply(digits)
 
    given FromDigits with

docs/docs/reference/changed-features/pattern-matching.md

@@ -121,7 +121,7 @@ For example:
 <!-- To be kept in sync with tests/new/patmat-spec.scala -->
 
 ```scala
-class FirstChars(s: String) extends Product:
+class FirstChars(s: String) extends Product with
    def _1 = s.charAt(0)
    def _2 = s.charAt(1)
 
@@ -147,7 +147,7 @@ object FirstChars:
 <!-- To be kept in sync with tests/new/patmat-spec.scala -->
 
 ```scala
-class Nat(val x: Int):
+class Nat(val x: Int) with
    def get: Int = x
    def isEmpty = x < 0
 

docs/docs/reference/changed-features/structural-types.md

@@ -34,13 +34,13 @@ configure how fields and methods should be resolved.
 Here's an example of a structural type `Person`:
 
 ```scala
-  class Record(elems: (String, Any)*) extends Selectable:
+  class Record(elems: (String, Any)*) extends Selectable with
      private val fields = elems.toMap
      def selectDynamic(name: String): Any = fields(name)
 
   type Person = Record { val name: String; val age: Int }
  ```
- 
+
 The type `Person` adds a _refinement_ to its parent type `Record` that defines the two fields `name` and `age`. We say the refinement is _structural_ since  `name` and `age` are not defined in the parent type. But they exist nevertheless as members of class `Person`. For instance, the following
 program would print  "Emma is 42 years old.":
 
@@ -82,10 +82,10 @@ Structural types can also be accessed using [Java reflection](https://www.oracle
 ```scala
   type Closeable = { def close(): Unit }
 
-  class FileInputStream:
+  class FileInputStream with
     def close(): Unit
 
-  class Channel:
+  class Channel with
     def close(): Unit
 ```
 

docs/docs/reference/contextual/context-functions.md

@@ -67,12 +67,12 @@ the aim is to construct tables like this:
 The idea is to define classes for `Table` and `Row` that allow the
 addition of elements via `add`:
 ```scala
-  class Table:
+  class Table with
      val rows = new ArrayBuffer[Row]
      def add(r: Row): Unit = rows += r
      override def toString = rows.mkString("Table(", ", ", ")")
 
-  class Row:
+  class Row with
      val cells = new ArrayBuffer[Cell]
      def add(c: Cell): Unit = cells += c
      override def toString = cells.mkString("Row(", ", ", ")")