@macroexpand macro

[StefanKarpinski]

Writing macroexpand(:(@foo x y z)) is a bit of a mouthful, but the expression passed to the macroexpand function needs to be quoted, of course. With a @macroexpand macro, this could be less annoying: @macroexpand @foo x y z

[simonbyrne]

https://github.com/MikeInnes/MacroTools.jl/blob/a1410ee320223220ec96d250c18cb69feaf952c1/src/utils.jl#L92-L102

[simonbyrne]

I think the extra complications to the above are the handling of $ in expressions (e.g. @foo $x may not expand correctly using macroexpand(:(@foo $x))), and his funny gensym names.

[jw3126]

A naive implementation would be as follows:

macro macroexpand(code)
    Expr(:call, :macroexpand, Expr(:quote, code))
end

It would be good to have a concrete example that breaks this.

[simonbyrne]

macro foo(ex)
    isa(ex,Expr) && ex.head == :$ ? 7 : ex
end

gives

julia> @macroexpand @foo $bar
ERROR: UndefVarError: bar not defined

julia> @foo $bar
7

[vtjnash]

the macroexpand also shouldn't be inside the esc() and only happens to work since you haven't put this inside a module and tested from a different module (with a different idea of what macroexpand means)

[jw3126]

Okay, if I run the function version of simonbyrne's example I get the same error:

julia> macroexpand(:(@foo $bar))
ERROR: UndefVarError: bar not defined

The problem is julia trying to interpolate bar into the expression, before the function gets even called. So this means getting the correct expansion of simonbyrne's example using a function is impossible. Do I see this correctly?

[simonbyrne]

Well, it is possible, just a bit more complicated: see the MacroTools link above.

[jw3126]

I just meant it is impossible by using a function e.g. one has to write a macro which does not rely on a function, like the current macroexpand function.

[yuyichao]

The error has nothing to do with the function it's from the expression object. What you need is to properly convert the expression object before returning it from the macro.

[jw3126]

Thanks for the help and sorry for the confusion. It seems that MacroTools also has problems with the example:

julia> using MacroTools

julia> macro foo(ex)
          isa(ex,Expr) && ex.head == :$ ? 7 : ex
       end
@foo (macro with 1 method)

julia> @expand @foo $bar 
:bar

[jw3126]

macro macroexpand(code)
    Expr(:quote, ccall(:jl_macroexpand, Any, (Any,), code))
end

Passes the simonbyrne example. In this case the code gets passed directly to jl_macroexpand so there is no chance for $ interpolation to cause confusion. Any objections?

[yuyichao]

No need to use ccall the function call is NOT the problem.
It's a smart solution to do the expansion first. It changes the module the expansion takes place but that shouldn't be too bad for interactive use (and potentially better for that).

[jw3126]

Yes I know that the function call is not the problem, but $ interpolation that takes place before function is even called.
So you suggest, to use the macroexpand function instead of the ccall?
How to circumvent the $ interpolation then?
Do you need some recursive replacement thing like in MacroTools or is there an easy way?
And what is the problem with the ccall?

[yuyichao]

Yes I know that the function call is not the problem, but $ interpolation that takes place before function is even called.

Only after the macro returns

So you suggest, to use the macroexpand function instead of the ccall?

Yes

How to circumvent the $ interpolation then?

It won't happen.

Do you need some recursive replacement thing like in MacroTools or is there an easy way?

No

And what is the problem with the ccall?

There's a function for it already.

[jw3126]

Thanks, finally I can see clear. I will put together a PR using

macro macroexpand(code)
    code_expanded = macroexpand(code)
    Expr(:quote, code_expanded)
end