Fix type params not being replaced in RHS

Move inline trait related code back from Inliner to InlineParentTrait

Use overridden version of DeepTypeMap to replace types in RHS of definitions

Add test with trait-related type param in RHS

Author: timotheeandres

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

@@ -158,7 +158,7 @@ class Inliner(val call: tpd.Tree)(using Context):
   for arg <- callTypeArgs do
     isFullyDefined(arg.tpe, ForceDegree.flipBottom)
 
-  /** A map from parameter names of the inlineable method or trait to references of the actual arguments.
+  /** A map from parameter names of the inlineable method 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 or trait
+  /** A map from references to (type and value) parameters of the inlineable method
    *  to their corresponding argument or proxy references, as given by `paramBinding`.
    */
   private[inlines] val paramProxy = new mutable.HashMap[Type, Type]
@@ -187,8 +187,7 @@ class Inliner(val call: tpd.Tree)(using Context):
    *
    *  These are different (wrt ==) types but represent logically the same key
    */
-  protected val thisProxy = new mutable.HashMap[ClassSymbol, TermRef]
-  protected val thisInlineTraitProxy = new mutable.HashMap[ClassSymbol, ThisType]
+  private val thisProxy = new mutable.HashMap[ClassSymbol, TermRef]
 
   /** A buffer for bindings that define proxies for actual arguments */
   private val bindingsBuf = new mutable.ListBuffer[ValOrDefDef]
@@ -439,11 +438,10 @@ class Inliner(val call: tpd.Tree)(using Context):
 
   private def adaptToPrefix(tp: Type) = tp.asSeenFrom(inlineCallPrefix.tpe, inlinedMethod.owner)
 
-  /** Populate `thisProxy`, `thisInlineTraitProxy` and `paramProxy` as follows:
+  /** Populate `thisProxy` and `paramProxy` as follows:
    *
    *  1a. If given type refers to a static this, thisProxy binds it to corresponding global reference,
-   *  1b. If given type refers to an inline trait, thisInlineTraitProxy binds it to the corresponding thistype,
-   *  1c. If given type refers to an instance this to a class that is not contained in the
+   *  1b. If given type refers to an instance this to a class that is not contained in the
    *      inline method, create a proxy symbol and bind the thistype to refer to the proxy.
    *      The proxy is not yet entered in `bindingsBuf`; that will come later.
    *  2.  If given type refers to a parameter, make `paramProxy` refer to the entry stored
@@ -453,7 +451,7 @@ class Inliner(val call: tpd.Tree)(using Context):
    *      and MethodParams, not TypeRefs or TermRefs.
    */
   private def registerType(tpe: Type): Unit = tpe match {
-    case tpe: ThisType if !canElideThis(tpe) && !thisProxy.contains(tpe.cls) =>
+    case tpe: ThisType if !canElideThis(tpe) && !thisProxy.contains(tpe.cls) && !tpe.cls.isInlineTrait =>
       val proxyName = s"${tpe.cls.name}_this".toTermName
       val proxyType = inlineCallPrefix.tpe.dealias.tryNormalize match {
         case typeMatchResult if typeMatchResult.exists => typeMatchResult
@@ -462,10 +460,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
@@ -510,9 +504,23 @@ class Inliner(val call: tpd.Tree)(using Context):
 
   val reducer = new InlineReducer(this)
 
+  protected class InlinerTypeMap extends DeepTypeMap {
+    override def stopAt =
+      if opaqueProxies.isEmpty then StopAt.Static else StopAt.Package
+    def apply(t: Type) = t match {
+      case t: ThisType => thisProxy.get(t.cls).getOrElse(t)
+      case t: TypeRef => paramProxy.getOrElse(t, mapOver(t))
+      case t: SingletonType =>
+        if t.termSymbol.isAllOf(InlineParam) then apply(t.widenTermRefExpr)
+        else paramProxy.getOrElse(t, mapOver(t))
+      case t => mapOver(t)
+    }
+  }
+
+  protected val inlinerTypeMap: InlinerTypeMap = InlinerTypeMap()
+
   /** The Inlined node representing the inlined call */
   def inlined(rhsToInline: tpd.Tree): (List[MemberDef], Tree) =
-
     inlining.println(i"-----------------------\nInlining $call\nWith RHS $rhsToInline")
 
     def paramTypess(call: Tree, acc: List[List[Type]]): List[List[Type]] = call match
@@ -564,19 +572,7 @@ class Inliner(val call: tpd.Tree)(using Context):
     // corresponding arguments or proxies on the type and term level. It also changes
     // the owner from the inlined method to the current owner.
     val inliner = new InlinerMap(
-      typeMap =
-        new DeepTypeMap {
-          override def stopAt =
-            if opaqueProxies.isEmpty then StopAt.Static else StopAt.Package
-          def apply(t: Type) = t match {
-            case t: ThisType => thisProxy.get(t.cls).orElse(thisInlineTraitProxy.get(t.cls)).getOrElse(t)
-            case t: TypeRef => paramProxy.getOrElse(t, mapOver(t))
-            case t: SingletonType =>
-              if t.termSymbol.isAllOf(InlineParam) then apply(t.widenTermRefExpr)
-              else paramProxy.getOrElse(t, mapOver(t))
-            case t => mapOver(t)
-          }
-        },
+      typeMap = inlinerTypeMap,
       treeMap = {
         case tree: This =>
           tree.tpe match {
@@ -625,7 +621,6 @@ class Inliner(val call: tpd.Tree)(using Context):
     inlining.println(
       i"""inliner transform with
          |thisProxy = ${thisProxy.toList.map(_._1)}%, % --> ${thisProxy.toList.map(_._2)}%, %
-         |thisInlineTraitProxy = ${thisInlineTraitProxy.toList.map(_._1)}%, % --> ${thisInlineTraitProxy.toList.map(_._2)}%, %
          |paramProxy = ${paramProxy.toList.map(_._1.typeSymbol.showLocated)}%, % --> ${paramProxy.toList.map(_._2)}%, %""")
 
     // Apply inliner to `rhsToInline`, split off any implicit bindings from result, and

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

@@ -172,7 +172,7 @@ object Inlines:
 
   def inlineParentTrait(parent: tpd.Tree, childOverrideDecls: Set[Symbol])(using Context): List[Tree] =
     val traitSym = if parent.symbol.isConstructor then parent.symbol.owner else parent.symbol
-    if traitSym.isInlineTrait then InlineParentTrait(parent, traitSym, childOverrideDecls).expandDefs()
+    if traitSym.isInlineTrait then InlineParentTrait(parent, traitSym.asClass, childOverrideDecls).expandDefs()
     else Nil
 
   /** Try to inline a pattern with an inline unapply method. Fail with error if the maximal
@@ -466,17 +466,28 @@ object Inlines:
     end expand
   end InlineCall
 
-  private class InlineParentTrait(parent: tpd.Tree, parentSym: Symbol, overriddenDecls: Set[Symbol])(using Context) extends Inliner(parent):
+  private class InlineParentTrait(parent: tpd.Tree, parentSym: ClassSymbol, overriddenDecls: Set[Symbol])(using Context) extends Inliner(parent):
     import tpd._
     import Inlines.*
 
+    private val thisInlineTraitProxy = ThisType.raw(TypeRef(ctx.owner.prefix, ctx.owner))
+
     def expandDefs(): List[Tree] =
       val tpd.Block(stats, _) = Inlines.bodyToInline(parentSym): @unchecked
       val stats1 = stats.filterNot(isMemberOverridden)
       val inlinedSymbols = stats1.map(stat => inlinedMember(stat.symbol))
       stats1.zip(inlinedSymbols).map(expandStat)//.map(inlined(_)._2)
     end expandDefs
 
+    protected class InlineTraitTypeMap extends InlinerTypeMap {
+      override def apply(t: Type) = t match {
+        case t: ThisType if t.cls == parentSym => thisInlineTraitProxy
+        case t => super.apply(t)
+      }
+    }
+
+    override protected val inlinerTypeMap: InlinerTypeMap = InlineTraitTypeMap()
+
     private val argsMap: Map[Name, Tree] =
       def allArgs(tree: Tree): List[List[Tree]] = tree match
         case Apply(fun, args) => args :: allArgs(fun)
@@ -492,13 +503,6 @@ object Inlines:
         else parent.symbol.info
       allParams(info).flatten.zip(allArgs(parent).reverse.flatten).toMap
 
-    private val substituteTypeParams = new TypeMap {
-      override def apply(t: Type): Type = t match
-        case TypeRef(ths: ThisType, sym: Symbol) if ths.cls == parentSym =>
-          argsMap.get(sym.name).map(_.tpe).getOrElse(t)
-        case t => mapOver(t)
-    }
-
     private def isMemberOverridden(stat: Tree): Boolean =
       overriddenDecls.flatMap(_.allOverriddenSymbols).toSet.contains(stat.symbol)
 
@@ -528,7 +532,7 @@ object Inlines:
         sym.copy(
           owner = ctx.owner,
           flags = flags,
-          info = substituteTypeParams(sym.info),
+          info = inlinerTypeMap(sym.info),
           coord = spanCoord(parent.span)).entered
 
     private def inlinedValDef(vdef: ValDef, inlinedSym: Symbol)(using Context): ValDef =
@@ -572,7 +576,7 @@ object Inlines:
       // TODO case tree: TypeDef => cloneTypeDef(tree)
 
     private def cloneDefDef(ddef: DefDef)(using Context): DefDef =
-      val inlinedSym = ddef.symbol.copy(owner = ctx.owner, info = substituteTypeParams(ddef.symbol.info), coord = spanCoord(parent.span)).entered
+      val inlinedSym = ddef.symbol.copy(owner = ctx.owner, info = inlinerTypeMap(ddef.symbol.info), coord = spanCoord(parent.span)).entered
       def rhsFun(paramss: List[List[Tree]]): Tree =
         val oldParamSyms = ddef.paramss.flatten.map(_.symbol)
         val newParamSyms = paramss.flatten.map(_.symbol)
@@ -584,7 +588,7 @@ object Inlines:
       cpy.DefDef(constr)(tpt = TypeTree(defn.UnitType), rhs = EmptyTree)
 
     private def cloneValDef(vdef: ValDef)(using Context): ValDef =
-      val inlinedSym = vdef.symbol.copy(owner = ctx.owner, info = substituteTypeParams(vdef.symbol.info), coord = spanCoord(parent.span)).entered
+      val inlinedSym = vdef.symbol.copy(owner = ctx.owner, info = inlinerTypeMap(vdef.symbol.info), coord = spanCoord(parent.span)).entered
       tpd.ValDef(inlinedSym.asTerm, inlinedRhs(vdef.rhs.changeOwner(vdef.symbol, inlinedSym))).withSpan(parent.span) // TODO clone local classes?
 
     private def cloneTypeDef(tdef: TypeDef)(using Context): TypeDef =

tests/pos/inline-trait-body-rhs-type.scala

@@ -0,0 +1,6 @@
+inline trait A[T](x: T):
+  def f: T = x: T
+  def g: T = identity[T](x)
+  def h: this.type = this: this.type
+
+class B extends A("Hello")