Add basic infrastructure to inline after typer

Author: nicolasstucki

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

@@ -50,6 +50,7 @@ class Compiler {
   /** Phases dealing with TASTY tree pickling and unpickling */
   protected def picklerPhases: List[List[Phase]] =
     List(new Pickler) ::            // Generate TASTY info
+    List(new Inlining) ::           // Inline and execute macros
     List(new ReifyQuotes) ::        // Turn quoted trees into explicit run-time data structures
     Nil
 

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

@@ -0,0 +1,67 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Decorators._
+import Flags._
+import Types._
+import Contexts._
+import Symbols._
+import Constants._
+import ast.Trees._
+import ast.{TreeTypeMap, untpd}
+import util.Spans._
+import tasty.TreePickler.Hole
+import SymUtils._
+import NameKinds._
+import dotty.tools.dotc.ast.tpd
+import typer.Implicits.SearchFailureType
+
+import scala.collection.mutable
+import dotty.tools.dotc.core.Annotations._
+import dotty.tools.dotc.core.Names._
+import dotty.tools.dotc.core.StdNames._
+import dotty.tools.dotc.quoted._
+import dotty.tools.dotc.transform.TreeMapWithStages._
+import dotty.tools.dotc.typer.Inliner
+
+import scala.annotation.constructorOnly
+
+
+class Inlining extends MacroTransform {
+  import tpd._
+
+  override def phaseName: String = Inlining.name
+
+  override def allowsImplicitSearch: Boolean = true
+
+  override def run(using Context): Unit =
+    if (ctx.settings.YinlineBlackboxAfterTyper.value) super.run
+
+  override def checkPostCondition(tree: Tree)(using Context): Unit =
+    tree match {
+      case tree: RefTree if !Inliner.inInlineMethod =>
+        assert(!tree.symbol.isInlineMethod)
+      case _ =>
+    }
+
+  protected def newTransformer(using Context): Transformer = new Transformer {
+    override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
+      tree match
+        case tree: DefTree =>
+          if tree.symbol.is(Inline) then tree
+          else super.transform(tree)
+        case _: Typed =>
+          super.transform(tree)
+        case _ if Inliner.isInlineable(tree) && !Inliner.inInlineMethod =>
+          val inlined = Inliner.inlineCall(tree)
+          super.transform(inlined)
+        case _ =>
+          super.transform(tree)
+
+  }
+}
+
+object Inlining {
+  val name: String = "inlining"
+}

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

@@ -42,7 +42,7 @@ object Inliner {
    *  @pre  hasBodyToInline(sym)
    */
   def bodyToInline(sym: SymDenotation)(using Context): Tree =
-    if (sym.isInlineMethod && sym.hasAnnotation(defn.BodyAnnot))
+    if hasBodyToInline(sym) then
       sym.getAnnotation(defn.BodyAnnot).get.tree
     else
       EmptyTree
@@ -61,6 +61,10 @@ object Inliner {
     case _ => isInlineable(tree.symbol) && !tree.tpe.isInstanceOf[MethodOrPoly]
   }
 
+  /** `sym` is an inline method with a known body to inline which looks like a tansparent inline */
+  def hasTransparentBody(sym: SymDenotation)(using Context): Boolean =
+    !bodyToInline(sym).isInstanceOf[Typed] // may have false negatives
+
   /** Try to inline a call to an inline method. Fail with error if the maximal
    *  inline depth is exceeded.
    *

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

@@ -3249,6 +3249,7 @@ class Typer extends Namer
       else if (methPart(tree).symbol.isAllOf(Inline | Deferred) && !Inliner.inInlineMethod) then
         errorTree(tree, i"Deferred inline ${methPart(tree).symbol.showLocated} cannot be invoked")
       else if (Inliner.isInlineable(tree) &&
+               (!ctx.settings.YinlineBlackboxAfterTyper.value || Inliner.hasTransparentBody(tree.symbol)) &&
                !ctx.settings.YnoInline.value &&
                !suppressInline) {
         tree.tpe <:< wildApprox(pt)