Move blackbox macro exapnsion to ReifyQuotes

Author: nicolasstucki

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

@@ -261,8 +261,7 @@ class ReifyQuotes extends MacroTransform {
           case splice: Select => cpy.Select(splice)(body1, splice.name)
         }
       }
-      else {
-        assert(level == 1, "unexpected top splice outside quote")
+      else if (level == 1) {
         val (body1, quotes) = nested(isQuote = false).splitSplice(body)(spliceContext)
         val tpe = outer.embedded.getHoleType(body, splice)
         val hole = makeHole(splice.isTerm, body1, quotes, tpe).withSpan(splice.span)
@@ -272,6 +271,10 @@ class ReifyQuotes extends MacroTransform {
         // For example we can have a lifted tree containing the LHS of an assignment (see tests/run-with-compiler/quote-var.scala).
         if (splice.isType || outer.embedded.isLiftedSymbol(body.symbol)) hole
         else Inlined(EmptyTree, Nil, hole).withSpan(splice.span)
+      } else {
+        assert(level == 0, "unexpected splice insiced top splice")
+        val newBody = Inliner.expandMacro(body, splice.span)
+        transform(newBody)
       }
 
     /** Transforms the contents of a nested splice

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

@@ -254,6 +254,25 @@ object Inliner {
       val errors = compileForErrors(tree, false)
       packErrors(errors)
   }
+
+  def expandMacro(body: Tree, span: Span)(implicit ctx: Context) = {
+    assert(level == 0)
+    val inlinedFrom = enclosingInlineds.last
+    val ctx1 = tastyreflect.MacroExpansion.context(inlinedFrom)
+
+    val evaluatedSplice = Splicer.splice(body, inlinedFrom.sourcePos, MacroClassLoader.fromContext)(ctx1)
+
+    val inlinedNormailizer = new TreeMap {
+      override def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = tree match {
+        case Inlined(EmptyTree, Nil, expr) if enclosingInlineds.isEmpty => transform(expr)
+        case _ => super.transform(tree)
+      }
+    }
+    val normalizedSplice = inlinedNormailizer.transform(evaluatedSplice)
+    if (normalizedSplice.isEmpty) normalizedSplice
+    else normalizedSplice.withSpan(span)
+  }
+
 }
 
 /** Produces an inlined version of `call` via its `inlined` method.
@@ -1110,7 +1129,14 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
                         && level == 0
                         && call.symbol.is(Macro)
                         && !suppressInline =>
-          expandMacro(res.args.head, tree.span)
+          val body = res.args.head
+          checkMacroDependencies(body, call.sourcePos)
+          if call.symbol.is(Synthetic) then
+            expandMacro(res.args.head, tree.span)
+          else
+            // Blackbox macros expanded later in ReifyQuotes
+            ctx.compilationUnit.needsStaging = true
+            res
         case res => res
       }
 
@@ -1269,31 +1295,16 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
     }
   }
 
-  private def expandMacro(body: Tree, span: Span)(implicit ctx: Context) = {
+  private def checkMacroDependencies(body: Tree, callPos: SourcePosition)(implicit ctx: Context): Unit = {
     assert(level == 0)
-    val inlinedFrom = enclosingInlineds.last
-    val ctx1 = tastyreflect.MacroExpansion.context(inlinedFrom)
     val dependencies = macroDependencies(body)
-
     if dependencies.nonEmpty && !ctx.reporter.errorsReported then
       for sym <- dependencies do
         if ctx.compilationUnit.source.file == sym.associatedFile then
-          ctx.error(em"Cannot call macro $sym defined in the same source file", call.sourcePos)
+          ctx.error(em"Cannot call macro $sym defined in the same source file", callPos)
         if (ctx.settings.XprintSuspension.value)
-          ctx.echo(i"suspension triggered by macro call to ${sym.showLocated} in ${sym.associatedFile}", call.sourcePos)
+          ctx.echo(i"suspension triggered by macro call to ${sym.showLocated} in ${sym.associatedFile}", callPos)
       ctx.compilationUnit.suspend() // this throws a SuspendException
-
-    val evaluatedSplice = Splicer.splice(body, inlinedFrom.sourcePos, MacroClassLoader.fromContext)(ctx1)
-
-    val inlinedNormailizer = new TreeMap {
-      override def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = tree match {
-        case Inlined(EmptyTree, Nil, expr) if enclosingInlineds.isEmpty => transform(expr)
-        case _ => super.transform(tree)
-      }
-    }
-    val normalizedSplice = inlinedNormailizer.transform(evaluatedSplice)
-    if (normalizedSplice.isEmpty) normalizedSplice
-    else normalizedSplice.withSpan(span)
   }
 
   /** Return the set of symbols that are referred at level -1 by the tree and defined in the current run.

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

@@ -1655,6 +1655,12 @@ class Typer extends Namer
     if (sym.isInlineMethod)
       PrepareInlineable.registerInlineInfo(sym, _ => rhs1)
 
+    if (sym.isInlineMethod)
+      rhs1 match
+        case _: Typed =>
+        case _ => sym.setFlag(Synthetic) // FIXME Tag whitebox macros (do it in desugar)
+
+
     if (sym.isConstructor && !sym.isPrimaryConstructor) {
       val ename = sym.erasedName
       if (ename != sym.name)

tests/neg/i6530.scala

@@ -1,4 +1,7 @@
 object Macros {
   inline def q : Int = ${ '[ Int ] } // error
-  val x : Int = 1 + q // error
+  val x : Int = 1 + q
+
+  inline def q2 <: Int = ${ '[ Int ] } // error
+  val y : Int = 1 + q2 // error
 }

tests/run-macros/box/Macro_1.scala

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

tests/run-macros/box/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)
+  }
+}