Marks macros when top level splices are created

Author: nicolasstucki

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

@@ -217,20 +217,6 @@ object Applications {
   class ExtMethodApply(app: Tree)(implicit @constructorOnly src: SourceFile)
   extends IntegratedTypeArgs(app)
 
-  /** If we are in an inline method but not in a nested quote, mark the inline method
-   *  as a macro.
-   */
-  def handleMeta(tree: Tree)(implicit ctx: Context): tree.type = {
-    import transform.SymUtils._
-
-    def markAsMacro(c: Context): Unit =
-      if (c.owner eq c.outer.owner) markAsMacro(c.outer)
-      else if (c.owner.isInlineMethod) c.owner.setFlag(Macro)
-      else if (!c.outer.owner.is(Package)) markAsMacro(c.outer)
-    if (tree.symbol.isSplice && StagingContext.level == 0)
-      markAsMacro(ctx)
-    tree
-  }
 }
 
 trait Applications extends Compatibility { self: Typer with Dynamic =>
@@ -811,7 +797,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
    *  or, if application is an operator assignment, also an `Assign` or
    *  Block node.
    */
-  def typedApply(tree: untpd.Apply, pt: Type)(implicit ctx: Context): Tree = handleMeta {
+  def typedApply(tree: untpd.Apply, pt: Type)(implicit ctx: Context): Tree = {
 
     def realApply(implicit ctx: Context): Tree = track("realApply") {
       val originalProto = new FunProto(tree.args, IgnoredProto(pt))(this, tree.isContextual)(argCtx(tree))
@@ -955,7 +941,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     val isNamed = hasNamedArg(tree.args)
     val typedArgs = if (isNamed) typedNamedArgs(tree.args) else tree.args.mapconserve(typedType(_))
     record("typedTypeApply")
-    handleMeta(typedFunPart(tree.fun, PolyProto(typedArgs, pt)) match {
+    typedFunPart(tree.fun, PolyProto(typedArgs, pt)) match {
       case IntegratedTypeArgs(app) =>
         app
       case _: TypeApply if !ctx.isAfterTyper =>
@@ -977,7 +963,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
         }
         if (typedFn.tpe eq TryDynamicCallType) tryDynamicTypeApply()
         else assignType(cpy.TypeApply(tree)(typedFn, typedArgs), typedFn, typedArgs)
-    })
+    }
   }
 
   /** Rewrite `new Array[T](....)` if T is an unbounded generic to calls to newGenericArray.

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

@@ -449,8 +449,7 @@ class Typer extends Namer
       }
     case qual =>
       if (tree.name.isTypeName) checkStable(qual.tpe, qual.sourcePos)
-      val select = Applications.handleMeta(
-        checkValue(assignType(cpy.Select(tree)(qual, tree.name), qual), pt))
+      val select = checkValue(assignType(cpy.Select(tree)(qual, tree.name), qual), pt)
       if (select.tpe ne TryDynamicCallType) ConstFold(checkStableIdentPattern(select, pt))
       else if (pt.isInstanceOf[FunOrPolyProto] || pt == AssignProto) select
       else typedDynamicSelect(tree, Nil, pt)
@@ -2027,8 +2026,17 @@ class Typer extends Namer
             tree.withType(UnspecifiedErrorType)
           }
         }
-        else
+        else {
+          if (StagingContext.level == 0) {
+            // Mark the first inline method from the context as a macro
+            def markAsMacro(c: Context): Unit =
+              if (c.owner eq c.outer.owner) markAsMacro(c.outer)
+              else if (c.owner.isInlineMethod) c.owner.setFlag(Macro)
+              else if (!c.outer.owner.is(Package)) markAsMacro(c.outer)
+            markAsMacro(ctx)
+          }
           typedApply(untpd.Apply(untpd.ref(defn.InternalQuoted_exprSpliceR), tree.expr), pt)(spliceContext).withSpan(tree.span)
+        }
     }
   }