Why is right variable in assert/1 function not unquoted?

This clause of assert handles the pattern matching case like

assert foo = bar

where foo is a pattern and bar can be anything.

Remember that atoms keep as is in the code and in the AST, and false and nil are atoms. So, if right is literally nil or false in the code, it is nil or false in the AST, too. And if right is nil or false, the assertion will definitely fail because pattern matching using = always returns the right hand side if it matches the left hand side, or raises an error if it does not match. So, in this specific case, unquote(right) should not be used.

The other cases of pattern matching when right is not literally false or nil is handled by the line

__match__(left, right, code, check, __CALLER__)

Thank you for your answer!

Sorry, I’m not sure why it should not be unquoted…
I think variables in quote should occurs an error without being unquoted.

But right in above code is not unquoted. Why it does not occur any errors?

Sorry, It was my misunderstanding of the code in ExUnit.

I stared at the code closely, and saw this:

def __match__(left, right, code, check, caller) do
  ...
  match_expr = ... # It's an AST!!
  
  quote do
    right = unquote(right)  #<---- This line does the trick!
    expr = unquote(code)
    unquote(vars) = unquote(match_expr)
    right
  end
end

By the way, it’s totally OK to access an undeclared variable inside quote, for example, in a brand new IEx session,

iex> quote do: foo
{:foo, [], Elixir}

It does not raise error.

Wow that’s true!

I don’t understand why assert function works with the __match__ function… Would you explain why?

When you try to perform a match that fails using = then a MatchError exception will be raised. For example if you try {x} = 1 in iex you’ll get a match exception. That’s the normal expected behaviour.

But …

In a test where we want to assert that a match occured and it doesn’t then we don’t want the match exception, we want a better error message. So what I think the code is doing is rewriting the match-and-bind expression into a match?/2 call.

That is, its re-writing {x} = 1 into something like match?({x}, 1). That way the assertion will get a Boolean result and it can then accept or refute the assertion and return a better error message.

Thank you for explaining that!