Track splice calls instead of inline calls

The real thing that needs to be tracked for cyclic dependencies
are calls to spliced methods. Move the suspend machinery from
inline calls to these.

Author: odersky

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

@@ -47,6 +47,8 @@ object Splicer {
         interpretedExpr.fold(tree)(macroClosure => PickledQuotes.quotedExprToTree(macroClosure(QuoteContext())))
       }
       catch {
+        case ex: CompilationUnit.SuspendException =>
+          throw ex
         case ex: StopInterpretation =>
           ctx.error(ex.msg, ex.pos)
           EmptyTree
@@ -199,14 +201,14 @@ object Splicer {
         else if (fn.symbol.is(Module))
           interpretModuleAccess(fn.symbol)
         else if (fn.symbol.isStatic) {
-          val staticMethodCall = interpretedStaticMethodCall(fn.symbol.owner, fn.symbol)
+          val staticMethodCall = interpretedStaticMethodCall(fn.symbol.owner, fn.symbol, tree.sourcePos)
           staticMethodCall(args.flatten.map(interpretTree))
         }
         else if (fn.qualifier.symbol.is(Module) && fn.qualifier.symbol.isStatic)
           if (fn.name == nme.asInstanceOfPM)
             interpretModuleAccess(fn.qualifier.symbol)
           else {
-            val staticMethodCall = interpretedStaticMethodCall(fn.qualifier.symbol.moduleClass, fn.symbol)
+            val staticMethodCall = interpretedStaticMethodCall(fn.qualifier.symbol.moduleClass, fn.symbol, tree.sourcePos)
             staticMethodCall(args.flatten.map(interpretTree))
           }
         else if (env.contains(fn.symbol))
@@ -264,7 +266,12 @@ object Splicer {
     private def interpretQuoteContext()(implicit env: Env): Object =
       QuoteContext()
 
-    private def interpretedStaticMethodCall(moduleClass: Symbol, fn: Symbol)(implicit env: Env): List[Object] => Object = {
+    private def interpretedStaticMethodCall(moduleClass: Symbol, fn: Symbol, pos: SourcePosition)(implicit env: Env): List[Object] => Object = {
+      if fn.isDefinedInCurrentRun then
+        if ctx.compilationUnit.source.file == fn.associatedFile then
+          ctx.error("Cannot call macro defined in the same source file", pos)
+        ctx.compilationUnit.suspend()
+
       val (inst, clazz) =
         if (moduleClass.name.startsWith(str.REPL_SESSION_LINE))
           (null, loadReplLineClass(moduleClass))

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

@@ -70,10 +70,6 @@ object Inliner {
    */
   def inlineCall(tree: Tree)(implicit ctx: Context): Tree = {
     if (tree.symbol == defn.CompiletimeTesting_typeChecks) return Intrinsics.typeChecks(tree)
-    if tree.symbol.is(Macro) && tree.symbol.isDefinedInCurrentRun then
-      if ctx.compilationUnit.source.file == tree.symbol.associatedFile then
-        ctx.error("Cannot call macro defined in the same source file", tree.sourcePos)
-      ctx.compilationUnit.suspend()
 
    /** Set the position of all trees logically contained in the expansion of
     *  inlined call `call` to the position of `call`. This transform is necessary
@@ -1241,59 +1237,17 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(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 dependencies = macroDependencies(body)
-
-    if (dependencies.nonEmpty) {
-      var location = inlinedFrom.symbol
-      if (location.isLocalDummy) location = location.owner
-
-      val msg =
-        em"""Failed to expand macro. This macro depends on an implementation that is defined in the same project and not yet compiled.
-           |In particular ${inlinedFrom.symbol} depends on ${dependencies.map(_.show).mkString(", ")}.
-           |
-           |Moving ${dependencies.map(_.show).mkString(", ")} to a different project would fix this.
-           |""".stripMargin
-      ctx.error(msg, inlinedFrom.sourcePos)
-      EmptyTree
-    }
-    else {
-      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 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)
     }
+    val normalizedSplice = inlinedNormailizer.transform(evaluatedSplice)
+    if (normalizedSplice.isEmpty) normalizedSplice
+    else normalizedSplice.withSpan(span)
   }
-
-  /** Return the set of symbols that are refered at level -1 by the tree and defined in the current run.
-   *  This corresponds to the symbols that will need to be interpreted.
-   */
-  private def macroDependencies(tree: Tree)(implicit ctx: Context) =
-    new TreeAccumulator[Set[Symbol]] {
-      private[this] var level = -1
-      override def apply(syms: Set[Symbol], tree: tpd.Tree)(implicit ctx: Context): Set[Symbol] =
-        if (level != -1) foldOver(syms, tree)
-        else tree match {
-          case tree: RefTree if level == -1 && tree.symbol.isDefinedInCurrentRun && !tree.symbol.isLocal =>
-            foldOver(syms + tree.symbol, tree)
-          case Quoted(body) =>
-            level += 1
-            try apply(syms, body)
-            finally level -= 1
-          case Spliced(body) =>
-            level -= 1
-            try apply(syms, body)
-            finally level += 1
-          case _ =>
-            foldOver(syms, tree)
-        }
-    }.apply(Set.empty, tree)
 }
 

compiler/test/dotc/run-test-pickling.blacklist

@@ -16,6 +16,7 @@ derive-generic.scala
 mixin-forwarder-overload
 t8905
 t10889
+macros-in-same-project1
 i5257.scala
 enum-java
 tuple-ops.scala

tests/neg/macro-cycle1.scala

@@ -4,5 +4,5 @@ object Test {
 
   inline def foo: Unit = ${fooImpl}
 
-  foo
+  foo // error
 }