Fix inlining with multiple type argument clauses

To do this, get rid of all uses of `decomposeCall`.

Author: odersky

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

@@ -621,24 +621,38 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
     }
   }
 
-  /** Decompose a call fn[targs](vargs_1)...(vargs_n)
-   *  into its constituents (fn, targs, vargss).
-   *
-   *  Note: targ and vargss may be empty
-   */
-  def decomposeCall(tree: Tree): (Tree, List[Tree], List[List[Tree]]) = {
+  /** The type arguemnts of a possibly curried call */
+  def typeArgss(tree: Tree): List[List[Tree]] =
     @tailrec
-    def loop(tree: Tree, targss: List[Tree], argss: List[List[Tree]]): (Tree, List[Tree], List[List[Tree]]) =
-      tree match {
-        case Apply(fn, args) =>
-          loop(fn, targss, args :: argss)
-        case TypeApply(fn, targs) =>
-          loop(fn, targs ::: targss, argss)
-        case _ =>
-          (tree, targss, argss)
-      }
-    loop(tree, Nil, Nil)
-  }
+    def loop(tree: Tree, argss: List[List[Tree]]): List[List[Tree]] = tree match
+      case TypeApply(fn, args) => loop(fn, args :: argss)
+      case Apply(fn, args) => loop(fn, argss)
+      case _ => argss
+    loop(tree, Nil)
+
+  /** The term arguemnts of a possibly curried call */
+  def termArgss(tree: Tree): List[List[Tree]] =
+    @tailrec
+    def loop(tree: Tree, argss: List[List[Tree]]): List[List[Tree]] = tree match
+      case Apply(fn, args) => loop(fn, args :: argss)
+      case TypeApply(fn, args) => loop(fn, argss)
+      case _ => argss
+    loop(tree, Nil)
+
+  /** The type and term arguemnts of a possibly curried call, in the order they are given */
+  def allArgss(tree: Tree): List[List[Tree]] =
+    @tailrec
+    def loop(tree: Tree, argss: List[List[Tree]]): List[List[Tree]] = tree match
+      case tree: GenericApply => loop(tree.fun, tree.args :: argss)
+      case _ => argss
+    loop(tree, Nil)
+
+  /** The function part of a possibly curried call. Unlike `methPart` this one does
+   *  not decompose blocks
+   */
+  def funPart(tree: Tree): Tree = tree match
+    case tree: GenericApply => funPart(tree.fun)
+    case tree => tree
 
   /** Decompose a template body into parameters and other statements */
   def decomposeTemplateBody(body: List[Tree])(using Context): (List[Tree], List[Tree]) =

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

@@ -1244,6 +1244,9 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     case TypeArgs(targs) :: argss1 => (targs, argss1)
     case _ => (Nil, argss)
 
+  def joinArgs(targs: List[Tree], argss: List[List[Tree]]): List[List[Tree]] =
+    if targs.isEmpty then argss else targs :: argss
+
   /** A key to be used in a context property that tracks enclosing inlined calls */
   private val InlinedCalls = Property.Key[List[Tree]]()
 

compiler/src/dotty/tools/dotc/transform/init/Checking.scala

@@ -130,16 +130,13 @@ object Checking {
 
     tpl.parents.foreach {
       case tree @ Block(_, parent) =>
-        val (ctor, _, _) = decomposeCall(parent)
-        checkConstructor(ctor.symbol, parent.tpe, tree)
+        checkConstructor(funPart(parent).symbol, parent.tpe, tree)
 
       case tree @ Apply(Block(_, parent), _) =>
-        val (ctor, _, _) = decomposeCall(parent)
-        checkConstructor(ctor.symbol, tree.tpe, tree)
+        checkConstructor(funPart(parent).symbol, tree.tpe, tree)
 
       case parent : Apply =>
-        val (ctor, _, argss) = decomposeCall(parent)
-        checkConstructor(ctor.symbol, parent.tpe, parent)
+        checkConstructor(funPart(parent).symbol, parent.tpe, parent)
 
       case ref =>
         val cls = ref.tpe.classSymbol.asClass

compiler/src/dotty/tools/dotc/transform/init/Summarization.scala

@@ -292,16 +292,16 @@ object Summarization {
       val effsAll = tpl.parents.foldLeft(effs) { (effs, parent) =>
         effs ++ (parent match {
           case tree @ Block(stats, parent) =>
-            val (ctor @ Select(qual, _), _, argss) = decomposeCall(parent)
-            parentArgEffsWithInit(qual :: stats ++ argss.flatten, ctor.symbol, tree)
+            val ctor @ Select(qual, _) = funPart(parent)
+            parentArgEffsWithInit(qual :: stats ++ termArgss(parent).flatten, ctor.symbol, tree)
 
           case tree @ Apply(Block(stats, parent), args) =>
-            val (ctor @ Select(qual, _), _, argss) = decomposeCall(parent)
-            parentArgEffsWithInit(qual :: stats ++ args ++ argss.flatten, ctor.symbol, tree)
+            val ctor @ Select(qual, _) = funPart(parent)
+            parentArgEffsWithInit(qual :: stats ++ args ++ termArgss(parent).flatten, ctor.symbol, tree)
 
           case parent : Apply =>
-            val (ctor @ Select(qual, _), _, argss) = decomposeCall(parent)
-            parentArgEffsWithInit(qual :: argss.flatten, ctor.symbol, parent)
+            val ctor @ Select(qual, _) = funPart(parent)
+            parentArgEffsWithInit(qual :: termArgss(parent).flatten, ctor.symbol, parent)
 
           case ref =>
             val tref: TypeRef = ref.tpe.typeConstructor.asInstanceOf

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -388,7 +388,7 @@ class SpaceEngine(using Context) extends SpaceLogic {
       projectSeq(pats)
 
     case UnApply(fun, _, pats) =>
-      val (fun1, _, _) = decomposeCall(fun)
+      val fun1 = funPart(fun)
       val funRef = fun1.tpe.asInstanceOf[TermRef]
       if (fun.symbol.name == nme.unapplySeq)
         if (fun.symbol.owner == scalaSeqFactoryClass)

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

@@ -160,10 +160,11 @@ trait Dynamic {
    *  where c11, ..., cNn are the classOf constants representing the erasures of T11, ..., TNn.
    *
    *  It's an error if U is neither a value nor a method type, or a dependent method
-   *  type.
+   *  type
    */
   def handleStructural(tree: Tree)(using Context): Tree = {
-    val (fun @ Select(qual, name), targs, vargss) = decomposeCall(tree)
+    val fun @ Select(qual, name) = funPart(tree)
+    val vargss = termArgss(tree)
 
     def structuralCall(selectorName: TermName, classOfs: => List[Tree]) = {
       val selectable = adapt(qual, defn.SelectableClass.typeRef)

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

@@ -309,7 +309,7 @@ class ImplicitSearchError(
     //     implicitly[Int => String] // found: x => f[Any](x)
 
     val call = tpd.closureBody(alt.tree) // the tree itself if not a closure
-    val (_, targs, _) = tpd.decomposeCall(call)
+    val targs = tpd.typeArgss(call).flatten
     val args = resolveTypes(targs)(using ctx.fresh.setTyperState(alt.tstate))
     userDefinedErrorString(raw, params, args)
   }
@@ -336,7 +336,8 @@ class ImplicitSearchError(
    */
   private def userDefinedImplicitNotFoundParamMessage: Option[String] = paramSymWithMethodCallTree.flatMap { (sym, applTree) =>
     userDefinedMsg(sym, defn.ImplicitNotFoundAnnot).map { rawMsg =>
-      val (fn, targs, _) = tpd.decomposeCall(applTree)
+      val fn = tpd.funPart(applTree)
+      val targs = tpd.typeArgss(applTree).flatten
       val methodOwner = fn.symbol.owner
       val methodOwnerType = tpd.qualifier(fn).tpe
       val methodTypeParams = fn.symbol.paramSymss.flatten.filter(_.isType)

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

@@ -364,7 +364,9 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
   import tpd._
   import Inliner._
 
-  private val (methPart, callTypeArgs, callValueArgss) = decomposeCall(call)
+  private val methPart = funPart(call)
+  private val callTypeArgs = typeArgss(call).flatten
+  private val callValueArgss = termArgss(call)
   private val inlinedMethod = methPart.symbol
   private val inlineCallPrefix =
      qualifier(methPart).orElse(This(inlinedMethod.enclosingClass.asClass))
@@ -456,7 +458,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
         paramSpan(name) = arg.span
         paramBinding(name) = arg.tpe.stripTypeVar
       }
-      computeParamBindings(tp.resultType, Nil, argss)
+      computeParamBindings(tp.resultType, targs.drop(tp.paramNames.length), argss)
     case tp: MethodType =>
       if argss.isEmpty then
         report.error(i"missing arguments for inline method $inlinedMethod", call.srcPos)

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

@@ -122,9 +122,10 @@ object PrepareInlineable {
       def preTransform(tree: Tree)(using Context): Tree = tree match {
         case _: Apply | _: TypeApply | _: RefTree
         if needsAccessor(tree.symbol) && tree.isTerm && !tree.symbol.isConstructor =>
-          val (refPart, targs, argss) = decomposeCall(tree)
+          val refPart = funPart(tree)
+          val argss = allArgss(tree)
           val qual = qualifier(refPart)
-          inlining.println(i"adding receiver passing inline accessor for $tree/$refPart -> (${qual.tpe}, $refPart: ${refPart.getClass}, [$targs%, %], ($argss%, %))")
+          inlining.println(i"adding receiver passing inline accessor for $tree/$refPart -> (${qual.tpe}, $refPart: ${refPart.getClass}, $argss%, %")
 
           // Need to dealias in order to cagtch all possible references to abstracted over types in
           // substitutions
@@ -159,10 +160,12 @@ object PrepareInlineable {
             accessorInfo = abstractQualType(addQualType(dealiasMap(accessedType))),
             accessed = accessed)
 
-          ref(accessor)
-            .appliedToTypeTrees(localRefs.map(TypeTree(_)) ++ targs)
-            .appliedToArgss((qual :: Nil) :: argss)
-            .withSpan(tree.span)
+          val (leadingTypeArgs, otherArgss) = splitArgs(argss)
+          val argss1 = joinArgs(
+            localRefs.map(TypeTree(_)) ++ leadingTypeArgs, // TODO: pass type parameters in two sections?
+            (qual :: Nil) :: otherArgss
+          )
+          ref(accessor).appliedToArgss(argss1).withSpan(tree.span)
 
             // TODO: Handle references to non-public types.
             // This is quite tricky, as such types can appear anywhere, including as parts

tests/pos/extmethods.scala

@@ -20,3 +20,10 @@ object CollectionStrawMan {
     protected[this] def newBuilder = new ArrayBuffer[A].mapResult(_.toArray(elemTag))
   }
 }
+
+extension [A](xs: List[A])
+  inline def foldl[B](z: B)(op: (B, A) => B): B =
+    (xs: List[A]).foldLeft(z)(op)
+
+val x = List("a", "b").foldl[Int](0)((x, y) => x + y.length)
+