Expand non-transparent macros after Typer

Author: nicolasstucki

compiler/src/dotty/tools/dotc/core/Flags.scala

@@ -350,6 +350,8 @@ object Flags {
   /** An opaque type alias or a class containing one */
   val (Opaque @ _, _, _) = newFlags(43, "opaque")
 
+  /** An transparent inline method */
+  val (_, Transparent @ _, _) = newFlags(44, "transparent")
 
   // ------------ Flags following this one are not pickled ----------------------------------
 
@@ -421,7 +423,7 @@ object Flags {
     CommonSourceModifierFlags.toTypeFlags | Abstract | Sealed | Opaque | Open
 
   val TermSourceModifierFlags: FlagSet =
-    CommonSourceModifierFlags.toTermFlags | Inline | AbsOverride | Lazy | Erased
+    CommonSourceModifierFlags.toTermFlags | Inline | AbsOverride | Lazy | Erased | Transparent
 
   /** Flags representing modifiers that can appear in trees */
   val ModifierFlags: FlagSet =
@@ -438,7 +440,7 @@ object Flags {
     Scala2SpecialFlags, MutableOrOpen, Opaque, Touched, JavaStatic,
     OuterOrCovariant, LabelOrContravariant, CaseAccessor,
     Extension, NonMember, Implicit, Given, Permanent, Synthetic,
-    SuperParamAliasOrScala2x, Inline, Macro)
+    SuperParamAliasOrScala2x, Inline, Macro, Transparent)
 
   /** Flags that are not (re)set when completing the denotation, or, if symbol is
    *  a top-level class or object, when completing the denotation once the class

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -723,6 +723,7 @@ class TreePickler(pickler: TastyPickler) {
       if (flags.is(ParamAccessor)) writeModTag(PARAMsetter)
       if (flags.is(SuperParamAlias)) writeModTag(PARAMalias)
       if (flags.is(Exported)) writeModTag(EXPORTED)
+      if (flags.is(Transparent)) writeModTag(TRANSPARENT)
       assert(!(flags.is(Label)))
     }
     else {

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -644,6 +644,7 @@ class TreeUnpickler(reader: TastyReader,
           case INLINE => addFlag(Inline)
           case INLINEPROXY => addFlag(InlineProxy)
           case MACRO => addFlag(Macro)
+          case TRANSPARENT => addFlag(Transparent)
           case OPAQUE => addFlag(Opaque)
           case STATIC => addFlag(JavaStatic)
           case OBJECT => addFlag(Module)

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

@@ -186,12 +186,10 @@ class ReifyQuotes extends MacroTransform {
      *  are in the body of an inline method.
      */
     protected def transformSplice(body: Tree, splice: Apply)(using Context): Tree =
-      if (level > 1) {
+      if level > 1 then
         val body1 = nested(isQuote = false).transform(body)(using spliceContext)
         cpy.Apply(splice)(splice.fun, body1 :: Nil)
-      }
-      else {
-        assert(level == 1, "unexpected top splice outside quote")
+      else if level == 1 then
         val (body1, quotes) = nested(isQuote = false).splitSplice(body)(using spliceContext)
         val tpe = outer.embedded.getHoleType(body, splice)
         val hole = makeHole(splice.isTerm, body1, quotes, tpe).withSpan(splice.span)
@@ -201,7 +199,11 @@ 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 (outer.embedded.isLiftedSymbol(body.symbol)) hole
         else Inlined(EmptyTree, Nil, hole).withSpan(splice.span)
-      }
+      else
+        assert(level == 0, "unexpected splice inside top splice")
+        val newBody = Inliner.expandMacro(body, splice.span)
+        transform(newBody)
+      end if
 
      /** If inside a quote, split the body of the splice into a core and a list of embedded quotes
      *  and make a hole from these parts. Otherwise issue an error, unless we
@@ -386,6 +388,10 @@ class ReifyQuotes extends MacroTransform {
             }
             tree.symbol.annotations = newAnnotations
             super.transform(tree)
+          case _: Select | _: GenericApply[_] if tree.symbol.is(Inline) =>
+            // Inline calls to inline definitions that where generated by a macro
+            val inlined = Inliner.inlineCall(tree)
+            transform(inlined)
           case _ =>
             super.transform(tree)
         }

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

@@ -331,6 +331,24 @@ 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 evaluatedSplice = inContext(dotc.quoted.MacroExpansion.context(inlinedFrom)) {
+      Splicer.splice(body, inlinedFrom.sourcePos, MacroClassLoader.fromContext)
+    }
+
+    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.
@@ -1254,14 +1272,21 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
       super.typedValDef(vdef1, sym)
 
     override def typedApply(tree: untpd.Apply, pt: Type)(using Context): Tree =
-      constToLiteral(betaReduce(super.typedApply(tree, pt))) match {
+      constToLiteral(betaReduce(super.typedApply(tree, pt))) match
         case res: Apply if res.symbol == defn.InternalQuoted_exprSplice
                         && level == 0
                         && !suppressInline =>
-          val expanded = expandMacro(res.args.head, tree.span)
-          typedExpr(expanded) // Inline calls and constant fold code generated by the macro
+          val body = res.args.head
+          checkMacroDependencies(body, call.sourcePos)
+          if call.symbol.is(Transparent) then
+            val expanded = expandMacro(res.args.head, tree.span)
+            typedExpr(expanded) // Inline calls and constant fold code generated by the macro
+          else
+            // Blackbox macros expanded later in ReifyQuotes
+            ctx.compilationUnit.needsStaging = true
+            res
         case res => res
-      }
+      end match
 
     override def typedMatchFinish(tree: untpd.Match, sel: Tree, wideSelType: Type, cases: List[untpd.CaseDef], pt: Type)(using Context) =
       if (!tree.isInline || ctx.owner.isInlineMethod) // don't reduce match of nested inline method yet
@@ -1417,32 +1442,19 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
     }
   }
 
-  private def expandMacro(body: Tree, span: Span)(using Context) = {
+  private def checkMacroDependencies(body: Tree, callPos: SrcPos)(implicit ctx: Context): Unit = {
     assert(level == 0)
     val inlinedFrom = enclosingInlineds.last
     val dependencies = macroDependencies(body)
     val suspendable = ctx.compilationUnit.isSuspendable
     if dependencies.nonEmpty && !ctx.reporter.errorsReported then
       for sym <- dependencies do
         if ctx.compilationUnit.source.file == sym.associatedFile then
-          report.error(em"Cannot call macro $sym defined in the same source file", call.srcPos)
+          report.error(em"Cannot call macro $sym defined in the same source file", callPos)
         if (suspendable && ctx.settings.XprintSuspension.value)
-          report.echo(i"suspension triggered by macro call to ${sym.showLocated} in ${sym.associatedFile}", call.srcPos)
+          report.echo(i"suspension triggered by macro call to ${sym.showLocated} in ${sym.associatedFile}", callPos)
       if suspendable then
         ctx.compilationUnit.suspend() // this throws a SuspendException
-
-    val evaluatedSplice = inContext(quoted.MacroExpansion.context(inlinedFrom)) {
-      Splicer.splice(body, inlinedFrom.srcPos, MacroClassLoader.fromContext)
-    }
-    val inlinedNormailizer = new TreeMap {
-      override def transform(tree: tpd.Tree)(using 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

@@ -1983,6 +1983,9 @@ class Typer extends Namer
 
     if sym.isInlineMethod then
       val rhsToInline = PrepareInlineable.wrapRHS(ddef, tpt1, rhs1)
+      rhsToInline match
+        case _: Typed =>
+        case _ => sym.setFlag(Transparent) // FIXME Tag whitebox macros (do it in desugar)
       PrepareInlineable.registerInlineInfo(sym, rhsToInline)
 
     if (sym.isConstructor && !sym.isPrimaryConstructor) {

tasty/src/dotty/tools/tasty/TastyFormat.scala

@@ -253,7 +253,7 @@ Standard Section: "Comments" Comment*
 object TastyFormat {
 
   final val header: Array[Int] = Array(0x5C, 0xA1, 0xAB, 0x1F)
-  val MajorVersion: Int = 24
+  val MajorVersion: Int = 25
   val MinorVersion: Int = 0
 
   /** Tags used to serialize names, should update [[nameTagToString]] if a new constant is added */
@@ -350,16 +350,17 @@ object TastyFormat {
   final val HASDEFAULT = 31
   final val STABLE = 32
   final val MACRO = 33
-  final val ERASED = 34
-  final val OPAQUE = 35
-  final val EXTENSION = 36
-  final val GIVEN = 37
-  final val PARAMsetter = 38
-  final val EXPORTED = 39
-  final val OPEN = 40
-  final val PARAMEND = 41
-  final val PARAMalias = 42
-  final val SUPERTRAIT = 43
+  final val TRANSPARENT = 34
+  final val ERASED = 35
+  final val OPAQUE = 36
+  final val EXTENSION = 37
+  final val GIVEN = 38
+  final val PARAMsetter = 39
+  final val EXPORTED = 40
+  final val OPEN = 41
+  final val PARAMEND = 42
+  final val PARAMalias = 43
+  final val SUPERTRAIT = 44
 
   // Cat. 2:    tag Nat
 
@@ -498,6 +499,7 @@ object TastyFormat {
        | INLINE
        | INLINEPROXY
        | MACRO
+       | TRANSPARENT
        | OPAQUE
        | STATIC
        | OBJECT
@@ -559,6 +561,7 @@ object TastyFormat {
     case INLINE => "INLINE"
     case INLINEPROXY => "INLINEPROXY"
     case MACRO => "MACRO"
+    case TRANSPARENT => "TRANSPARENT"
     case OPAQUE => "OPAQUE"
     case STATIC => "STATIC"
     case OBJECT => "OBJECT"

tests/neg-macros/i6530.scala

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

tests/neg-macros/i9014.check

@@ -2,9 +2,5 @@
 -- Error: tests/neg-macros/i9014/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 DottyPredef.
-  |                I found:
-  |
-  |                    given_Bar
-  |
-  |                But method given_Bar does not match type Bar.
+  |                       Failed to expand!
+  | This location contains code that was inlined from Test_2.scala:1

tests/pos-macros/i8764/Macro_1.scala

@@ -0,0 +1,90 @@
+package izumi.reflect.dottyreflection
+
+import scala.quoted.{Expr, QuoteContext}
+
+object Inspect {
+  inline def inspect[T <: AnyKind]: String = ${ inspectAny[T] }
+
+  def inspectAny[T <: AnyKind : quoted.Type](using qctx0: QuoteContext): Expr[String] = {
+    val ref = new Inspector().buildTypeRef[T]
+    // println(s"result: $ref")
+    Expr(ref.toString)
+  }
+}
+
+final case class NameReference(ref: String, prefix: Option[NameReference]) {
+  override def toString: String = prefix.fold("")(p => s"$p::") + ref
+}
+
+class Inspector(implicit qctx: QuoteContext) {
+  import qctx.tasty._
+
+  protected def log(s: String) = {
+    // println(" -> " + s)
+  }
+
+  def buildTypeRef[T <: AnyKind](using tpe: quoted.Type[T]): NameReference = {
+    val uns = tpe.unseal
+    log(s" -------- about to inspect ${tpe} --------")
+    val v = inspectTree(uns)
+    log(s" -------- done inspecting ${tpe} --------")
+    v
+  }
+
+  private def inspectTree(tpeTree: TypeTree): NameReference = {
+    log(s"INSPECT: $tpeTree: ${tpeTree.getClass}")
+    if (tpeTree.symbol.isNoSymbol) {
+      inspectType(tpeTree.tpe)
+    } else {
+      inspectSymbol(tpeTree.symbol)
+    }
+  }
+
+  private def inspectType(tpe: Type): NameReference = {
+    log(s"INSPECT: type `$tpe`")
+    tpe match {
+      case r: TypeRef =>
+        inspectSymbol(r.typeSymbol)
+
+      case a: AnnotatedType =>
+        inspectType(a.underlying)
+
+      case lazyref if lazyref.getClass.getName.contains("LazyRef") => // upstream bug seems like
+        log(s"LazyRef occured $lazyref")
+        throw new RuntimeException(s"LazyRef occured $lazyref")
+
+      case o =>
+        log(s"Type, UNSUPPORTED: ${o.getClass} - $o")
+        throw new RuntimeException(s"Type, UNSUPPORTED: ${o.getClass} - $o")
+    }
+  }
+
+  private def inspectSymbol(symbol: Symbol): NameReference = {
+    log(s"INSPECT: symbol `$symbol`")
+    symbol.tree match {
+      case c: ClassDef =>
+        symbolToNameReference(symbol)
+
+      case t: TypeDef =>
+        inspectTree(t.rhs.asInstanceOf[TypeTree])
+
+      case v: ValDef =>
+        inspectTree(v.tpt)
+
+      case o =>
+        log(s"SYMBOL TREE, UNSUPPORTED: $o")
+        throw new RuntimeException(s"SYMBOL TREE, UNSUPPORTED: ${o.getClass} - $o")
+    }
+  }
+
+  private def symbolToNameReference(sym: Symbol): NameReference = {
+    val prefix = if (sym.maybeOwner.isNoSymbol) {
+      None
+    } else {
+      if sym.owner.isPackageDef then None
+      else Some(inspectSymbol(sym.maybeOwner))
+    }
+    NameReference(sym.fullName, prefix)
+  }
+
+}

tests/pos-macros/i8764/Macro_2.scala

@@ -0,0 +1,16 @@
+package test
+
+import izumi.reflect.dottyreflection.Inspect.inspect
+
+object Test1  {
+
+  class Foo
+  println(inspect[Foo])
+
+  def test1(): Unit =
+    inspect[Foo]
+
+  def test2() =
+    inspect[Foo]
+
+}

tests/run-custom-args/Yretain-trees/tasty-load-tree-2.check

@@ -1,2 +1,2 @@
-DefDef("foo", Nil, Nil, Inferred(), None)
-ValDef("bar", Inferred(), None)
+DefDef("foo", Nil, Nil, TypeIdent("Int"), Some(Apply(Select(Literal(Constant.Int(1)), "+"), List(Literal(Constant.Int(2))))))
+ValDef("bar", TypeIdent("Int"), Some(Apply(Select(Literal(Constant.Int(2)), "+"), List(Literal(Constant.Int(3))))))

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