Create InlineTreeMap, make helper function for param accessors

Author: timotheeandres

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

@@ -517,7 +517,53 @@ class Inliner(val call: tpd.Tree)(using Context):
     }
   }
 
+  protected class InlinerTreeMap extends (Tree => Tree) {
+    def apply(tree: Tree) = tree match {
+      case tree: This =>
+        tree.tpe match {
+          case thistpe: ThisType =>
+            val cls = thistpe.cls
+            if cls.isInlineTrait then
+              integrate(This(ctx.owner.asClass).withSpan(call.span), cls)
+            else thisProxy.get(cls) match {
+              case Some(t) =>
+                val thisRef = ref(t).withSpan(call.span)
+                inlinedFromOutside(thisRef)(tree.span)
+              case None => tree
+            }
+          case _ => tree
+        }
+      case tree: Ident =>
+        /* Span of the argument. Used when the argument is inlined directly without a binding */
+        def argSpan =
+          if (tree.name == nme.WILDCARD) tree.span // From type match
+          else if (tree.symbol.isTypeParam && tree.symbol.owner.isClass) tree.span // TODO is this the correct span?
+          else paramSpan(tree.name)
+        val inlinedCtx = ctx.withSource(inlinedMethod.topLevelClass.source)
+        paramProxy.get(tree.tpe) match {
+          case Some(t) if tree.isTerm && t.isSingleton =>
+            val inlinedSingleton = singleton(t).withSpan(argSpan)
+            inlinedFromOutside(inlinedSingleton)(tree.span)
+          case Some(t) if tree.isType =>
+            inlinedFromOutside(TypeTree(t).withSpan(argSpan))(tree.span)
+          case _ => tree
+        }
+      case tree @ Select(qual: This, name) if tree.symbol.is(Private) && tree.symbol.isInlineMethod =>
+        // This inline method refers to another (private) inline method (see tests/pos/i14042.scala).
+        // We insert upcast to access the private inline method once inlined. This makes the selection
+        // keep the symbol when re-typechecking in the InlineTyper. The method is inlined and hence no
+        // reference to a private method is kept at runtime.
+        cpy.Select(tree)(qual.asInstance(qual.tpe.widen), name)
+
+      case tree => tree
+    }
+
+    private def inlinedFromOutside(tree: Tree)(span: Span): Tree =
+      Inlined(EmptyTree, Nil, tree)(using ctx.withSource(inlinedMethod.topLevelClass.source)).withSpan(span)
+  }
+
   protected val inlinerTypeMap: InlinerTypeMap = InlinerTypeMap()
+  protected val inlinerTreeMap: InlinerTreeMap = InlinerTreeMap()
 
   /** The Inlined node representing the inlined call */
   def inlined(rhsToInline: tpd.Tree): (List[MemberDef], Tree) =
@@ -564,54 +610,13 @@ class Inliner(val call: tpd.Tree)(using Context):
 
     val inlineCtx = inlineContext(call).fresh.setTyper(inlineTyper).setNewScope
 
-    def inlinedFromOutside(tree: Tree)(span: Span): Tree =
-      Inlined(EmptyTree, Nil, tree)(using ctx.withSource(inlinedMethod.topLevelClass.source)).withSpan(span)
-
     // 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 InlinerMap(
       typeMap = inlinerTypeMap,
-      treeMap = {
-        case tree: This =>
-          tree.tpe match {
-            case thistpe: ThisType =>
-              val cls = thistpe.cls
-              if cls.isInlineTrait then
-                integrate(This(ctx.owner.asClass).withSpan(call.span), cls)
-              else thisProxy.get(cls) match {
-                case Some(t) =>
-                  val thisRef = ref(t).withSpan(call.span)
-                  inlinedFromOutside(thisRef)(tree.span)
-                case None => tree
-              }
-            case _ => tree
-          }
-        case tree: Ident =>
-          /* Span of the argument. Used when the argument is inlined directly without a binding */
-          def argSpan =
-            if (tree.name == nme.WILDCARD) tree.span // From type match
-            else if (tree.symbol.isTypeParam && tree.symbol.owner.isClass) tree.span // TODO is this the correct span?
-            else paramSpan(tree.name)
-          val inlinedCtx = ctx.withSource(inlinedMethod.topLevelClass.source)
-          paramProxy.get(tree.tpe) match {
-            case Some(t) if tree.isTerm && t.isSingleton =>
-              val inlinedSingleton = singleton(t).withSpan(argSpan)
-              inlinedFromOutside(inlinedSingleton)(tree.span)
-            case Some(t) if tree.isType =>
-              inlinedFromOutside(TypeTree(t).withSpan(argSpan))(tree.span)
-            case _ => tree
-          }
-        case tree @ Select(qual: This, name) if tree.symbol.is(Private) && tree.symbol.isInlineMethod =>
-          // This inline method refers to another (private) inline method (see tests/pos/i14042.scala).
-          // We insert upcast to access the private inline method once inlined. This makes the selection
-          // keep the symbol when re-typechecking in the InlineTyper. The method is inlined and hence no
-          // reference to a private method is kept at runtime.
-          cpy.Select(tree)(qual.asInstance(qual.tpe.widen), name)
-
-        case tree => tree
-      },
+      treeMap = inlinerTreeMap,
       oldOwners = inlinedMethod :: Nil,
       newOwners = ctx.owner :: Nil,
       substFrom = Nil,

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

@@ -505,6 +505,9 @@ object Inlines:
     private def isStatAlreadyOverridden(stat: Tree): Boolean =
       overriddenDecls.contains(stat.symbol)
 
+    extension (sym: Symbol)
+      private def isTermParamAccessor: Boolean = !sym.isType && sym.is(ParamAccessor)
+
     private def expandStat(stat: tpd.Tree, inlinedSym: Symbol): tpd.Tree = stat match
       case stat: ValDef =>
         inlinedValDef(stat, inlinedSym)
@@ -523,7 +526,7 @@ object Inlines:
         case _ =>
           var flags = sym.flags | Synthetic
           if sym.isType || !sym.is(Private) then flags |= Override
-          if !sym.isType && sym.is(ParamAccessor) then flags &~= ParamAccessor
+          if sym.isTermParamAccessor then flags &~= ParamAccessor
           sym.copy(
             owner = ctx.owner,
             flags = flags,
@@ -539,7 +542,7 @@ object Inlines:
 
     private def inlinedValDef(vdef: ValDef, inlinedSym: Symbol)(using Context): ValDef =
       val rhs =
-        if vdef.symbol.is(ParamAccessor) then
+        if vdef.symbol.isTermParamAccessor then
           paramAccessorsValueOf(vdef.symbol.name)
         else
           inlinedRhs(vdef.rhs.changeOwner(vdef.symbol, inlinedSym))