Move inline β-reduction after post typer

Author: nicolasstucki

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -37,9 +37,9 @@ class Compiler {
   protected def frontendPhases: List[List[Phase]] =
     List(new FrontEnd) ::           // Compiler frontend: scanner, parser, namer, typer
     List(new sbt.ExtractDependencies) :: // Sends information on classes' dependencies to sbt via callbacks
-    List(new InlineCalls) ::        // β-reduce inline calls
     List(new PostTyper) ::          // Additional checks and cleanups after type checking
     List(new sbt.ExtractAPI) ::     // Sends a representation of the API of classes to sbt via callbacks
+    List(new InlineCalls) ::        // β-reduce inline calls
     Nil
 
   /** Phases dealing with TASTY tree pickling and unpickling */

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

@@ -23,11 +23,33 @@ 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 =>
-        transform(Inliner.inlineCall(tree, tree.tpe.widen))
+        normalize(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
+        newTree
       case _ =>
         super.transform(tree)
     }
+  }
 
+  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
   }
 }
 

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

@@ -178,6 +178,11 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
       }
     }
 
+    private def handleInlineCall(sym: Symbol)(implicit ctx: Context): Unit = {
+      if (sym.is(Inline))
+        ctx.compilationUnit.containsQuotesOrSplices = true
+    }
+
     private object dropInlines extends TreeMap {
       override def transform(tree: Tree)(implicit ctx: Context): Tree = tree match {
         case Inlined(call, _, _) =>
@@ -189,12 +194,14 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
     override def transform(tree: Tree)(implicit ctx: Context): Tree =
       try tree match {
         case tree: Ident if !tree.isType =>
+          handleInlineCall(tree.symbol)
           handleMeta(tree.symbol)
           tree.tpe match {
             case tpe: ThisType => This(tpe.cls).withPos(tree.pos)
             case _ => tree
           }
         case tree @ Select(qual, name) =>
+          handleInlineCall(tree.symbol)
           handleMeta(tree.symbol)
           if (name.isTypeName) {
             Checking.checkRealizable(qual.tpe, qual.pos.focus)
@@ -203,6 +210,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           else
             transformSelect(tree, Nil)
         case tree: Apply =>
+          handleInlineCall(tree.symbol)
           val methType = tree.fun.tpe.widen
           val app =
             if (methType.isErasedMethod)
@@ -223,6 +231,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
               super.transform(app)
           }
         case tree: TypeApply =>
+          handleInlineCall(tree.symbol)
           val tree1 @ TypeApply(fn, args) = normalizeTypeArgs(tree)
           if (fn.symbol != defn.ChildAnnot.primaryConstructor) {
             // Make an exception for ChildAnnot, which should really have AnyKind bounds
@@ -236,19 +245,6 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
             case _ =>
               super.transform(tree1)
           }
-        case Inlined(call, bindings, expansion) if !call.isEmpty =>
-          // 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, transformSub(bindings), transform(expansion)(inlineContext(call)))
         case tree: Template =>
           withNoCheckNews(tree.parents.flatMap(newPart)) {
             val templ1 = paramFwd.forwardParamAccessors(tree)