Normalize call at Inlined node creation

Author: nicolasstucki

compiler/src/dotty/tools/dotc/transform/InlineCalls.scala

@@ -23,7 +23,7 @@ class InlineCalls extends MacroTransform { thisPhase =>
   class InlineCallsTransformer extends Transformer {
     override def transform(tree: Tree)(implicit ctx: Context): Tree = tree match {
       case _: RefTree | _: GenericApply[_] if Inliner.isInlineable(tree) && !ctx.reporter.hasErrors =>
-        normalize(transform(Inliner.inlineCall(tree, tree.tpe.widen)))
+        transform(Inliner.inlineCall(tree, tree.tpe.widen))
       case _: MemberDef =>
         val newTree = super.transform(tree)
         newTree.symbol.defTree = newTree // update tree set in PostTyper or set for inlined members
@@ -33,24 +33,6 @@ class InlineCalls extends MacroTransform { thisPhase =>
     }
   }
 
-  def normalize(tree: Tree)(implicit ctx: Context): Tree = tree match {
-    case Inlined(call, bindings, expansion) if !call.isEmpty =>
-      // TODO: Normalize when Inlined is created. We never use the full call, we always collapse it first.
-      // Leave only a call trace consisting of
-      //  - a reference to the top-level class from which the call was inlined,
-      //  - the call's position
-      // in the call field of an Inlined node.
-      // The trace has enough info to completely reconstruct positions.
-      // The minimization is done for two reasons:
-      //  1. To save space (calls might contain large inline arguments, which would otherwise
-      //     be duplicated
-      //  2. To enable correct pickling (calls can share symbols with the inlined code, which
-      //     would trigger an assertion when pickling).
-      val callTrace = Ident(call.symbol.topLevelClass.typeRef).withPos(call.pos)
-      cpy.Inlined(tree)(callTrace, bindings, expansion)
-    case _ =>
-      tree
-  }
 }
 
 object InlineCalls {

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

@@ -452,9 +452,21 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
 
       if (inlinedMethod == defn.Typelevel_error) issueError()
 
+      // Leave only a call trace consisting of
+      //  - a reference to the top-level class from which the call was inlined,
+      //  - the call's position
+      // in the call field of an Inlined node.
+      // The trace has enough info to completely reconstruct positions.
+      // The minimization is done for two reasons:
+      //  1. To save space (calls might contain large inline arguments, which would otherwise
+      //     be duplicated
+      //  2. To enable correct pickling (calls can share symbols with the inlined code, which
+      //     would trigger an assertion when pickling).
+      val callTrace = Ident(call.symbol.topLevelClass.typeRef).withPos(call.pos)
+
       // Take care that only argument bindings go into `bindings`, since positions are
       // different for bindings from arguments and bindings from body.
-      tpd.Inlined(call, finalBindings, finalExpansion)
+      tpd.Inlined(callTrace, finalBindings, finalExpansion)
     }
   }