Change syntax and Parser to allow extension instances

Author: odersky

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

@@ -931,7 +931,11 @@ object Parsers {
       lookahead.nextToken()
       if lookahead.isIdent && !lookahead.isIdent(nme.on) then
         lookahead.nextToken()
+      if lookahead.isNewLine then
+        lookahead.nextToken()
       lookahead.isIdent(nme.on)
+      || lookahead.token == LBRACE
+      || lookahead.token == COLON
 
 /* --------- OPERAND/OPERATOR STACK --------------------------------------- */
 
@@ -3470,6 +3474,20 @@ object Parsers {
       Template(constr, parents, Nil, EmptyValDef, Nil)
     }
 
+    def checkExtensionMethod(tparams: List[Tree],
+        vparamss: List[List[Tree]], stat: Tree): Unit = stat match {
+      case stat: DefDef =>
+        if stat.mods.is(Extension) && vparamss.nonEmpty then
+          syntaxError(i"no extension method allowed here since leading parameter was already given", stat.span)
+        else if !stat.mods.is(Extension) && vparamss.isEmpty then
+          syntaxError(i"an extension method is required here", stat.span)
+        else if tparams.nonEmpty && stat.tparams.nonEmpty then
+          syntaxError(i"extension method cannot have type parameters since some were already given previously",
+            stat.tparams.head.span)
+      case stat =>
+        syntaxError(i"extension clause can only define methods", stat.span)
+    }
+
     /** GivenDef          ::=  [GivenSig] [‘_’ ‘<:’] Type ‘=’ Expr
      *                      |  [GivenSig] ConstrApps [TemplateBody]
      *  GivenSig          ::=  [id] [DefTypeParamClause] {UsingParamClauses} ‘as’
@@ -3516,20 +3534,25 @@ object Parsers {
       finalizeDef(gdef, mods1, start)
     }
 
-    /** ExtensionDef  ::=  [id] ‘on’ ExtParamClause {UsingParamClause} ExtMethods
+    /** ExtensionDef  ::=  [id] [‘on’ ExtParamClause {UsingParamClause}] TemplateBody
      */
     def extensionDef(start: Offset, mods: Modifiers): ModuleDef =
       in.nextToken()
       val name = if isIdent && !isIdent(nme.on) then ident() else EmptyTermName
       in.endMarkerScope(if name.isEmpty then nme.extension else name) {
-        if !isIdent(nme.on) then syntaxErrorOrIncomplete("`on` expected")
-        if isIdent(nme.on) then in.nextToken()
-        val tparams = typeParamClauseOpt(ParamOwner.Def)
-        val extParams = paramClause(0, prefix = true)
-        val givenParamss = paramClauses(givenOnly = true)
+        val (tparams, vparamss) =
+          if isIdent(nme.on) then
+            in.nextToken()
+            val tparams = typeParamClauseOpt(ParamOwner.Def)
+            val extParams = paramClause(0, prefix = true)
+            val givenParamss = paramClauses(givenOnly = true)
+            (tparams, extParams :: givenParamss)
+          else
+            (Nil, Nil)
         possibleTemplateStart()
         if !in.isNestedStart then syntaxError("Extension without extension methods")
-        val templ = templateBodyOpt(makeConstructor(tparams, extParams :: givenParamss), Nil, Nil)
+        val templ = templateBodyOpt(makeConstructor(tparams, vparamss), Nil, Nil)
+        templ.body.foreach(checkExtensionMethod(tparams, vparamss, _))
         val edef = ModuleDef(name, templ)
         finalizeDef(edef, addFlag(mods, Given), start)
       }

docs/docs/internals/syntax.md

@@ -386,7 +386,8 @@ EnumDef           ::=  id ClassConstr InheritClauses EnumBody
 GivenDef          ::=  [GivenSig] [‘_’ ‘<:’] Type ‘=’ Expr
                     |  [GivenSig] ConstrApps [TemplateBody]
 GivenSig          ::=  [id] [DefTypeParamClause] {UsingParamClause} ‘as’
-ExtensionDef      ::=  [id] ‘on’ ExtParamClause {WithParamsOrTypes} ExtMethods
+ExtensionDef      ::=  [id] [‘on’ ExtParamClause {UsingParamClause}]
+                       TemplateBody
 ExtMethods        ::=  [nl] ‘{’ ‘def’ DefDef {semi ‘def’ DefDef} ‘}’
 ExtParamClause    ::=  [DefTypeParamClause] ‘(’ DefParam ‘)’
 Template          ::=  InheritClauses [TemplateBody]                            Template(constr, parents, self, stats)

tests/pos/reference/extension-methods.scala

@@ -56,14 +56,25 @@ object ExtMethods:
   extension on [T](xs: List[T])(using Ordering[T]):
     def largest(n: Int) = xs.sorted.takeRight(n)
 
-  given stringOps1 as AnyRef {
+  extension ops:
+    def (xs: Seq[String]).longestStrings: Seq[String] =
+      val maxLength = xs.map(_.length).max
+      xs.filter(_.length == maxLength)
+    def (xs: Seq[String]).longestString: String = xs.longestStrings.head
+    def [T](xs: List[T]).second: T = xs.tail.head
+
+  extension:
+    def [T](xs: List[T]) longest (using Ordering[T])(n: Int) =
+      xs.sorted.takeRight(n)
+
+  given stringOps2 as AnyRef {
     def (xs: Seq[String]).longestStrings: Seq[String] = {
       val maxLength = xs.map(_.length).max
       xs.filter(_.length == maxLength)
     }
   }
 
-  given listOps1 as AnyRef {
+  given listOps2 as AnyRef {
     def [T](xs: List[T]) second = xs.tail.head
     def [T](xs: List[T]) third: T = xs.tail.tail.head
   }

tests/run/extmethod-overload.scala

@@ -22,13 +22,13 @@ object Test extends App {
   // Test with extension methods in given object
   object test1 {
 
-    given Foo as AnyRef {
+    extension Foo:
       def (x: Int) |+| (y: Int) = x + y
       def (x: Int) |+| (y: String) = x + y.length
 
       def [T](xs: List[T]) +++ (ys: List[T]): List[T] = xs ++ ys ++ ys
       def [T](xs: List[T]) +++ (ys: Iterator[T]): List[T] = xs ++ ys ++ ys
-    }
+    end Foo
 
     assert((1 |+| 2) == 3)
     assert((1 |+| "2") == 2)

tests/run/instances.scala

@@ -31,10 +31,8 @@ object Test extends App {
   extension listListOps on [T](xs: List[List[T]]):
     def flattened = xs.foldLeft[List[T]](Nil)(_ ++ _)
 
-  // A right associative op. Note: can't use given extension for this!
-  given prepend as AnyRef {
+  extension prepend:
     def [T](x: T) :: (xs: Seq[T]) = x +: xs
-  }
 
   val ss: Seq[Int] = List(1, 2, 3)
   val ss1 = 0 :: ss