Refactor TreeTypeMap

Break out an `InlinerMap` that contains inliner-specific overrides. This avoids
a global mode in TreeTypeMap that had to deal with inliner-specific behavior.

Author: odersky

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

@@ -22,8 +22,6 @@ import core.tasty.TreePickler.Hole
  *  @param newOwners New owners, replacing previous owners.
  *  @param substFrom The symbols that need to be substituted.
  *  @param substTo   The substitution targets.
- *  @param stopAtInlinedArgument  Whether one should stop at an inlined argument,
- *                    i.e. a node of form Inlined(EmptyTree, _, _).
  *
  *  The reason the substitution is broken out from the rest of the type map is
  *  that all symbols have to be substituted at the same time. If we do not do this,
@@ -38,16 +36,24 @@ import core.tasty.TreePickler.Hole
  *  nested scopes. Any subclass of TreeTypeMap would revert to the standard
  *  TreeTypeMap in these recursive invocations.
  */
-final class TreeTypeMap(
+class TreeTypeMap(
   val typeMap: Type => Type = IdentityTypeMap,
   val treeMap: tpd.Tree => tpd.Tree = identity _,
   val oldOwners: List[Symbol] = Nil,
   val newOwners: List[Symbol] = Nil,
   val substFrom: List[Symbol] = Nil,
-  val substTo: List[Symbol] = Nil,
-  stopAtInlinedArgument: Boolean = false)(using Context) extends tpd.TreeMap {
+  val substTo: List[Symbol] = Nil)(using Context) extends tpd.TreeMap {
   import tpd._
 
+  def copy(
+      typeMap: Type => Type,
+      treeMap: tpd.Tree => tpd.Tree,
+      oldOwners: List[Symbol],
+      newOwners: List[Symbol],
+      substFrom: List[Symbol],
+      substTo: List[Symbol])(using Context): TreeTypeMap =
+    new TreeTypeMap(typeMap, treeMap, oldOwners, newOwners, substFrom, substTo)
+
   /** If `sym` is one of `oldOwners`, replace by corresponding symbol in `newOwners` */
   def mapOwner(sym: Symbol): Symbol = sym.subst(oldOwners, newOwners)
 
@@ -119,15 +125,8 @@ final class TreeTypeMap(
           val (tmap1, stats1) = transformDefs(stats)
           val expr1 = tmap1.transform(expr)
           cpy.Block(blk)(stats1, expr1)
-        case inlined @ Inlined(call, bindings, expanded) =>
-          if stopAtInlinedArgument && call.isEmpty then
-            expanded match
-              case expanded: TypeTree => assert(bindings.isEmpty); expanded
-              case _ => inlined
-          else
-            val (tmap1, bindings1) = transformDefs(bindings)
-            val expanded1 = tmap1.transform(expanded)
-            cpy.Inlined(inlined)(call, bindings1, expanded1)
+        case inlined: Inlined =>
+          transformInlined(inlined)
         case cdef @ CaseDef(pat, guard, rhs) =>
           val tmap = withMappedSyms(patVars(pat))
           val pat1 = tmap.transform(pat)
@@ -183,14 +182,13 @@ final class TreeTypeMap(
       assert(!to.exists(substFrom contains _))
       assert(!from.exists(newOwners contains _))
       assert(!to.exists(oldOwners contains _))
-      new TreeTypeMap(
+      copy(
         typeMap,
         treeMap,
         from ++ oldOwners,
         to ++ newOwners,
         from ++ substFrom,
-        to ++ substTo,
-        stopAtInlinedArgument)
+        to ++ substTo)
     }
 
   /** Apply `typeMap` and `ownerMap` to given symbols `syms`

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

@@ -706,11 +706,40 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
     def inlinedFromOutside(tree: Tree)(span: Span): Tree =
       Inlined(EmptyTree, Nil, tree)(using ctx.withSource(inlinedMethod.topLevelClass.source)).withSpan(span)
 
+    // InlinerMap is a TreeTypeMap with special treatment for inlined arguments:
+    // They are generally left alone (not mapped further, and if they wrap a type
+    // the type Inlined wrapper gets dropped
+    class InlinerMap(
+        typeMap: Type => Type,
+        treeMap: Tree => Tree,
+        oldOwners: List[Symbol],
+        newOwners: List[Symbol],
+        substFrom: List[Symbol],
+        substTo: List[Symbol])(using Context)
+      extends TreeTypeMap(typeMap, treeMap, oldOwners, newOwners, substFrom, substTo):
+
+      override def copy(
+          typeMap: Type => Type,
+          treeMap: Tree => Tree,
+          oldOwners: List[Symbol],
+          newOwners: List[Symbol],
+          substFrom: List[Symbol],
+          substTo: List[Symbol])(using Context) =
+        new InlinerMap(typeMap, treeMap, oldOwners, newOwners, substFrom, substTo)
+
+      override def transformInlined(tree: Inlined)(using Context) =
+        if tree.call.isEmpty then
+          tree.expansion match
+            case expansion: TypeTree => expansion
+            case _ => tree
+        else super.transformInlined(tree)
+    end InlinerMap
+
     // A tree type map to prepare the inlined body for typechecked.
     // The translation maps references to `this` and parameters to
     // 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 TreeTypeMap(
+    val inliner = new InlinerMap(
       typeMap =
         new DeepTypeMap {
           def apply(t: Type) = t match {
@@ -753,7 +782,8 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
       },
       oldOwners = inlinedMethod :: Nil,
       newOwners = ctx.owner :: Nil,
-      stopAtInlinedArgument = true
+      substFrom = Nil,
+      substTo = Nil
     )(using inlineCtx)
 
     // Apply inliner to `rhsToInline`, split off any implicit bindings from result, and