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(", ", ", ")")