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)
@@ -2603,18 +2605,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: