Ensure module of macro method is used for AST scope

This change allows macros to be extended from modules other than
`parentmodule(mac)` and have the scope of the AST be that of the module
the extension is written in.

This matches Julia's current semantics for macro extensions though it's
unclear how useful this actually is when different macro methods are
distinguished based only on the number of arguments.

Author: c42f

src/macro_expansion.jl

@@ -138,12 +138,15 @@ function expand_macro(ctx, ex)
     #   a macro expansion.
     # In either case, we need to set any unset scope layers before passing the
     # arguments to the macro call.
-    macro_args = [set_scope_layer(ctx, e, ctx.current_layer.id, false)
-                  for e in children(ex)[2:end]]
     mctx = MacroContext(ctx.graph, ex, ctx.current_layer)
+    macro_args = Any[mctx]
+    for i in 2:numchildren(ex)
+        push!(macro_args, set_scope_layer(ctx, ex[i], ctx.current_layer.id, false))
+    end
+    macro_invocation_world = Base.get_world_counter()
     expanded = try
         # TODO: Allow invoking old-style macros for compat
-        invokelatest(macfunc, mctx, macro_args...)
+        invokelatest(macfunc, macro_args...)
     catch exc
         if exc isa MacroExpansionError
             # Add context to the error.
@@ -162,7 +165,10 @@ function expand_macro(ctx, ex)
             expanded = copy_ast(ctx, expanded)
         end
         expanded = append_sourceref(ctx, expanded, ex)
-        new_layer = ScopeLayer(length(ctx.scope_layers)+1, parentmodule(macfunc), true)
+        # Module scope for the returned AST is the module where this particular
+        # method was defined (may be different from `parentmodule(macfunc)`)
+        mod_for_ast = lookup_method_instance(macfunc, macro_args, macro_invocation_world).def.module
+        new_layer = ScopeLayer(length(ctx.scope_layers)+1, mod_for_ast, true)
         push!(ctx.scope_layers, new_layer)
         inner_ctx = MacroExpansionContext(ctx.graph, ctx.bindings, ctx.scope_layers, new_layer)
         expanded = expand_forms_1(inner_ctx, expanded)

src/runtime.jl

@@ -418,3 +418,11 @@ function reserve_module_binding_i(mod, basename)
     end
 end
 
+function lookup_method_instance(func, args, world::Integer)
+    allargs = Vector{Any}(undef, length(args) + 1)
+    allargs[1] = func
+    allargs[2:end] = args
+    mi = @ccall jl_method_lookup(allargs::Ptr{Any}, length(allargs)::Csize_t,
+                                 world::Csize_t)::Ptr{Cvoid}
+    return mi == C_NULL ? nothing : unsafe_pointer_to_objref(mi)
+end

test/macros_ir.jl

@@ -1,3 +1,21 @@
+module MacroMethods
+    macro some_macro()
+        quote
+            some_global
+        end
+    end
+
+    module ExtraMacroMethods
+        using ..MacroMethods
+        macro MacroMethods.some_macro(ex)
+            quote
+                some_global
+            end
+        end
+    end
+end
+
+#*******************************************************************************
 ########################################
 # Simple macro
 macro add_one(ex)
@@ -42,6 +60,17 @@ end
 9   TestMod.@foo
 10  (return %₉)
 
+########################################
+# Scope for symbols emitted by macros is the module where the method was
+# defined, thus two different modules in this case, even though `@some_macro`
+# belongs to the MacroMethods module.
+(MacroMethods.@some_macro(), MacroMethods.@some_macro(unused))
+#---------------------
+1   TestMod.MacroMethods.some_global
+2   TestMod.MacroMethods.ExtraMacroMethods.some_global
+3   (call core.tuple %₁ %₂)
+4   (return %₃)
+
 ########################################
 # Error: Macro with kw args
 macro mmm(a; b=2)