Fix issue with generic type in signature

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

@@ -150,15 +150,15 @@ class Inliner(val call: tpd.Tree)(using Context):
   protected val callTypeArgs = typeArgss(call).flatten
   protected val callValueArgss = termArgss(call)
   protected val inlinedMethod = methPart.symbol
-  private val inlineCallPrefix =
+  protected val inlineCallPrefix =
      qualifier(methPart).orElse(This(inlinedMethod.enclosingClass.asClass))
 
   // Make sure all type arguments to the call are fully determined,
   // but continue if that's not achievable (or else i7459.scala would crash).
   for arg <- callTypeArgs do
     isFullyDefined(arg.tpe, ForceDegree.flipBottom)
 
-  /** A map from parameter names of the inlineable method to references of the actual arguments.
+  /** A map from parameter names of the inlineable method or trait to references of the actual arguments.
    *  For a type argument this is the full argument type.
    *  For a value argument, it is a reference to either the argument value
    *  (if the argument is a pure expression of singleton type), or to `val` or `def` acting
@@ -169,7 +169,7 @@ class Inliner(val call: tpd.Tree)(using Context):
   /** A map from parameter names of the inlineable method to spans of the actual arguments */
   private val paramSpan = new mutable.HashMap[Name, Span]
 
-  /** A map from references to (type and value) parameters of the inlineable method
+  /** A map from references to (type and value) parameters of the inlineable method or trait
    *  to their corresponding argument or proxy references, as given by `paramBinding`.
    */
   private[inlines] val paramProxy = new mutable.HashMap[Type, Type]
@@ -187,8 +187,8 @@ class Inliner(val call: tpd.Tree)(using Context):
    *
    *  These are different (wrt ==) types but represent logically the same key
    */
-  private val thisProxy = new mutable.HashMap[ClassSymbol, TermRef]
-  private val thisInlineTraitProxy = new mutable.HashMap[ClassSymbol, ThisType]
+  protected val thisProxy = new mutable.HashMap[ClassSymbol, TermRef]
+  protected val thisInlineTraitProxy = new mutable.HashMap[ClassSymbol, ThisType]
 
   /** A buffer for bindings that define proxies for actual arguments */
   private val bindingsBuf = new mutable.ListBuffer[ValOrDefDef]
@@ -452,7 +452,7 @@ class Inliner(val call: tpd.Tree)(using Context):
    *      references of a method are (we only know the method's type, but that contains TypeParamRefs
    *      and MethodParams, not TypeRefs or TermRefs.
    */
-  private def registerType(tpe: Type): Unit = tpe match {
+  protected def registerType(tpe: Type): Unit = tpe match {
     case tpe: ThisType if !canElideThis(tpe) && !thisProxy.contains(tpe.cls) =>
       val proxyName = s"${tpe.cls.name}_this".toTermName
       val proxyType = inlineCallPrefix.tpe.dealias.tryNormalize match {
@@ -462,10 +462,6 @@ class Inliner(val call: tpd.Tree)(using Context):
       thisProxy(tpe.cls) = newSym(proxyName, InlineProxy, proxyType).termRef
       for (param <- tpe.cls.typeParams)
         paramProxy(param.typeRef) = adaptToPrefix(param.typeRef)
-    case tpe: ThisType if tpe.cls.isInlineTrait =>
-      thisInlineTraitProxy(tpe.cls) = ThisType.raw(TypeRef(ctx.owner.prefix, ctx.owner))
-      for (param <- tpe.cls.typeParams)
-        paramProxy(param.typeRef) = adaptToPrefix(param.typeRef)
     case tpe: NamedType
     if tpe.symbol.is(Param)
         && tpe.symbol.owner == inlinedMethod

compiler/src/dotty/tools/dotc/inlines/Inlines.scala

@@ -470,45 +470,100 @@ object Inlines:
     import Inlines.*
 
     def expandDefs(): List[Tree] =
-      val argsMap = parent match
-        case Apply(_, args) =>
-          val MethodType(paramNames) = parent.symbol.info: @unchecked
-          paramNames.zip(args).toMap
-        case _ => Map.empty
-
       val Block(stats, _) = Inlines.bodyToInline(parentSym): @unchecked
+      val s = stats.map(expandStat)
+      s.map(inlined(_)._2)
+    end expandDefs
+
+    override protected def registerType(tpe: Type): Unit = tpe match {
+      case tpe: ThisType if tpe.cls.isInlineTrait =>
+        thisInlineTraitProxy(tpe.cls) = ThisType.raw(TypeRef(ctx.owner.prefix, ctx.owner))
+        for (param <- tpe.cls.typeParams)
+          paramProxy(param.typeRef) = param.typeRef.asSeenFrom(inlineCallPrefix.tpe, inlinedMethod.owner)
+      case _ => super.registerType(tpe)
+    }
 
-      val stats1 = stats.map { stat =>
-          val sym = stat.symbol
-          stat match
-            case stat: ValDef if sym.isOneOf(Given | Implicit) =>
-              report.error("implementation restriction: inline traits cannot have implicit or given variables", stat.srcPos)
-              stat
-            case stat: ValDef =>
-              val vdef = cloneValDef(stat)
-              val vdef1 =
-                if sym.is(ParamAccessor) then
-                  vdef.symbol.resetFlag(ParamAccessor)
-                  cpy.ValDef(vdef)(rhs = argsMap(sym.name.asTermName))
-                else
-                  vdef
-              if !sym.is(Private) then
-                vdef1.symbol.setFlag(Override)
-              vdef1 // TODO keep rhs? Can we do a single ValOrDefDef case using cloneStat?
-            case stat: DefDef =>
-              val ddef = cloneDefDef(stat)
-              if !sym.is(Private) then ddef.symbol.setFlag(Override)
-              if sym.is(Mutable) then
-                report.error("implementation restriction: inline traits cannot have mutable variables", stat.srcPos)
-              ddef
-            case stat @ TypeDef(_, impl: Template) =>
-              cloneClass(stat, impl)
-            case stat: TypeDef =>
-              val tdef = cloneTypeDef(stat)
-              tdef.symbol.setFlag(Override)
-              tdef
+    private val argsMap: Map[Names.Name, untpd.Tree] =
+      /*
+       * Consider the parent `new A[String](1)("A")` with signature `inline trait A[T](x: Int)(y: T)`.
+       * The `parent` tree is "right-to-left": Apply(Apply(TypeApply(..., String), 1), "A")
+       * The `info` tree is "left-to-right": PolyType(T, ..., MethodType(x, Int, MethodType(y, T, ...)))
+       * This recursive solution goes as deep as possible in the tree, then matches arguments with their
+       * names in a bottom-up fashion.
+       */
+      def rec(tree: Tree, info: Type, acc: Map[Names.Name, untpd.Tree]): (Option[Type], Map[Names.Name, untpd.Tree]) =
+        tree match {
+          case Apply(tree1, args) => rec(tree1, info, acc) match {
+            case (Some(info1), acc1) => info1 match {
+              case MethodTpe(paramNames, _, info2) if paramNames.length == args.length =>
+                (Some(info2), acc1 ++ paramNames.zip(args).toMap)
+              case _ =>
+                report.error(s"mismatch between Apply ${tree.show} and info ${info1}", parent.srcPos)
+                (None, acc1)
+            }
+            case res => res
+          }
+          case TypeApply(tree1, tpes) => rec(tree1, info, acc) match {
+            case (Some(info1), acc1) => info1 match {
+              case PolyType(lambdaParams, info2) if lambdaParams.length == tpes.length =>
+                (Some(info2), acc1)
+              case _ =>
+                report.error(s"mismatch between TypeApply ${tree.show} and info ${info1}", parent.srcPos)
+                (None, acc1)
+            }
+            case res => res
+          }
+          case _ => (Some(info), acc)
+        }
+
+      parent match {
+        case _: GenericApply =>
+          val (remainingInfo, map) = rec(parent, parent.symbol.info, Map.empty)
+          remainingInfo match {
+            case Some(MethodType(paramNames)) =>
+              report.error(s"could not match the following parameters with their values: ${paramNames.map(_.show).mkString(", ")}", parent.srcPos)
+            case _ =>
+          }
+          map
+        case _ => Map.empty
       }
-      stats1.map(stat => inlined(stat)._2)
+    end argsMap
+
+    private def expandStat(stat: untpd.Tree): untpd.Tree =
+      val sym = stat.symbol
+      stat match
+        case stat: ValDef if sym.isOneOf(Given | Implicit) =>
+          report.error("implementation restriction: inline traits cannot have implicit or given variables", stat.srcPos)
+          stat
+        case stat: ValDef =>
+          val vdef = cloneValDef(stat)
+          val vdef1 =
+            if sym.is(ParamAccessor) then
+              vdef.symbol.resetFlag(ParamAccessor)
+              cpy.ValDef(vdef)(rhs = argsMap(sym.name.asTermName))
+            else
+              vdef
+          if !sym.is(Private) then
+            vdef1.symbol.setFlag(Override)
+          vdef1 // TODO keep rhs? Can we do a single ValOrDefDef case using cloneStat?
+        case stat: DefDef =>
+          val ddef = cloneDefDef(stat)
+          if !sym.is(Private) then
+            ddef.symbol.setFlag(Override)
+          if sym.is(Mutable) then
+            report.error("implementation restriction: inline traits cannot have mutable variables", stat.srcPos)
+          ddef
+        case stat @ TypeDef(_, impl: Template) =>
+          report.error("inline traits do not handle inner classes yet", stat.srcPos)
+          cloneClass(stat, impl)
+        case stat: TypeDef =>
+          val tdef = cloneTypeDef(stat)
+          tdef.symbol.setFlag(Override)
+          tdef
+        case _ =>
+          report.error(s"unknown body element of inline ${parentSym.show}: ${stat.show}", stat.srcPos)
+          stat
+    end expandStat
 
     private def inlinedRhs(rhs: Tree): Inlined =
       Inlined(tpd.ref(parentSym), Nil, rhs).withSpan(parent.span)