Yes, because now it sounds like XY problem.
hauleth
bartblast
Creator of Hologram
@hauleth
I’m writing Elixir to JavaScript transpiler as part of a project I’m working on. When I transpile a specific Elixir module I need to expand all the macros and use directives before transforming the AST to IR. If such macro expansion can’t be done with Elixir standard lib, I’m still able to get the macros AST, resolve the bindings and inject the generated AST into the calling module, but this would be more time-consuming with my custom approach, so I hoped I could do this differently, just with the standard lib somehow.
0
ityonemo
If you are doing an elixir to js transpiler, I recommend using the BEAM bytecode. You can obtain bytecode by doing :beam_disasm on the module binary.
6
stevensonmt
what’s wrong with using binding() |> IO.inspect? That’s what I was just doing trying to learn what ASTs looked like in the Elixir macro world.
0
bartblast
Creator of Hologram
@stevensonmt
Can you explain what do you mean? binding/1 returns the variable name-value bindings for the current context.
0
stevensonmt
bartblast
Creator of Hologram
@stevensonmt
Could you give some simple example using the module which I described in my first post?
0
ityonemo
the problem is that macros are HIGHLY contextual and the “middle” of the macro code (everything between the defmacro and the resulting quoted retval), may not be able to evaluated without having access to a bunch of internal information, if for example, functions like Module.get_attribute (see note “This function can only be used on modules that have not yet been compiled”) and then if you have a macro inside of a macro, you will need to track the rolling environment, and then there’s the magic __CONTEXT__ special form, which quite frankly I’m not entirely sure how it works under the hood. I guess that’s why you’re trying to obtain the AST information at the point of egress, but note that even the AST emitted by module ITSELF might have macros inside of it, so even if you obtain the AST in a late-interception fashion, you still need something that can “execute” macros.
I think this complexity might have been what killed ElixirScript – elixir_script v0.32.1, which I have a ton of respect for. If you decide to go with reading bytecode, which honestly is IMO way simpler than elixir AST, let me know, I am very much intereseted in resurrecting these elixir on the FE type projects. I am thinking about tinkering with a WASM-based bytecode interpreter, (not to be confused with lumen, which is a beam-to-wasm compiler).
2
stevensonmt
I think I misunderstood your original question. I do not know how to get what you want with binding/1 but I think I stumbled on a way to get the AST you were after. It requires some reconfiguring of the macro call itself, however. Sorry if this isn’t helpful.
defmodule TestModule do
defmacro test_macro(ast) do
binding() |> IO.inspect
help(ast)
|> Macro.escape
|> IO.inspect
end
defp help([do: {:__block__, [], [a, b, c]}]) when is_integer(a) and is_integer(b) do
binding() |> IO.inspect
quote do
a + b + unquote(c)
end
end
end
defmodule Testing do
require TestModule
TestModule.test_macro do
1
2
3
end
end
returns:
[ast: [do: {:__block__, [], [1, 2, 3]}]] # first binding
[a: 1, b: 2, c: 3] # second binding
# output of Macro.escape()
{:{}, [],
[:+, [context: TestModule, import: Kernel],
[{:{}, [],
[:+, [context: TestModule, import: Kernel],
[{:{}, [], [:a, [], TestModule]}, {:{}, [], [:b, [], TestModule]}]]}, 3]]}
1