Regarding evaluation of arguments to ExUnit.Assertions.assert/2

Code like:

assert 3 * 14 == 6 * 7

will expand to:

      left = 3 * 14
      right = 6 * 7

      ExUnit.Assertions.assert(left == right,
        left: left,
        right: right,
        expr: #<ast omitted>,
        message: "Assertion with operator == failed",
        context: #<__CALLER__ omitted>
      )

Thanks for taking a look.

When* I try expanding something like this …

{operator, meta, [left, right]}

…using my own..

h = {:!=, [], [5, 5]}

…then passing to a function…

defmodule Tst do
 def unq(p) do
	quote do: unq2 unquote p
 end
 def unq2(g), do: IO.puts g
end

…I get an AST chunk back.

If I do the unquote outside of the quote do: I get a no variable error.

error: undefined variable "p"
└─ iex:200: Tst (module)

** (CompileError) iex: cannot compile module Tst (errors have been logged)
    (elixir 1.16.0) src/elixir_expand.erl:389: :elixir_expand.expand/3
    (elixir 1.16.0) src/elixir_expand.erl:599: :elixir_expand.expand_arg/3
    (elixir 1.16.0) src/elixir_expand.erl:531: :elixir_expand.expand_list/5
    (elixir 1.16.0) src/elixir_expand.erl:437: :elixir_expand.expand/3
    (elixir 1.16.0) src/elixir_expand.erl:599: :elixir_expand.expand_arg/3
    (elixir 1.16.0) src/elixir_expand.erl:615: :elixir_expand.mapfold/5
    (elixir 1.16.0) src/elixir_expand.erl:608: :elixir_expand.expand_args/3
    iex:194: (file)

Functions like unq would need to be called from inside a defmacro to get the AST they generate turned into executable code.

Also noticed there was a type in there specifically,

def unq2(g), do: IO.puts p

Just going to update this in the 2nd P as this was not an area of concern, nor a source of error.

Fantastic, you’ve been solving so many of my question lol!

Just a crucial sidebar, when I do…

defmodule Tst do
 defmacro unqm do
	unq({:==, [], [5, 5]})
 end
 def unq(p) do
	quote do: Tst.unq2 (unquote p)
 end
 def unq2(g), do: IO.inspect g
end
require Tst
Tst.unqm

It outputs true however,

when I use

defmodule Tst do
 defmacro unqm(k) do
	unq(k)
 end
 def unq(p) do
	quote do: Tst.unq2 (unquote p)
 end
 def unq2(g), do: IO.inspect g
end
require Tst
Tst.unqm {:!=, [], [5, 5]}

I get AST segments again.

I think I understand why, but I don’t want to assume.

Are the function calls getting processed, or are they all getting crammed into the macro as ASTs and then getting executed in there?

Edit: I forgot that the 3 elem tuple is going to get quoted when it’s passed as an arg to the macro, which addresses the above.

The quote do…unquote is located in a def do: block which is quoted, so the unquote is in a nested quote which means that is quoted rather than executed.

  defp translate_operator(kind, {op, meta, [left, right]} = expr, call, message, false, _caller) do
    expr = escape_quoted(kind, meta, expr)
    context = if op in [:===, :!==], do: :===, else: :==

    quote do
      left = unquote(left)
      right = unquote(right)

      ExUnit.Assertions.assert(unquote(call),
        left: left,
        right: right,
        expr: unquote(expr),
        message: unquote(message),
        context: unquote(context)
      )
    end
  end

Results in…

    quote do
      left = unquote(left)
      right = unquote(right)

      ExUnit.Assertions.assert(unquote(call),
        left: left,
        right: right,
        expr: unquote(expr),
        message: unquote(message),
        context: unquote(context)
      )
    end

…getting sent back to the macro that started the chain of function calls.

The macro will then subject the AST to a macro.escape-like processing that identifies :unquote operators in the AST and does not escape the args (children), leaving them in their current form with :unquote stripped or generating a valid AST to describe them. This occurs because the returned AST from translate_operator is the last reachable expression in the macro, and so it must be validated as a formal AST.

The macro will then insert this valid AST fragment into the over all AST at the location were it (the macro, defmacro assert(assertion)) was called.

I initial thought that evaluation was taking place at unquote and at escape, however this was corrected:

If anyone has an question about this I’d be happy to go into further detail.

If I got anything wrong please let me know.