Module aliasing in macros

nmichel

There is something I don’t get about macros, modules and aliasing.
Consider the following code snippets.

Module Foo exports macro show/1 that just log the received AST fragment on standard output.

defmodule Foo do
    defmacro show(frag) do
        IO.puts "#{inspect frag}"
        frag
    end
end

Then consider the following two useless modules Outer and Outer.Inner.

defmodule Outer do
    defmodule Inner do
        def foo do
            :foo
        end
    end
end

Now lets play with aliasing.

defmodule Test do
    import Foo

    alias Outer, as: A
    alias Outer.Inner, as: B
    alias A.Inner, as: C
    
    show A
    show B
    show C
    show C.foo()
    
    ast = quote do: A
    IO.puts "ast #{inspect ast}"
end

Here is the console log when I compile the code.

iex(1)> c("./test/demo.ex")
{:__aliases__, [counter: 0, line: 23], [:A]} # No aliasing info
{:__aliases__, [counter: 0, line: 24], [:B]}
{:__aliases__, [counter: 0, line: 25], [:C]}
{{:., [line: 26], [{:__aliases__, [counter: 0, line: 26], [:C]}, :foo]}, [line: 26], []}
ast {:__aliases__, [alias: Outer], [:A]} # quote => Aliasing info !
[Test, Outer, Outer.Inner, Foo]
iex(2)>

What puzzles me, is that in show/1 macro calls, module fragments do not hold any aliasing information, while when quoted, it does.

Why don’t I have aliasing information during macro expansion ?

Many thanks !

Nicolas -

1 comment

#alias #macros

2 3038 1

2018-01-03 10:53:14 UTC

Showing Posts 1 to 1

Show Best Posts
Show All (oldest first)
Show All (newest first)

nmichel

Hi,

I pursued my investigations further, and modified the Foo.show/1 function as follow.

defmodule Foo do
    defmacro show(frag = {:__aliases__, _, refs}) do
        resolved = Macro.expand(frag, __CALLER__)
        IO.puts """
        Alias
        frag \t #{inspect frag}
        resolved #{inspect resolved}
        """
        frag
    end

    defmacro show(frag = {{:., _, [path, target]}, _, _}) do
        resolved = Macro.expand(path, __CALLER__)
        IO.puts """
        Call
        path \t #{inspect path}
        resolved #{inspect resolved}#{inspect target}
        """
        frag
    end
end

Basically I catch fragments bearing aliasing information to make some experiments.

Here is the output

Alias
frag     {:__aliases__, [counter: 0, line: 38], [:A]}
resolved Outer

Alias
frag     {:__aliases__, [counter: 0, line: 39], [:B]}
resolved Outer.Inner

Alias
frag     {:__aliases__, [counter: 0, line: 40], [:C]}
resolved Outer.Inner

Call
path     {:__aliases__, [counter: 0, line: 41], [:C]}
resolved Outer.Inner:foo

ast {:__aliases__, [alias: Outer], [:A]}

We can see that, though fragments do not bear aliasing information, Macro.expand resolves aliases at compile time.

Cheers

Nicolas -

P.S. The question may rise of knowing WHY I needed to have those resolved symbols. Well, I wanted to be able to take some decisions based on the knowledge that a function is exported by a certain module … it proved to be a wrong way, but the underlying purely technical is still interesting