Change syntax of instance declarations

odersky · odersky · commit f8bd21ae5f1d · 2018-03-14T15:42:24.000+01:00
- Use `:` instead of `implements`.

Still todo: Make the `:` context constraint abstract over such instance declarations.
diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -773,13 +773,17 @@ object desugar {
   }
 
   private val collectNames = new untpd.UntypedTreeAccumulator[ListBuffer[String]] {
+    def add(buf: ListBuffer[String], name: Name): ListBuffer[String] = {
+      val alpha = name.toString.filter(isIdentifierPart)
+      if (alpha.isEmpty) buf else buf += alpha
+    }
     override def apply(buf: ListBuffer[String], tree: Tree)(implicit ctx: Context): ListBuffer[String] = tree match {
       case Ident(name) =>
-        buf += name.toString
+        add(buf, name)
       case Select(qual, name) =>
-        apply(buf, qual) += name.toString
+        add(apply(buf, qual), name)
       case TypeDef(name, rhs) =>
-        apply(buf += "type" += name.toString, rhs)
+        apply(add(buf += "type", name), rhs)
       case Apply(fn, _) =>
         apply(buf, fn)
       case _ =>
@@ -790,12 +794,11 @@ object desugar {
   private def extensionName(ext: Extension)(implicit ctx: Context): TypeName = {
     var buf = collectNames(new ListBuffer[String] += "extend", ext.extended)
     if (ext.impl.parents.nonEmpty)
-      buf = collectNames(buf += "implements", ext.impl.parents)
-    val ids = buf.toList.map(_.filter(isIdentifierPart)).filter(!_.isEmpty)
-    ids.mkString("_").toTypeName
+      buf = collectNames(buf += "", ext.impl.parents)
+    buf.toList.mkString("_").toTypeName
   }
 
-  /**     extend <type-pattern> <params> implements <parents> { <body>} }
+  /**     extend <type-pattern> <params> : <parents> { <body>} }
    *   ->
    *      implicit class <extension-name> <type-params> ($this: <extended>) <combined-params>
    *      extends <parents> { <body1> }
@@ -855,7 +858,7 @@ object desugar {
 
     val mods =
       if (isSimpleExtension) EmptyModifiers
-      else EmptyModifiers.withAddedMod(Mod.TraitImplementation())
+      else EmptyModifiers.withAddedMod(Mod.InstanceDecl())
     val icls =
       TypeDef(extName,
         cpy.Template(impl)(constr = constr1, parents = parents1, body = body1))
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -143,7 +143,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
     case class EnumCase() extends Mod(Flags.EmptyFlags)
 
-    case class TraitImplementation() extends Mod(Flags.EmptyFlags)
+    case class InstanceDecl() extends Mod(Flags.EmptyFlags)
   }
 
   /** Modifiers and annotations for definitions
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -2306,20 +2306,20 @@ object Parsers {
     /** Extension          ::=  ‘extend’ BindingTypePattern
      *                          [[nl] ImplicitParamClause] ExtensionClause
      *  BindingTypePattern ::=  AnnotType
-     *  ExtensionClause    ::=  ‘implements’ Template
+     *  ExtensionClause    ::=  : Template
      *                       |  [nl] ‘{’ ‘def’ DefDef {semi ‘def’ DefDef} ‘}’
      */
     def extension(): Extension = atPos(in.skipToken(), nameStart) {
       val extended = withinTypePattern(binding = true)(annotType())
       val vparamss = paramClauses(tpnme.EMPTY, ofExtension = true).take(1)
       val constr = makeConstructor(Nil, vparamss)
       val templ =
-        if (in.token == IMPLEMENTS) {
+        if (in.token == COLON) {
           in.nextToken()
           template(constr, bodyRequired = true)._1
         }
         else {
-          if (in.token == EXTENDS) syntaxError("`implements` or `{` expected")
+          if (in.token == EXTENDS) syntaxError("`:` or `{` expected")
           val templ = templateClauseOpt(constr, bodyRequired = true)
           def checkDef(tree: Tree) = tree match {
             case _: DefDef | EmptyValDef => // ok
diff --git a/compiler/src/dotty/tools/dotc/parsing/Tokens.scala b/compiler/src/dotty/tools/dotc/parsing/Tokens.scala
@@ -180,7 +180,6 @@ object Tokens extends TokensCommon {
   final val ERASED = 64;           enter(ERASED, "erased")
   final val OPAQUE = 65;           enter(OPAQUE, "opaque")
   final val EXTEND = 66;           enter(EXTEND, "extend")
-  final val IMPLEMENTS = 67;       enter(IMPLEMENTS, "implements")
 
   /** special symbols */
   final val NEWLINE = 78;          enter(NEWLINE, "end of statement", "new line")
@@ -201,7 +200,7 @@ object Tokens extends TokensCommon {
   /** XML mode */
   final val XMLSTART = 96;         enter(XMLSTART, "$XMLSTART$<") // TODO: deprecate
 
-  final val alphaKeywords = tokenRange(IF, IMPLEMENTS)
+  final val alphaKeywords = tokenRange(IF, EXTEND)
   final val symbolicKeywords = tokenRange(USCORE, VIEWBOUND)
   final val symbolicTokens = tokenRange(COMMA, VIEWBOUND)
   final val keywords = alphaKeywords | symbolicKeywords
diff --git a/compiler/src/dotty/tools/dotc/typer/Namer.scala b/compiler/src/dotty/tools/dotc/typer/Namer.scala
@@ -944,7 +944,7 @@ class Namer { typer: Typer =>
         if (cls.isRefinementClass) ptype
         else {
           val pt = checkClassType(ptype, parent.pos,
-              traitReq = (parent `ne` parents.head) || original.mods.hasMod[Mod.TraitImplementation],
+              traitReq = (parent `ne` parents.head) || original.mods.hasMod[Mod.InstanceDecl],
               stablePrefixReq = true)
           if (pt.derivesFrom(cls)) {
             val addendum = parent match {
diff --git a/docs/docs/reference/extend/instance-declarations.md b/docs/docs/reference/extend/instance-declarations.md
@@ -1,21 +1,21 @@
 ---
 layout: doc-page
-title: "Extension Implementations"
+title: "Instance Declarations"
 ---
 
-In addition to adding methods, an extension can also implement traits and classes. For instance,
+In addition to adding methods, an extension can also implement traits. Extensions implementing traits are also called _instance declarations_. For example,
 
 ```scala
 trait HasArea {
   def area: Double
 }
 
-extend Circle implements HasArea {
+extend Circle : HasArea {
   def area = this.radius * this.radius * math.Pi
 }
 ```
 
-This extension makes `Circle` implement the `HasArea` trait. Specifically, it defines an implicit subclass of `HasArea`
+This extension makes `Circle` an instance of the `HasArea` trait. Specifically, it defines an implicit subclass of `HasArea`
 which takes a `Circle` as argument and provides the given implementation. Hence, the implementation of the extension above would be like this
 
 ```scala
@@ -24,11 +24,11 @@ implicit class circleOps($this: Circle) extends HasArea {
 }
 ```
 
-An extension implementation can thus provide a kind of "implements" relationship that can be defined independently of the types it connects.
+An instance definition can thus provide a kind of "implements" relationship that can be defined independently of the types it connects.
 
-### Adding Implementations to Generic Traits
+### Generic Instance Declarations
 
-Just like extension methods, extension implementations can also be generic and their type parameters can have bounds.
+Just like extension methods, instance declarations can also be generic and their type parameters can have bounds.
 
 For example, assume we have the following two traits, which define binary and unary (infix) equality tests:
 
@@ -45,18 +45,20 @@ trait HasEql[T] {
 The following extension makes any type `T` with an implicit `Eql[T]` instance implement `HasEql`:
 
 ```scala
-extend (type T: Eql) implements HasEql[T] {
+extend (type T : Eql) : HasEql[T] {
   def === (that: T): Boolean = implicitly[Eql[T]].eql(this, that)
 }
 ```
 
+
+
 ### Syntax of Extensions
 
 The syntax of extensions is specified below as a delta with respect to the Scala syntax given [here](http://dotty.epfl.ch/docs/internals/syntax.html)
 
     Extension           ::=  ‘extend’ BindingTypePattern
                              [[nl] ImplicitParamClause] ExtensionClause
-    ExtensionClause     ::=  ‘implements’ Template
+    ExtensionClause     ::=  ‘:’ Template
                           |  [nl] ‘{’ ‘def’ DefDef {semi ‘def’ DefDef} ‘}’
 
     ImplicitParamClause ::=  [nl] ‘(’ ImplicitMods ClsParams ‘)’
diff --git a/docs/docs/reference/extend/translation.md b/docs/docs/reference/extend/translation.md
@@ -5,7 +5,7 @@ title: "Translation of Extensions"
 
 Extensons are closely related to implicit classes and can be translated into them. In short,
 an extension that just adds extension methods translates into an implicit value class whereas
-an extension with an `implements` clause translates
+an instance declaration translates
 into a regular implicit class. The following sections sketch this translation.
 
 Conversely, it is conceivable (and desirable) to replace most usages of implicit classes and value classes by extensions and [opaque types](../opaques.html). We plan to [drop](../dropped/implicit-value-classes.html)
@@ -31,7 +31,9 @@ Extensions are anonymous -- the first identifier given in an extension designate
  2. Drop an implicit parameter list if one is given and also drop any value arguments to parent constructors.
  3. Drop any tokens that are not keywords of identifiers.
  4. In each token resulting from the previous step, drop all characters that are not legal parts of alphanumeric identifiers. This leaves all characters that satisfy the `java.lang.Character.isUnicodeIdentifierPart` predicate as well as `$`. Among Ascii characters, the retained characters are all letters, digits, as well as `_` and `$`.
- 5. Concatenate all non-empty strings resulting from the previous step with `_` separators.
+ 5. Concatenate all non-empty strings resulting from the previous step with `_` separators,
+    except use `__` (i.e. two underscores) between identifiers coming from the type pattern
+    and identifiers coming from the implemented traits (if there are any).
 
 It is an error if two extensions defined in the same scope have the same computed name. These double definition errors can always be avoided by grouping augments together or, as a last resort, defining suitable type aliases. The scheme gives stable names that do not depend on the order in which definitions are given.
 
@@ -69,11 +71,11 @@ implicit class extend_Seq_type_T_math_Ordering [T]($this: List[T]) extends AnyVa
 }
 ```
 
-### Translation of Extension Implementations
+### Translation of Instance Declarations
 
 Now, assume an extension
 
-    extend <TP> <params> implements <parents> { <body> }
+    extend <TP> <params> : <parents> { <body> }
 
 Let again `(<tparams>, <T>)` be the decomposition of `<TP>`. This extension is translated to
 
@@ -87,15 +89,15 @@ parameterized.
 For example, the extension
 
 ```scala
-extend (type T: Eql) implements HasEql[T] {
+extend (type T: Eql) : HasEql[T] {
   def === (that: T): Boolean = implicitly[Eql[T]].eql(this, that)
 }
 ```
 
 would be translated to
 
 ```scala
-implicit class extend_type_T_Eql_implements_HasEql_T [T]
+implicit class extend_type_T_Eql__HasEql_T [T]
                   ($this: T)(implicit $ev: Eql[T]) extends HasEql[T] {
     def === (that: T): Boolean = implicitly[Eql[T]].eql($this, that)
   }
diff --git a/docs/sidebar.yml b/docs/sidebar.yml
@@ -33,8 +33,8 @@ sidebar:
           subsection:
             - title: Extension Methods
               url: docs/reference/extend/extension-methods.html
-            - title: Extension Implementations
-              url: docs/reference/extend/extension-implementations.html
+            - title: Instance Declarations
+              url: docs/reference/extend/instance-declarations.html
             - title: Translation of Extensions
               url: docs/reference/extend/translation.html
         - title: Enums
diff --git a/tests/neg/extensions.scala b/tests/neg/extensions.scala
@@ -24,13 +24,13 @@ object extensions {
 
   abstract class HasAreaClass extends HasArea
 
-  extend Circle implements HasArea {
+  extend Circle : HasArea {
     def area = this.radius * this.radius * math.Pi
   }
 
-  extend Circle2 extends HasArea {} // error: `implements` or `{` expected // error: `def` expected
+  extend Circle2 extends HasArea {} // error: `:` or `{` expected // error: `def` expected
 
-  extend Circle implements HasAreaClass { // error: class HasAreaClass is not a trait
+  extend Circle : HasAreaClass { // error: class HasAreaClass is not a trait
     def area = this.radius * this.radius * math.Pi
   }
 
diff --git a/tests/run/extensions.scala b/tests/run/extensions.scala
@@ -15,7 +15,7 @@ object extensions {
     def area: Double
   }
 
-  extend Circle implements HasArea {
+  extend Circle : HasArea {
     def area = this.radius * this.radius * math.Pi
   }
 
@@ -63,15 +63,15 @@ object extensions {
     def === (that: T): Boolean
   }
 
-  extend (type S: Eql) implements HasEql[S] {
+  extend (type S : Eql) : HasEql[S] {
     def === (that: S): Boolean = implicitly[Eql[S]].eql(this, that)
   }
 
   extend (type T2)(implicit ev: Eql[T2]) {
     def ==== (that: T2): Boolean = implicitly[Eql[T2]].eql(this, that)
   }
 
-  extend Rectangle[type T: Eql] implements HasEql[Rectangle[T]] {
+  extend Rectangle[type T : Eql] : HasEql[Rectangle[T]] {
     def === (that: Rectangle[T]) =
       this.x === that.x &&
       this.y === that.y &&
@@ -81,16 +81,16 @@ object extensions {
 }
 
 object extensions2 {
-  import extensions.{Eql, extend_type_S_Eql_S_implements_HasEql_S}
+  import extensions.{Eql, extend_type_S_Eql_S__HasEql_S}
   // Nested generic arguments
 
   extend List[List[type U]] {
     def flattened: List[U] = (this :\ (Nil: List[U]))(_ ++ _)
   }
 
-  extend (type T: Eql, T) {
+  extend (type T : Eql, T) {
     def isSame = this._1 === this._2
-    def isSame2 = extend_type_S_Eql_S_implements_HasEql_S(this._1) == this._2
+    def isSame2 = extend_type_S_Eql_S__HasEql_S(this._1) == this._2
   }
 
 }

Original file line number	Diff line number	Diff line change
`@@ -143,7 +143,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {`
`143`	`143`
`144`	`144`	`case class EnumCase() extends Mod(Flags.EmptyFlags)`
`145`	`145`
`146`		`- case class TraitImplementation() extends Mod(Flags.EmptyFlags)`
	`146`	`+ case class InstanceDecl() extends Mod(Flags.EmptyFlags)`
`147`	`147`	`}`
`148`	`148`
`149`	`149`	`/** Modifiers and annotations for definitions`
Original file line number	Diff line number	Diff line change
`@@ -24,13 +24,13 @@ object extensions {`
`24`	`24`
`25`	`25`	`abstract class HasAreaClass extends HasArea`
`26`	`26`
`27`		`- extend Circle implements HasArea {`
	`27`	`+ extend Circle : HasArea {`
`28`	`28`	`def area = this.radius * this.radius * math.Pi`
`29`	`29`	`}`
`30`	`30`
`31`		- extend Circle2 extends HasArea {} // error: `implements` or `{` expected // error: `def` expected
	`31`	+ extend Circle2 extends HasArea {} // error: `:` or `{` expected // error: `def` expected
`32`	`32`
`33`		`- extend Circle implements HasAreaClass { // error: class HasAreaClass is not a trait`
	`33`	`+ extend Circle : HasAreaClass { // error: class HasAreaClass is not a trait`
`34`	`34`	`def area = this.radius * this.radius * math.Pi`
`35`	`35`	`}`
`36`	`36`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ object extensions {`
`15`	`15`	`def area: Double`
`16`	`16`	`}`
`17`	`17`
`18`		`- extend Circle implements HasArea {`
	`18`	`+ extend Circle : HasArea {`
`19`	`19`	`def area = this.radius * this.radius * math.Pi`
`20`	`20`	`}`
`21`	`21`
`@@ -63,15 +63,15 @@ object extensions {`
`63`	`63`	`def === (that: T): Boolean`
`64`	`64`	`}`
`65`	`65`
`66`		`- extend (type S: Eql) implements HasEql[S] {`
	`66`	`+ extend (type S : Eql) : HasEql[S] {`
`67`	`67`	`def === (that: S): Boolean = implicitly[Eql[S]].eql(this, that)`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`extend (type T2)(implicit ev: Eql[T2]) {`
`71`	`71`	`def ==== (that: T2): Boolean = implicitly[Eql[T2]].eql(this, that)`
`72`	`72`	`}`
`73`	`73`
`74`		`- extend Rectangle[type T: Eql] implements HasEql[Rectangle[T]] {`
	`74`	`+ extend Rectangle[type T : Eql] : HasEql[Rectangle[T]] {`
`75`	`75`	`def === (that: Rectangle[T]) =`
`76`	`76`	`this.x === that.x &&`
`77`	`77`	`this.y === that.y &&`
`@@ -81,16 +81,16 @@ object extensions {`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`object extensions2 {`
`84`		`- import extensions.{Eql, extend_type_S_Eql_S_implements_HasEql_S}`
	`84`	`+ import extensions.{Eql, extend_type_S_Eql_S__HasEql_S}`
`85`	`85`	`// Nested generic arguments`
`86`	`86`
`87`	`87`	`extend List[List[type U]] {`
`88`	`88`	`def flattened: List[U] = (this :\ (Nil: List[U]))(_ ++ _)`
`89`	`89`	`}`
`90`	`90`
`91`		`- extend (type T: Eql, T) {`
	`91`	`+ extend (type T : Eql, T) {`
`92`	`92`	`def isSame = this._1 === this._2`
`93`		`- def isSame2 = extend_type_S_Eql_S_implements_HasEql_S(this._1) == this._2`
	`93`	`+ def isSame2 = extend_type_S_Eql_S__HasEql_S(this._1) == this._2`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`}`