Implement macros based on cyclic (sub)module dependencies - module

Question

If you have two modules, A and B, which should contain two functions, bar and baz, that depend each other's module, this can be implemented by first declaring the functions as empty, and adding methods afterwards:
module Wrapper
module A
const x = 1
function bar end
end # module A
module B
const x = 2
function baz end
end # module B
import .A: bar
import .B: baz
bar(expr) = quote
println("bar", $(B.x))
$expr
end
baz(expr) = quote
println("baz", $(A.x))
$expr
end
end # module Wrapper
However, I have a case where A and B contain macros that depend on bar and baz. Since (I think?) I cannot add methods to a macro from outside a module, they have to be declared inside. But then I cannot circumvent the cyclic imports anymore -- the following fails because WARNING: could not import Wrapper.B into A, leaving B undefined in A:
module Wrapper
module A
import ..Wrapper.B
const x = 1
macro foo(expr)
B.baz(expr)
end
function bar end
end # module A
module B
import ..Wrapper.A
const x = 2
macro foo(expr)
A.bar(expr)
end
function baz end
end # module B
import .A: bar
import .B: baz
bar(expr) = quote
println("bar", $(B.x))
$expr
end
baz(expr) = quote
println("baz", $(A.x))
$expr
end
end # module Wrapper
Is there any possibility how this pattern can be implemented? (Just renaming the foos and moving them into Wrapper is not really an option, since I want the names to be the same...).

Answer 1

I could solve the problem by declaring bar and baz outside of A and B, using and redefining them in the submodules, and finally implementing their methods afterwards:
module Wrapper
function bar end
function baz end
module A
import ..Wrapper
const x = 1
macro foo(expr)
Wrapper.baz(expr)
end
const bar = Wrapper.bar
end # module A
module B
import ..Wrapper
const x = 2
macro foo(expr)
Wrapper.bar(expr)
end
const baz = Wrapper.baz
end # module B
import .A
import .B
bar(expr) = quote
println("bar", $(B.x))
$expr
end
baz(expr) = quote
println("baz", $(A.x))
$expr
end
end # module Wrapper
Result:
julia> Wrapper.A.bar(1)
quote
#= /tmp/test.jl:119 =#
println("bar", 2)
#= /tmp/test.jl:120 =#
1
end
julia> Wrapper.B.baz(1)
quote
#= /tmp/test.jl:124 =#
println("baz", 1)
#= /tmp/test.jl:125 =#
1
end
julia> Wrapper.B.#foo 1
bar2
1
julia> Wrapper.A.#foo 1
baz1
1