Require that non-extending augments only add extension methods

Author: odersky

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -2154,7 +2154,7 @@ object Types {
       if (ctx.erasedTypes) tref
       else cls.info match {
         case cinfo: ClassInfo => cinfo.selfType
-        case cinfo: ErrorType if ctx.mode.is(Mode.Interactive) => cinfo
+        case _: ErrorType | NoType if ctx.mode.is(Mode.Interactive) => cls.info
           // can happen in IDE if `cls` is stale
       }
 

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

@@ -2304,14 +2304,25 @@ object Parsers {
     }
 
     /** Augmentation       ::=  ‘augment’ BindingTypePattern
-     *                          [[nl] ImplicitParamClause] TemplateClause
+     *                          [[nl] ImplicitParamClause] Additions
      *  BindingTypePattern ::=  AnnotType
+     *  Additions         ::=  ‘extends’ Template
+     *                      |  [nl] ‘{’ ‘def’ DefDef {semi ‘def’ DefDef} ‘}’
      */
     def augmentation(): Augment = atPos(in.skipToken(), nameStart) {
       val augmented = withinTypePattern(binding = true)(annotType())
       val vparamss = paramClauses(tpnme.EMPTY, ofAugmentation = true).take(1)
       val constr = makeConstructor(Nil, vparamss)
+      val isSimpleExtension = in.token != EXTENDS
       val templ = templateClauseOpt(constr, bodyRequired = true)
+      if (isSimpleExtension) {
+        def checkDef(tree: Tree) = tree match {
+          case _: DefDef | EmptyValDef => // ok
+          case _ => syntaxError("`def` expected", tree.pos.startPos)
+        }
+        checkDef(templ.self)
+        templ.body.foreach(checkDef)
+      }
       Augment(augmented, templ)
     }
 

docs/docs/internals/syntax.md

@@ -248,7 +248,9 @@ ArgumentPatterns  ::=  ‘(’ [Patterns] ‘)’
                     |  ‘(’ [Patterns ‘,’] Pattern2 ‘:’ ‘_’ ‘*’ ‘)’
 
 Augmentation      ::=  ‘augment’ BindingTypePattern
-                       [[nl] ImplicitParamClause] TemplateClause                Augment(name, templ)
+                       [[nl] ImplicitParamClause] AugmentClause                 Augment(name, templ)
+AugmentClause     ::=  ‘extends’ Template
+                    |  [nl] ‘{’ ‘def’ DefDef {semi ‘def’ DefDef} ‘}’
 BindingTypePattern::=  AnnotType
 ```
 

tests/neg/augment.scala

@@ -0,0 +1,111 @@
+import Predef.{any2stringadd => _, _}
+object augments {
+
+// Simple extension methods
+
+  case class Circle(x: Double, y: Double, radius: Double)
+
+  augment Circle {
+    def circumference = this.radius * math.Pi * 2
+    private val p = math.Pi       // error: `def` expected
+  }
+
+// Trait implementations
+
+  trait HasArea {
+    def area: Double
+  }
+
+  augment Circle extends HasArea {
+    def area = this.radius * this.radius * math.Pi
+  }
+
+// Generic trait implementations
+
+  augment List[type T] {
+    type I = Int                 // error: `def` expected
+    def second = this.tail.head
+  }
+
+// Specific trait implementations
+
+  augment List[Int] {
+    import java.lang._
+    def maxx = (0 /: this)(_ `max` _)
+  }
+
+  augment Array[Int] {
+    def maxx = (0 /: this)(_ `max` _)
+  }
+
+// Conditional extension methods
+
+  case class Rectangle[T](x: T, y: T, width: T, height: T)
+
+  trait Eql[T] {
+    def eql (x: T, y: T): Boolean
+  }
+
+  augment Rectangle[type T: Eql] {
+    def isSquare: Boolean = implicitly[Eql[T]].eql(this.width, this.height)
+  }
+
+// Simple generic augments
+
+  augment (type T) {
+    def ~[U](that: U): (T, U) = (this, that)
+  }
+
+// Conditional generic augments
+
+  trait HasEql[T] {
+    def === (that: T): Boolean
+  }
+
+  augment (type T: Eql) extends HasEql[T] {
+    def === (that: T): Boolean = implicitly[Eql[T]].eql(this, that)
+  }
+
+  augment Rectangle[type T: Eql] extends HasEql[Rectangle[T]] {
+    def === (that: Rectangle[T]) =
+      this.x === that.x &&
+      this.y === that.y &&
+      this.width == that.width &&
+      this.height == that.height
+  }
+
+// Generic augments with additional parameters
+
+  augment List[List[type U]] {
+    def flattened: List[U] = (this :\ (Nil: List[U]))(_ ++ _)
+  }
+
+  augment (type T: Eql, T) {
+    def isSame = this._1 === this._2
+  }
+}
+
+import augments._
+object Test extends App {
+  val c = Circle(0, 1, 2)
+  println(c.area)
+
+  implicit object IntHasEql extends Eql[Int] {
+    def eql (x: Int, y: Int): Boolean = x == y
+  }
+
+  println(1 ~ "a")
+
+  val r1 = Rectangle(0, 0, 2, 2)
+  val r2 = Rectangle(0, 0, 2, 3)
+  println(r1.isSquare)
+  println(r2.isSquare)
+  println(r1 === r1)
+  println(r1 === r2)
+  println(List(1, 2, 3).second)
+  println(List(List(1), List(2, 3)).flattened)
+  println(List(List(1), List(2, 3)).flattened.maxx)
+  println(Array(1, 2, 3).maxx)
+  println((2, 3).isSame)
+  println((3, 3).isSame)
+}