Move inline β-reduction out of typer

Author: nicolasstucki

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

@@ -37,6 +37,7 @@ 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
     Nil

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

@@ -0,0 +1,36 @@
+package dotty.tools.dotc.transform
+
+import dotty.tools.dotc.ast.Trees._
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Phases.Phase
+import dotty.tools.dotc.typer.Inliner
+
+
+class InlineCalls extends MacroTransform { thisPhase =>
+  import tpd._
+
+  override def phaseName: String = InlineCalls.name
+
+  override def run(implicit ctx: Context): Unit =
+    if (!ctx.settings.YnoInline.value) super.run
+
+  override def transformPhase(implicit ctx: Context): Phase = thisPhase.next
+
+  protected def newTransformer(implicit ctx: Context): Transformer =
+    new InlineCallsTransformer
+
+  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))
+      case _ =>
+        super.transform(tree)
+    }
+
+  }
+}
+
+object InlineCalls {
+  final val name = "inlineCalls"
+}

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

@@ -2441,13 +2441,6 @@ class Typer extends Namer
         checkEqualityEvidence(tree, pt)
         tree
       }
-      else if (Inliner.isInlineable(tree) &&
-               !ctx.settings.YnoInline.value &&
-               !ctx.isAfterTyper &&
-               !ctx.reporter.hasErrors &&
-               tree.tpe <:< pt) {
-        readaptSimplified(Inliner.inlineCall(tree, pt))
-      }
       else if (tree.tpe <:< pt) {
         if (pt.hasAnnotation(defn.InlineParamAnnot))
           checkInlineConformant(tree, isFinal = false, "argument to inline parameter")