Inline non-transparent calls after Pickler

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 PickleQuotes) ::       // Turn quoted trees into explicit run-time data structures
     Nil
 

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -186,6 +186,9 @@ class ScalaSettings extends Settings.SettingGroup {
   val Yinstrument: Setting[Boolean] = BooleanSetting("-Yinstrument", "Add instrumentation code that counts allocations and closure creations.")
   val YinstrumentDefs: Setting[Boolean] = BooleanSetting("-Yinstrument-defs", "Add instrumentation code that counts method calls; needs -Yinstrument to be set, too.")
 
+  // TODO Remove. Added to help bootstrappting this change.
+  val YinlineBlackboxAfterTyper: Setting[Boolean] = BooleanSetting("-Yinline-blackbox-after-typer", "")
+
   /** Dottydoc specific settings */
   val siteRoot: Setting[String] = StringSetting(
     "-siteroot",

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

@@ -0,0 +1,82 @@
+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 | _: Block =>
+          super.transform(tree)
+        case _ if Inliner.isInlineable(tree) && !tree.tpe.widen.isInstanceOf[MethodOrPoly] =>
+          val tree1 = super.transform(tree)
+          val inlined = Inliner.inlineCall(tree1)
+          if tree1 eq inlined then inlined
+          else transform(inlined)
+        case _ =>
+          super.transform(tree)
+
+  }
+}
+
+object Inlining {
+  val name: String = "inlining"
+}
+
+// inlined class definition
+// tests/pos/i7068-a.scala failed
+// tests/pos/i7068-b.scala failed
+
+// tulpe xxl: deep subtypes
+// tests/pos/i7580.scala failed
+
+// inlined inline match proxy failing
+// tests/pos/i8892.scala failed
+
+// inlined inline val not pure
+// tests/pos/i8843.scala failed

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

@@ -43,7 +43,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
@@ -62,6 +62,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 =
+    sym.exists && !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

@@ -3272,6 +3272,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)
@@ -3614,7 +3615,7 @@ class Typer extends Namer
   }
 
   // Overridden in InlineTyper
-  def suppressInline(using Context): Boolean = ctx.isAfterTyper
+  def suppressInline(using Context): Boolean = ctx.isAfterTyper && ctx.phase.phaseName != "inlining"
 
   /** Does the "contextuality" of the method type `methType` match the one of the prototype `pt`?
    *  This is the case if

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -39,7 +39,7 @@ class CompilationTests {
       compileFilesInDir("tests/new", defaultOptions),
       compileFilesInDir("tests/pos-scala2", scala2CompatMode),
       compileFilesInDir("tests/pos-custom-args/erased", defaultOptions.and("-Yerased-terms")),
-      compileFilesInDir("tests/pos", defaultOptions),
+      compileFilesInDir("tests/pos", defaultOptions /*and "-Yinline-blackbox-after-typer"*/),
       compileFilesInDir("tests/pos-deep-subtype", allowDeepSubtypes),
       compileFile(
         // succeeds despite -Xfatal-warnings because of -nowarn

library/src/scala/compiletime/package.scala

@@ -141,7 +141,8 @@ package object compiletime {
    *  @tparam T the tuple containing the types of the values to be summoned
    *  @return the given values typed as elements of the tuple
    */
-  inline def summonAll[T <: Tuple]: Widen[T] =
+  // FIXME: missing span in tests/run/summonAll.scala
+  /*transparent */inline def summonAll[T <: Tuple]: Widen[T] =
     val res =
       inline erasedValue[T] match
         case _: EmptyTuple => EmptyTuple

tests/neg-macros/i9014/Macros_1.scala

@@ -1,4 +1,4 @@
 import scala.quoted._
 trait Bar
-inline given Bar = ${ impl }
+transparent inline given Bar = ${ impl }
 def impl(using Quotes): Expr[Bar] = quotes.reflect.report.throwError("Failed to expand!")

tests/neg-macros/i9014b.check

@@ -0,0 +1,10 @@
+
+-- Error: tests/neg-macros/i9014b/Test_2.scala:1:23 --------------------------------------------------------------------
+1 |val tests = summon[Bar] // error
+  |                       ^
+  |                     no implicit argument of type Bar was found for parameter x of method summon in object Predef.
+  |                     I found:
+  |
+  |                         given_Bar
+  |
+  |                     But method given_Bar does not match type Bar.

tests/neg-macros/i9014b/Macros_1.scala

@@ -0,0 +1,4 @@
+import scala.quoted._
+trait Bar
+inline given Bar = ${ impl }
+def impl(using Quotes): Expr[Bar] = quotes.reflect.report.throwError("Failed to expand!")

tests/neg-macros/i9014b/Test_2.scala

@@ -0,0 +1 @@
+val tests = summon[Bar] // error

tests/run-macros/no-symbol/2.scala

@@ -1,6 +1,6 @@
 object Test {
   def main(args: Array[String]): Unit = {
     assert(Macro.foo[Foo] == "symbol")
-    assert(Macro.foo[Box] == "no symbol")
+    assert(Macro.foo[Box[_]] == "no symbol")
   }
 }

tests/run-macros/whitebox-inline-macro/Macro_1.scala

@@ -0,0 +1,11 @@
+import scala.quoted._
+
+object Macros {
+
+  inline def blackbox: Int = ${one}
+
+  transparent inline def whitebox: Int = ${one}
+
+  private def one(using Quotes): Expr[Int] = Expr(1)
+
+}

tests/run-macros/whitebox-inline-macro/Test_2.scala

@@ -0,0 +1,12 @@
+import scala.quoted._
+import Macros._
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    val a: Int = blackbox
+    val b: 1 = whitebox
+
+    assert(a == 1)
+    assert(b == 1)
+  }
+}

tests/run/whitebox-inline.scala

@@ -0,0 +1,16 @@
+import scala.quoted._
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    val a: Int = blackbox
+    val b: 1 = whitebox
+
+    assert(a == 1)
+    assert(b == 1)
+  }
+
+  inline def blackbox: Int = 1
+
+  transparent inline def whitebox: Int = 1
+
+}