Merge pull request #7455 from dotty-staging/change-extmethod-tparams

Syntax change for type parameters of extension methods

Author: odersky

compiler/src/dotty/tools/dotc/ast/Positioned.scala

@@ -208,16 +208,13 @@ abstract class Positioned(implicit @constructorOnly src: SourceFile) extends Pro
       case tree: DefDef if tree.mods.is(Extension) =>
         tree.vparamss match {
           case vparams1 :: vparams2 :: rest if !isLeftAssoc(tree.name) =>
-            check(vparams2)
             check(tree.tparams)
+            check(vparams2)
             check(vparams1)
             check(rest)
-          case vparams1 :: rest =>
-            check(vparams1)
-            check(tree.tparams)
-            check(rest)
           case _ =>
             check(tree.tparams)
+            check(tree.vparamss)
         }
         check(tree.tpt)
         check(tree.rhs)

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -754,9 +754,10 @@ object Trees {
     def unforced: LazyTree[T] = preRhs
     protected def force(x: Tree[T @uncheckedVariance]): Unit = preRhs = x
 
-    override def disableOverlapChecks = rawMods.is(Given)
-      // disable order checks for implicit aliases since their given clause follows
-      // their for clause, but the two appear swapped in the DefDef.
+    override def disableOverlapChecks = rawMods.is(Extension)
+      // disable order checks for extension methods as long as we parse
+      // type parameters both before and after the leading parameter section.
+      // TODO drop this once syntax of type parameters has settled.
   }
 
   /** mods class name template     or
@@ -789,10 +790,6 @@ object Trees {
 
     def parents: List[Tree[T]] = parentsOrDerived // overridden by DerivingTemplate
     def derived: List[untpd.Tree] = Nil           // overridden by DerivingTemplate
-
-    override def disableOverlapChecks = true
-      // disable overlaps checks since templates of instance definitions have their
-      // `given` clause come last, which means that the constructor span can contain the parent spans.
   }
 
 

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

@@ -170,8 +170,8 @@ object Decorators {
       }
   }
 
-  implicit object reportDeco {
-    def (x: T) reporting[T](
+  implicit class reportDeco[T](x: T) extends AnyVal {
+    def reporting(
         op: (given WrappedResult[T]) => String,
         printer: config.Printers.Printer = config.Printers.default): T = {
       printer.println(op(given WrappedResult(x)))

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

@@ -3089,10 +3089,11 @@ object Parsers {
       }
     }
 
-    /** DefDef ::= DefSig [(‘:’ | ‘<:’) Type] ‘=’ Expr
-     *           | this ParamClause ParamClauses `=' ConstrExpr
-     *  DefDcl ::= DefSig `:' Type
-     *  DefSig ::= [‘(’ DefParam ‘)’ [nl]] id [DefTypeParamClause] ParamClauses
+    /** DefDef  ::=  DefSig [(‘:’ | ‘<:’) Type] ‘=’ Expr
+     *            |  this ParamClause ParamClauses `=' ConstrExpr
+     *  DefDcl  ::=  DefSig `:' Type
+     *  DefSig  ::=  id [DefTypeParamClause] DefParamClauses
+     *            |  ExtParamClause [nl] id DefParamClauses
      */
     def defDefOrDcl(start: Offset, mods: Modifiers): Tree = atSpan(start, nameStart) {
       def scala2ProcedureSyntax(resultTypeStr: String) = {
@@ -3121,27 +3122,35 @@ object Parsers {
         makeConstructor(Nil, vparamss, rhs).withMods(mods).setComment(in.getDocComment(start))
       }
       else {
-        val (leadingParamss, flags) =
-          if (in.token == LPAREN)
-            try (paramClause(0, prefix = true) :: Nil, Method | Extension)
-            finally newLineOpt()
+        def extParamss() = try paramClause(0, prefix = true) :: Nil finally newLineOpt()
+        val (leadingTparams, leadingVparamss, flags) =
+          if in.token == LBRACKET then
+            (typeParamClause(ParamOwner.Def), extParamss(), Method | Extension)
+          else if in.token == LPAREN then
+            (Nil, extParamss(), Method | Extension)
           else
-            (Nil, Method)
+            (Nil, Nil, Method)
         val mods1 = addFlag(mods, flags)
         val ident = termIdent()
         val name = ident.name.asTermName
-        val tparams = typeParamClauseOpt(ParamOwner.Def)
-        val vparamss = paramClauses() match {
-          case rparams :: rparamss if leadingParamss.nonEmpty && !isLeftAssoc(ident.name) =>
-            rparams :: leadingParamss ::: rparamss
+        val tparams =
+          if in.token == LBRACKET then
+            if flags.is(Extension) then
+              if leadingTparams.isEmpty then
+                deprecationWarning("type parameters in extension methods should be written after `def`")
+              else
+                syntaxError("no type parameters allowed here")
+            typeParamClause(ParamOwner.Def)
+          else leadingTparams
+        val vparamss = paramClauses() match
+          case rparams :: rparamss if leadingVparamss.nonEmpty && !isLeftAssoc(ident.name) =>
+            rparams :: leadingVparamss ::: rparamss
           case rparamss =>
-            leadingParamss ::: rparamss
-        }
+            leadingVparamss ::: rparamss
         var tpt = fromWithinReturnType {
-          if (in.token == SUBTYPE && mods.is(Inline)) {
+          if in.token == SUBTYPE && mods.is(Inline) then
             in.nextToken()
             TypeBoundsTree(EmptyTree, toplevelTyp())
-          }
           else typedOpt()
         }
         if (in.isScala2Mode) newLineOptWhenFollowedBy(LBRACE)

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -141,7 +141,8 @@ class CompilationTests extends ParallelTesting {
       compileFile("tests/neg-custom-args/infix.scala", defaultOptions.and("-strict", "-deprecation", "-Xfatal-warnings")),
       compileFile("tests/neg-custom-args/missing-alpha.scala", defaultOptions.and("-strict", "-deprecation", "-Xfatal-warnings")),
       compileFile("tests/neg-custom-args/wildcards.scala", defaultOptions.and("-strict", "-deprecation", "-Xfatal-warnings")),
-      compileFile("tests/neg-custom-args/indentRight.scala", defaultOptions.and("-noindent", "-Xfatal-warnings"))
+      compileFile("tests/neg-custom-args/indentRight.scala", defaultOptions.and("-noindent", "-Xfatal-warnings")),
+      compileFile("tests/neg-custom-args/extmethods-tparams.scala", defaultOptions.and("-deprecation", "-Xfatal-warnings"))
     ).checkExpectedErrors()
   }
 

docs/docs/internals/syntax.md

@@ -357,8 +357,8 @@ Dcl               ::=  RefineDcl
 ValDcl            ::=  ids ‘:’ Type                                             PatDef(_, ids, tpe, EmptyTree)
 VarDcl            ::=  ids ‘:’ Type                                             PatDef(_, ids, tpe, EmptyTree)
 DefDcl            ::=  DefSig ‘:’ Type                                          DefDef(_, name, tparams, vparamss, tpe, EmptyTree)
-DefSig            ::=  [‘(’ DefParam ‘)’ [nl]] id
-                       [DefTypeParamClause] DefParamClauses
+DefSig            ::=  id [DefTypeParamClause] DefParamClauses
+                    |  ExtParamClause [nl] id DefParamClauses
 TypeDcl           ::=  id [TypeParamClause] SubtypeBounds [‘=’ Type]           TypeDefTree(_, name, tparams, bound
 
 Def               ::=  ‘val’ PatDef

docs/docs/reference/contextual/extension-methods.md

@@ -94,7 +94,7 @@ given stringOps: {
 }
 
 given {
-  def (xs: List[T]) second[T] = xs.tail.head
+  def [T](xs: List[T]) second = xs.tail.head
 }
 ```
 If such given instances are anonymous (as in the second clause), their name is synthesized from the name of the first defined extension method.
@@ -106,8 +106,8 @@ as well as any type parameters of these extension methods into the given instanc
 For instance, here is a given instance with two extension methods.
 ```scala
 given listOps: {
-  def (xs: List[T]) second[T]: T = xs.tail.head
-  def (xs: List[T]) third[T]: T = xs.tail.tail.head
+  def [T](xs: List[T]) second: T = xs.tail.head
+  def [T](xs: List[T]) third: T = xs.tail.tail.head
 }
 ```
 The repetition in the parameters can be avoided by hoisting the parameters up into the given instance itself. The following version is a shorthand for the code above.
@@ -151,26 +151,28 @@ to the implementation of right binding operators as normal methods.
 The `StringSeqOps` examples extended a specific instance of a generic type. It is also possible to extend a generic type by adding type parameters to an extension method. Examples:
 
 ```scala
-def (xs: List[T]) second [T] =
+def [T](xs: List[T]) second =
   xs.tail.head
 
-def (xs: List[List[T]]) flattened [T] =
+def [T](xs: List[List[T]]) flattened =
   xs.foldLeft[List[T]](Nil)(_ ++ _)
 
-def (x: T) + [T : Numeric](y: T): T =
+def [T: Numeric](x: T) + (y: T): T =
   summon[Numeric[T]].plus(x, y)
 ```
 
-As usual, type parameters of the extension method follow the defined method name. Nevertheless, such type parameters can already be used in the preceding parameter clause.
-
+If an extension method has type parameters, they come immediately after the `def` and are followed by the extended parameter. When calling a  generic extension method, any explicitly given type arguments follow the method name. So the `second` method can be instantiated as follows:
+```scala
+List(1, 2, 3).second[Int]
+```
 
 ### Syntax
 
 The required syntax extension just adds one clause for extension methods relative
 to the [current syntax](../../internals/syntax.md).
 ```
 DefSig            ::=  ...
-                    |  ‘(’ DefParam ‘)’ [nl] id [DefTypeParamClause] DefParamClauses
+                    |  ExtParamClause [nl] id DefParamClauses
 GivenDef          ::=  ...
                        [GivenSig ‘:’] [ExtParamClause] TemplateBody
 ExtParamClause    ::=  [DefTypeParamClause] ‘(’ DefParam ‘)’ {GivenParamClause}

docs/docs/reference/contextual/typeclasses.md

@@ -38,25 +38,25 @@ def sum[T: Monoid](xs: List[T]): T =
 
 ```scala
 trait Functor[F[_]] {
-  def (x: F[A]) map [A, B] (f: A => B): F[B]
+  def [A, B](x: F[A]) map (f: A => B): F[B]
 }
 
 trait Monad[F[_]] extends Functor[F] {
-  def (x: F[A]) flatMap [A, B] (f: A => F[B]): F[B]
-  def (x: F[A]) map [A, B] (f: A => B) = x.flatMap(f `andThen` pure)
+  def [A, B](x: F[A]) flatMap (f: A => F[B]): F[B]
+  def [A, B](x: F[A]) map (f: A => B) = x.flatMap(f `andThen` pure)
 
   def pure[A](x: A): F[A]
 }
 
 given listMonad: Monad[List] {
-  def (xs: List[A]) flatMap [A, B] (f: A => List[B]): List[B] =
+  def [A, B](xs: List[A]) flatMap (f: A => List[B]): List[B] =
     xs.flatMap(f)
   def pure[A](x: A): List[A] =
     List(x)
 }
 
 given readerMonad[Ctx]: Monad[[X] =>> Ctx => X] {
-  def (r: Ctx => A) flatMap [A, B] (f: A => Ctx => B): Ctx => B =
+  def [A, B](r: Ctx => A) flatMap (f: A => Ctx => B): Ctx => B =
     ctx => f(r(ctx))(ctx)
   def pure[A](x: A): Ctx => A =
     ctx => x

library/src-bootstrapped/scala/IArray.scala

@@ -23,8 +23,8 @@ object opaques {
     def (arr: IArray[Long]) apply (n: Int): Long = arr.asInstanceOf[Array[Long]].apply(n)
     def (arr: IArray[Float]) apply (n: Int): Float = arr.asInstanceOf[Array[Float]].apply(n)
     def (arr: IArray[Double]) apply (n: Int): Double = arr.asInstanceOf[Array[Double]].apply(n)
-    def (arr: IArray[T]) apply[T <: Object] (n: Int): T = arr.asInstanceOf[Array[T]].apply(n)
-    def (arr: IArray[T]) apply[T] (n: Int): T = arr.asInstanceOf[Array[T]].apply(n)
+    def [T <: Object](arr: IArray[T]) apply (n: Int): T = arr.asInstanceOf[Array[T]].apply(n)
+    def [T](arr: IArray[T]) apply (n: Int): T = arr.asInstanceOf[Array[T]].apply(n)
 
     /** The number of elements in an immutable array
       *  @param arr  the immutable array
@@ -37,7 +37,7 @@ object opaques {
     def (arr: IArray[Float]) length: Int = arr.asInstanceOf[Array[Float]].length
     def (arr: IArray[Double]) length: Int = arr.asInstanceOf[Array[Double]].length
     def (arr: IArray[Object]) length: Int = arr.asInstanceOf[Array[Object]].length
-    def (arr: IArray[T]) length[T] : Int = arr.asInstanceOf[Array[T]].length
+    def [T](arr: IArray[T]) length: Int = arr.asInstanceOf[Array[T]].length
   }
 }
 type IArray[+T] = opaques.IArray[T]

library/src-bootstrapped/scala/quoted/package.scala

@@ -4,6 +4,6 @@ package object quoted {
 
   implicit object ExprOps {
     @deprecated("Use scala.quoted.Expr.apply instead", "0.19.0")
-    def (x: T) toExpr[T: Liftable](given QuoteContext): Expr[T] = Expr(x)
+    def [T: Liftable](x: T) toExpr (given QuoteContext): Expr[T] = Expr(x)
   }
 }