Allow two type parameter lists in extension methods

Author: odersky

compiler/src-bootstrapped/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -62,7 +62,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     /** Convert this to an `quoted.Expr[X]` if this expression is a valid expression of type `X` or throws */
     def asExprOf(using scala.quoted.Type[X]): scala.quoted.Expr[X] = {
-      if isExprOf[X] then
+      if this.isExprOf[X](self) then
         self.asInstanceOf[scala.quoted.Expr[X]]
       else
         throw Exception(

compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala renamed to compiler/src-non-bootstrapped/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -906,33 +906,24 @@ object desugar {
   /** Transform extension construct to list of extension methods */
   def extMethods(ext: ExtMethods)(using Context): Tree = flatTree {
     for mdef <- ext.methods yield
-      var extParamss = ext.paramss
-      var mdefParamss = mdef.paramss
-      if mdef.leadingTypeParams.nonEmpty then
-        report.error("extension method cannot have type parameters here, all type parameters go after `extension`",
-          mdef.leadingTypeParams.head.srcPos)
-        extParamss = extParamss match
-          case TypeDefs(tparams) :: paramss1 => (tparams ++ mdef.leadingTypeParams) :: paramss1
-          case _ => mdef.leadingTypeParams :: extParamss
-        mdefParamss = mdef.trailingParamss
       defDef(
         cpy.DefDef(mdef)(
           name = normalizeName(mdef, ext).asTermName,
           paramss = mdef.paramss match
             case params1 :: paramss1 if mdef.name.isRightAssocOperatorName =>
               def badRightAssoc(problem: String) =
                 report.error(i"right-associative extension method $problem", mdef.srcPos)
-                extParamss ++ mdefParamss
+                ext.paramss ++ mdef.paramss
               params1 match
                 case ValDefs(vparam :: Nil) =>
                   if !vparam.mods.is(Given) then
-                    val (leadingUsing, otherExtParamss) = extParamss.span(isUsingOrTypeParamClause)
+                    val (leadingUsing, otherExtParamss) = ext.paramss.span(isUsingOrTypeParamClause)
                     leadingUsing ::: params1 :: otherExtParamss ::: paramss1
                   else badRightAssoc("cannot start with using clause")
                 case _ =>
                   badRightAssoc("must start with a single parameter")
             case _ =>
-              extParamss ++ mdefParamss
+              ext.paramss ++ mdef.paramss
         ).withMods(mdef.mods | ExtensionMethod)
       )
   }

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

@@ -564,6 +564,11 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
     }
   }
 
+  def isExtMethodApply(tree: Tree)(using Context): Boolean = methPart(tree) match
+    case Inlined(call, _, _) => isExtMethodApply(call)
+    case tree @ Select(qual, nme.apply) => tree.symbol.is(ExtensionMethod) || isExtMethodApply(qual)
+    case tree => tree.symbol.is(ExtensionMethod)
+
   /** Is symbol potentially a getter of a mutable variable?
    */
   def mayBeVarGetter(sym: Symbol)(using Context): Boolean = {

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

@@ -647,6 +647,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         keywordStr("${") ~ toTextGlobal(dropBlock(tree)) ~ keywordStr("}")
       case tree: Applications.IntegratedTypeArgs =>
         toText(tree.app) ~ Str("(with integrated type args)").provided(printDebug)
+      case tree: Applications.ExtMethodApply =>
+        toText(tree.app) ~ Str("(ext method apply)").provided(printDebug)
       case Thicket(trees) =>
         "Thicket {" ~~ toTextGlobal(trees, "\n") ~~ "}"
       case MacroTree(call) =>

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -196,12 +196,8 @@ object Applications {
   def wrapDefs(defs: mutable.ListBuffer[Tree], tree: Tree)(using Context): Tree =
     if (defs != null && defs.nonEmpty) tpd.Block(defs.toList, tree) else tree
 
-  /** A wrapper indicating that its `app` argument has already integrated the type arguments
-   *  of the expected type, provided that type is a (possibly ignored) PolyProto.
-   *  I.e., if the expected type is a PolyProto, then `app` will be a `TypeApply(_, args)` where
-   *  `args` are the type arguments of the expected type.
-   */
-  class IntegratedTypeArgs(val app: Tree)(implicit @constructorOnly src: SourceFile) extends ProxyTree {
+  abstract class AppProxy(implicit @constructorOnly src: SourceFile) extends ProxyTree {
+    def app: Tree
     override def span = app.span
 
     def forwardTo = app
@@ -210,6 +206,13 @@ object Applications {
     def productElement(n: Int): Any = app.productElement(n)
   }
 
+  /** A wrapper indicating that its `app` argument has already integrated the type arguments
+   *  of the expected type, provided that type is a (possibly ignored) PolyProto.
+   *  I.e., if the expected type is a PolyProto, then `app` will be a `TypeApply(_, args)` where
+   *  `args` are the type arguments of the expected type.
+   */
+  class IntegratedTypeArgs(val app: Tree)(implicit @constructorOnly src: SourceFile) extends AppProxy
+
   /** The unapply method of this extractor also recognizes IntegratedTypeArgs in closure blocks.
    *  This is necessary to deal with closures as left arguments of extension method applications.
    *  A test case is i5606.scala
@@ -225,12 +228,10 @@ object Applications {
 
   /** A wrapper indicating that its argument is an application of an extension method.
    */
-  class ExtMethodApply(app: Tree)(implicit @constructorOnly src: SourceFile)
-  extends IntegratedTypeArgs(app) {
-    overwriteType(WildcardType)
+  class ExtMethodApply(val app: Tree)(implicit @constructorOnly src: SourceFile) extends AppProxy:
+    overwriteType(app.tpe)
       // ExtMethodApply always has wildcard type in order not to prompt any further adaptations
       // such as eta expansion before the method is fully applied.
-  }
 }
 
 trait Applications extends Compatibility {
@@ -2146,9 +2147,6 @@ trait Applications extends Compatibility {
       // Always hide expected member to allow for chained extensions (needed for i6900.scala)
       case _: SelectionProto =>
         (tree, IgnoredProto(currentPt))
-      case PolyProto(targs, restpe) =>
-        val tree1 = untpd.TypeApply(tree, targs.map(untpd.TypedSplice(_)))
-        normalizePt(tree1, restpe)
       case _ =>
         (tree, currentPt)
 

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -937,7 +937,7 @@ trait Implicits:
           case Select(qual, _) => apply(x, qual)
           case Apply(fn, _) => apply(x, fn)
           case TypeApply(fn, _) => apply(x, fn)
-          case tree: Applications.IntegratedTypeArgs => apply(x, tree.app)
+          case tree: Applications.AppProxy => apply(x, tree.app)
           case _: This => false
           case _ => foldOver(x, tree)
       }

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -553,6 +553,8 @@ class Typer extends Namer
         case _: PolyProto => qual // keep the IntegratedTypeArgs to strip at next typedTypeApply
         case _ => app
       }
+    case qual: ExtMethodApply =>
+      qual.app
     case qual =>
       val select = assignType(cpy.Select(tree)(qual, tree.name), qual)
       val select1 = toNotNullTermRef(select, pt)
@@ -2604,18 +2606,16 @@ class Typer extends Namer
   }
 
   /** Interpolate and simplify the type of the given tree. */
-  protected def simplify(tree: Tree, pt: Type, locked: TypeVars)(using Context): tree.type = {
-    if (!tree.denot.isOverloaded &&
-          // for overloaded trees: resolve overloading before simplifying
-        !tree.isInstanceOf[Applications.IntegratedTypeArgs])
-          // don't interpolate in the middle of an extension method application
-      if (!tree.tpe.widen.isInstanceOf[MethodOrPoly] // wait with simplifying until method is fully applied
-          || tree.isDef) {                             // ... unless tree is a definition
+  protected def simplify(tree: Tree, pt: Type, locked: TypeVars)(using Context): tree.type =
+    if !tree.denot.isOverloaded // for overloaded trees: resolve overloading before simplifying
+       && !tree.isInstanceOf[Applications.AppProxy] // don't interpolate in the middle of an extension method application
+    then
+      if !tree.tpe.widen.isInstanceOf[MethodOrPoly] // wait with simplifying until method is fully applied
+         || tree.isDef                              // ... unless tree is a definition
+      then
         interpolateTypeVars(tree, pt, locked)
         tree.overwriteType(tree.tpe.simplified)
-      }
     tree
-  }
 
   protected def makeContextualFunction(tree: untpd.Tree, pt: Type)(using Context): Tree = {
     val defn.FunctionOf(formals, _, true, _) = pt.dropDependentRefinement

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -280,7 +280,7 @@ class ReplCompiler extends Compiler {
         if (errorsAllowed || !ctx.reporter.hasErrors)
           unwrapped(unit.tpdTree, src)
         else
-          ctx.reporter.removeBufferedMessages.errors[tpd.ValDef] // Workaround #4988
+          ctx.reporter.removeBufferedMessages.errors // Workaround #4988
       }
     }
   }

compiler/src/dotty/tools/repl/ReplCompiler.scala

@@ -157,7 +157,6 @@ class CompilationTests {
       compileFile("tests/neg-custom-args/missing-alpha.scala", defaultOptions.and("-Yrequire-targetName", "-Xfatal-warnings")),
       compileFile("tests/neg-custom-args/wildcards.scala", defaultOptions.and("-source", "3.1", "-deprecation", "-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")),
       compileDir("tests/neg-custom-args/adhoc-extension", defaultOptions.and("-source", "3.1", "-feature", "-Xfatal-warnings")),
       compileFile("tests/neg/i7575.scala", defaultOptions.withoutLanguageFeatures.and("-language:_")),
       compileFile("tests/neg-custom-args/kind-projector.scala", defaultOptions.and("-Ykind-projector")),
@@ -250,7 +249,7 @@ class CompilationTests {
     val tastyCoreSources = sources(Paths.get("tasty/src"))
     val tastyCore = compileList("tastyCore", tastyCoreSources, opt)(tastyCoreGroup)
 
-    val compilerSources = sources(Paths.get("compiler/src"))
+    val compilerSources = sources(Paths.get("compiler/src")) ++ sources(Paths.get("compiler/src-bootstrapped"))
     val compilerManagedSources = sources(Properties.dottyCompilerManagedSources)
 
     val dotty1 = compileList("dotty1", compilerSources ++ compilerManagedSources, opt)(dotty1Group)

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

@@ -58,7 +58,10 @@ The three definitions above translate to
 Note the swap of the two parameters `x` and `xs` when translating
 the right-associative operator `+:` to an extension method. This is analogous
 to the implementation of right binding operators as normal methods. The Scala
-compiler preprocesses an infix operation `x +: xs` to `xs.+:(x)`, so the extension method ends up being applied to the sequence as first argument (in other words, the two swaps cancel each other out).
+compiler preprocesses an infix operation `x +: xs` to `xs.+:(x)`, so the extension
+method ends up being applied to the sequence as first argument (in other words, the
+two swaps cancel each other out). See [here for details](./right-associative-extension-methods.html).
+
 ### Generic Extensions
 
 It is also possible to extend generic types by adding type parameters to an extension. For instance:

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

@@ -43,7 +43,7 @@ object opaques:
     extension [T](arr: IArray[T]) def length: Int = arr.asInstanceOf[Array[T]].length
 
     /** Returns this array concatenated with the given array. */
-    extension [T, U >: T: ClassTag](arr: IArray[T]) def ++(that: IArray[U]): IArray[U] =
+    extension [T](arr: IArray[T]) def ++ [U >: T: ClassTag](that: IArray[U]): IArray[U] =
       genericArrayOps(arr) ++ that
 
     /** Tests whether this array contains a given value as an element. */
@@ -53,15 +53,15 @@ object opaques:
       genericArrayOps(arr).exists(_ == elem)
 
     /** Copy elements of this array to another array. */
-    extension [T, U >: T](arr: IArray[T]) def copyToArray(xs: Array[U]): Int =
+    extension [T](arr: IArray[T]) def copyToArray[U >: T](xs: Array[U]): Int =
       genericArrayOps(arr).copyToArray(xs)
 
     /** Copy elements of this array to another array. */
-    extension [T, U >: T](arr: IArray[T]) def copyToArray(xs: Array[U], start: Int): Int =
+    extension [T](arr: IArray[T]) def copyToArray[U >: T](xs: Array[U], start: Int): Int =
       genericArrayOps(arr).copyToArray(xs, start)
 
     /** Copy elements of this array to another array. */
-    extension [T, U >: T](arr: IArray[T]) def copyToArray(xs: Array[U], start: Int, len: Int): Int =
+    extension [T](arr: IArray[T]) def copyToArray[U >: T](xs: Array[U], start: Int, len: Int): Int =
       genericArrayOps(arr).copyToArray(xs, start, len)
 
     /** Counts the number of elements in this array which satisfy a predicate */
@@ -98,34 +98,34 @@ object opaques:
 
     /** Builds a new array by applying a function to all elements of this array
       * and using the elements of the resulting collections. */
-    extension [T, U: ClassTag](arr: IArray[T]) def flatMap(f: T => IterableOnce[U]): IArray[U] =
+    extension [T](arr: IArray[T]) def flatMap[U: ClassTag](f: T => IterableOnce[U]): IArray[U] =
       genericArrayOps(arr).flatMap(f)
 
     /** Flattens a two-dimensional array by concatenating all its rows
       * into a single array. */
-    extension [T, U: ClassTag](arr: IArray[T]) def flatten(using T => Iterable[U]): IArray[U] =
+    extension [T](arr: IArray[T]) def flatten[U: ClassTag](using T => Iterable[U]): IArray[U] =
       genericArrayOps(arr).flatten
 
     /** Folds the elements of this array using the specified associative binary operator. */
-    extension [T, U >: T: ClassTag](arr: IArray[T]) def fold(z: U)(op: (U, U) => U): U =
+    extension [T](arr: IArray[T]) def fold[U >: T: ClassTag](z: U)(op: (U, U) => U): U =
       genericArrayOps(arr).fold(z)(op)
 
     /** Applies a binary operator to a start value and all elements of this array,
       * going left to right. */
-    extension [T, U: ClassTag](arr: IArray[T]) def foldLeft(z: U)(op: (U, T) => U): U =
+    extension [T](arr: IArray[T]) def foldLeft[U: ClassTag](z: U)(op: (U, T) => U): U =
       genericArrayOps(arr).foldLeft(z)(op)
 
     /** Applies a binary operator to all elements of this array and a start value,
       * going right to left. */
-    extension [T, U: ClassTag](arr: IArray[T]) def foldRight(z: U)(op: (T, U) => U): U =
+    extension [T](arr: IArray[T]) def foldRight[U: ClassTag](z: U)(op: (T, U) => U): U =
       genericArrayOps(arr).foldRight(z)(op)
 
     /** Tests whether a predicate holds for all elements of this array. */
     extension [T](arr: IArray[T]) def forall(p: T => Boolean): Boolean =
       genericArrayOps(arr).forall(p)
 
     /** Apply `f` to each element for its side effects. */
-    extension [T, U](arr: IArray[T]) def foreach(f: T => U): Unit =
+    extension [T](arr: IArray[T]) def foreach[U](f: T => U): Unit =
       genericArrayOps(arr).foreach(f)
 
     /** Selects the first element of this array. */
@@ -181,7 +181,7 @@ object opaques:
       genericArrayOps(arr).lastIndexWhere(p, end)
 
     /** Builds a new array by applying a function to all elements of this array. */
-    extension [T, U: ClassTag](arr: IArray[T]) def map(f: T => U): IArray[U] =
+    extension [T](arr: IArray[T]) def map[U: ClassTag](f: T => U): IArray[U] =
       genericArrayOps(arr).map(f)
 
     /** Tests whether the array is not empty. */
@@ -197,17 +197,17 @@ object opaques:
       genericArrayOps(arr).reverse
 
     /** Computes a prefix scan of the elements of the array. */
-    extension [T, U >: T: ClassTag](arr: IArray[T]) def scan(z: U)(op: (U, U) => U): IArray[U] =
+    extension [T](arr: IArray[T]) def scan[U >: T: ClassTag](z: U)(op: (U, U) => U): IArray[U] =
       genericArrayOps(arr).scan(z)(op)
 
     /** Produces an array containing cumulative results of applying the binary
       * operator going left to right. */
-    extension [T, U: ClassTag](arr: IArray[T]) def scanLeft(z: U)(op: (U, T) => U): IArray[U] =
+    extension [T](arr: IArray[T]) def scanLeft[U: ClassTag](z: U)(op: (U, T) => U): IArray[U] =
       genericArrayOps(arr).scanLeft(z)(op)
 
     /** Produces an array containing cumulative results of applying the binary
       * operator going right to left. */
-    extension [T, U: ClassTag](arr: IArray[T]) def scanRight(z: U)(op: (T, U) => U): IArray[U] =
+    extension [T](arr: IArray[T]) def scanRight[U: ClassTag](z: U)(op: (T, U) => U): IArray[U] =
       genericArrayOps(arr).scanRight(z)(op)
 
     /** The size of this array. */
@@ -220,7 +220,7 @@ object opaques:
 
     /** Sorts this array according to the Ordering which results from transforming
       * an implicitly given Ordering with a transformation function. */
-    extension [T, U: ClassTag](arr: IArray[T]) def sortBy(f: T => U)(using math.Ordering[U]): IArray[T] =
+    extension [T](arr: IArray[T]) def sortBy[U: ClassTag](f: T => U)(using math.Ordering[U]): IArray[T] =
       genericArrayOps(arr).sortBy(f)
 
     /** Sorts this array according to a comparison function. */
@@ -240,7 +240,7 @@ object opaques:
       genericArrayOps(arr).splitAt(n)
 
     /** Tests whether this array starts with the given array. */
-    extension [T, U >: T: ClassTag](arr: IArray[T]) def startsWith(that: IArray[U], offset: Int = 0): Boolean =
+    extension [T](arr: IArray[T]) def startsWith[U >: T: ClassTag](that: IArray[U], offset: Int = 0): Boolean =
       genericArrayOps(arr).startsWith(that)
 
     /** The rest of the array without its first element. */
@@ -270,7 +270,7 @@ object opaques:
     /** Returns an array formed from this array and another iterable collection
       * by combining corresponding elements in pairs.
       * If one of the two collections is longer than the other, its remaining elements are ignored. */
-    extension [T, U: ClassTag](arr: IArray[T]) def zip(that: IArray[U]): IArray[(T, U)] =
+    extension [T](arr: IArray[T]) def zip[U: ClassTag](that: IArray[U]): IArray[(T, U)] =
       genericArrayOps(arr).zip(that)
   }
 end opaques

library/src-bootstrapped/scala/IArray.scala

@@ -53,12 +53,12 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
   end extension
 
   // Extension methods for `Expr[Any]` that take another explicit type parameter
-  extension [X](self: Expr[Any])
+  extension (self: Expr[Any])
     /** Checks is the `quoted.Expr[?]` is valid expression of type `X` */
-    def isExprOf(using Type[X]): Boolean
+    def isExprOf[X](using Type[X]): Boolean
 
     /** Convert this to an `quoted.Expr[X]` if this expression is a valid expression of type `X` or throws */
-    def asExprOf(using Type[X]): Expr[X]
+    def asExprOf[X](using Type[X]): Expr[X]
   end extension
 
   /** Low-level Typed AST metaprogramming API.

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

@@ -145,7 +145,9 @@ trait ExprMap:
         trees.mapConserve(x => transformTypeCaseDef(x)(owner))
 
     }
-    new MapChildren().transformTermChildren(e.asTerm, TypeRepr.of[T])(Symbol.spliceOwner).asExprOf[T]
+    new MapChildren()
+      .transformTermChildren(e.asTerm, TypeRepr.of[T])(Symbol.spliceOwner)
+      .asExprOf: Expr[T]
   }
 
 end ExprMap