anchor.diff:  
   translate_each(Bitstring, S) when is_bitstring(Bitstring) ->
     { elixir_tree_helpers:abstract_syntax(Bitstring), S }.
  +
  +%%%% Local macros
  +
  +%% Operators
  +
  +translate_macro({ '+', _Line, [Expr] }, S) when is_number(Expr) ->
  +  record('+', S),
  +  translate_each(Expr, S);
  +
  +translate_macro({ '-', _Line, [Expr] }, S) when is_number(Expr) ->
  +  record('-', S),
  +  translate_each(-1 * Expr, S);
  +
  +translate_macro({ Op, Line, Exprs }, S) when is_list(Exprs),
  +  Op == '+'; Op == '-'; Op == '*'; Op == '/'; Op == '<-';
  +  Op == '++'; Op == '--'; Op == 'andalso'; Op == 'orelse';
  +  Op == 'not'; Op == 'and'; Op == 'or'; Op == 'xor';
  +  Op == '<'; Op == '>'; Op == '<='; Op == '>=';
  +  Op == '=='; Op == '!='; Op == '==='; Op == '!==' ->
  +  record(Op, S),
  +  translate_macro({ erlang_op, Line, [Op|Exprs] }, S);
  +
  +%% Erlang Operators
  +
  +translate_macro({ erlang_op, Line, [Op, Expr] }, S) when is_atom(Op) ->
  +  record(erlang_op, S),
  +  { TExpr, NS } = translate_each(Expr, S),
  +  { { op, Line, convert_op(Op), TExpr }, NS };
  +
  +translate_macro({ erlang_op, Line, [Op|Args] }, S) when is_atom(Op) ->
  +  record(erlang_op, S),
  +  { [TLeft, TRight], NS }  = translate_args(Args, S),
  +  { { op, Line, convert_op(Op), TLeft, TRight }, NS };
  +
  +%% Case
  +
  +translate_macro({'case', Line, [Expr, RawClauses]}, S) ->
  +  record('case', S),
  +  Clauses = orddict:erase(do, RawClauses),
  +  { TExpr, NS } = translate_each(Expr, S),
  +  { TClauses, TS } = elixir_clauses:match(Line, Clauses, NS),
  +  { { 'case', Line, TExpr, TClauses }, TS };
  +
  +%% Blocks
  +
  +translate_macro({ block, Line, [] }, S) ->
  +  { { atom, Line, nil }, S };
  +
  +translate_macro({ block, _Line, [Arg] }, S) ->
  +  translate_each(Arg, S);
  +
  +translate_macro({ block, Line, Args }, S) when is_list(Args) ->
  +  { TArgs, NS } = translate(Args, S),
  +  { { block, Line, TArgs }, NS };
  +
  +translate_macro({ kv_block, _, [{[Expr],nil}] }, S) ->
  +  translate_each(Expr, S);
  +
  +translate_macro({ kv_block, Line, Args }, S) when is_list(Args) ->
  +  case S#elixir_scope.macro of
  +    { Receiver, Name, Arity } ->
  +      Desc = io_lib:format("~s.~s/~B", [Receiver, Name, Arity]),
  +      elixir_errors:syntax_error(Line, S#elixir_scope.filename, "key value blocks not supported by: ", Desc);
  +    _ ->
  +      elixir_errors:syntax_error(Line, S#elixir_scope.filename, "unhandled key value blocks", "")
  +  end;
  +
  +%% ::
  +
  +translate_macro({'::', Line, [Left]}, S) ->
  +  translate_macro({'::', Line, [nil,Left]}, S);
  +
  +translate_macro({'::', Line, [Left|Right]}, S) ->
  +  { TLeft, LS } = translate_each(Left, S),
  +  { TRight, RS } = translate_args(Right, (umergec(S, LS))#elixir_scope{noref=true}),
  +  TArgs = [TLeft|TRight],
  +  Atoms = [Atom || { atom, _, Atom } <- TArgs],
  +  Final = case length(Atoms) == length(TArgs) of
  +    true  -> { atom, Line, elixir_ref:concat(Atoms) };
  +    false ->
  +      FArgs = [elixir_tree_helpers:build_simple_list(Line, TArgs)],
  +      ?ELIXIR_WRAP_CALL(Line, elixir_ref, concat, FArgs)
  +  end,
  +  { Final, (umergev(LS, RS))#elixir_scope{noref=S#elixir_scope.noref} };
  +
  +%% Definitions
  +
  +translate_macro({defmodule, Line, [Ref, [{do,Block}]]}, S) ->
  +  record(defmodule, S),
  +  { TRef, _ } = translate_each(Ref, S#elixir_scope{noref=true}),
  +
  +  NS = case TRef of
  +    { atom, _, Module } ->
  +      S#elixir_scope{scheduled=[Module|S#elixir_scope.scheduled]};
  +    _ -> S
  +  end,
  +
  +  { elixir_module:transform(Line, S#elixir_scope.filename, TRef, Block), NS };
  +
  +translate_macro({Kind, Line, [Call,[{do, Expr}]]}, S) when Kind == def; Kind == defp; Kind == defmacro ->
  +  record(Kind, S),
  +  case S#elixir_scope.function /= [] of
  +    true ->
  +      elixir_errors:syntax_error(Line, S#elixir_scope.filename, "invalid function scope for: ", atom_to_list(Kind));
  +    _ ->
  +      { elixir_def:wrap_definition(Kind, Line, Call, Expr, S), S }
  +  end;
  +
  +translate_macro({Kind, Line, [Call]}, S) when Kind == def; Kind == defmacro; Kind == defp ->
  +  record(Kind, S),
  +  { Name, Args } = elixir_clauses:extract_args(Call),
  +  { { tuple, Line, [{ atom, Line, Name }, { integer, Line, length(Args) }] }, S };
  +
  +translate_macro({Kind, Line, Args}, S) when is_list(Args), Kind == def; Kind == defmacro; Kind == defp ->
  +  elixir_errors:syntax_error(Line, S#elixir_scope.filename, "invalid args for: ", atom_to_list(Kind));
  +
  +%% Functions
  +
  +translate_macro({fn, Line, RawArgs}, S) when is_list(RawArgs) ->
  +  record(fn, S),
  +  Clauses = case lists:split(length(RawArgs) - 1, RawArgs) of
  +    { Args, [[{do,Expr}]] } ->
  +      [{match,Args,Expr}];
  +    { [], [KV] } when is_list(KV) ->
  +      elixir_kv_block:decouple(orddict:erase(do, KV));
  +    _ ->
  +      elixir_errors:syntax_error(Line, S#elixir_scope.filename, "no block given for: ", "fn")
  +  end,
  +
  +  Transformer = fun({ match, ArgsWithGuards, Expr }, Acc) ->
  +    { FinalArgs, Guards } = elixir_clauses:extract_last_guards(ArgsWithGuards),
  +    elixir_clauses:assigns_block(Line, fun translate/2, FinalArgs, [Expr], Guards, umergec(S, Acc))
  +  end,
  +
  +  { TClauses, NS } = lists:mapfoldl(Transformer, S, Clauses),
  +  { { 'fun', Line, {clauses, TClauses} }, umergec(S, NS) };
  +
  +%% Loop and recur
  +
  +translate_macro({loop, Line, RawArgs}, S) when is_list(RawArgs) ->
  +  record(loop, S),
  +  case lists:split(length(RawArgs) - 1, RawArgs) of
  +    { Args, [KV] } when is_list(KV) ->
  +      %% Generate a variable that will store the function
  +      { FunVar, VS }  = elixir_tree_helpers:build_ex_var(Line, S),
  +
  +      %% Add this new variable to all match clauses
  +      [{match, KVBlock}] = elixir_kv_block:normalize(orddict:erase(do, KV)),
  +      Values = [{ [FunVar|Conds], Expr } || { Conds, Expr } <- element(3, KVBlock)],
  +      NewKVBlock = setelement(3, KVBlock, Values),
  +
  +      %% Generate a function with the match blocks
  +      Function = { fn, Line, [[{match,NewKVBlock}]] },
  +
  +      %% Finally, assign the function to a variable and
  +      %% invoke it passing the function itself as first arg
  +      Block = { block, Line, [
  +        { '=', Line, [FunVar, Function] },
  +        { { '.', Line, [FunVar] }, Line, [FunVar|Args] }
  +      ] },
  +
  +      { TBlock, TS } = translate_each(Block, VS#elixir_scope{recur=element(1,FunVar)}),
  +      { TBlock, TS#elixir_scope{recur=[]} };
  +    _ ->
  +      elixir_errors:syntax_error(Line, S#elixir_scope.filename, "invalid args for: ", "loop")
  +  end;
  +
  +translate_macro({recur, Line, Args}, S) when is_list(Args) ->
  +  record(recur, S),
  +  case S#elixir_scope.recur of
  +    [] ->
  +      elixir_errors:syntax_error(Line, S#elixir_scope.filename, "cannot invoke recur outside of a loop. invalid scope for: ", "recur");
  +    Recur ->
  +      ExVar = { Recur, Line, false },
  +      Call = { { '.', Line, [ExVar] }, Line, [ExVar|Args] },
  +      translate_each(Call, S)
  +  end;
  +
  +%% Apply - Optimize apply by checking what doesn't need to be dispatched dynamically
  +
  +translate_macro({apply, Line, [Left, Right, Args]}, S) when is_list(Args) ->
  +  record(apply, S),
  +  { TLeft,  SL } = translate_each(Left, S),
  +  { TRight, SR } = translate_each(Right, umergec(S, SL)),
  +  translate_apply(Line, TLeft, TRight, Args, S, SL, SR);
  +
  +%% Else
  +
  +translate_macro({ Atom, Line, Args }, S) ->
  +  Callback = fun() ->
  +    { TArgs, NS } = translate_args(Args, S),
  +    { { call, Line, { atom, Line, Atom }, TArgs }, NS }
  +  end,
  +  elixir_macro:dispatch_imports(Line, Atom, Args, S, Callback).
   
   %% Helpers
   
  
positive.code:       { TClauses, SC } = elixir_clauses:match(Line, Clauses, S),
        { { 'receive', Line, TClauses }, SC }
    end;
  
  %% Apply - Optimize apply by checking what doesn't need to be dispatched dynamically
  
  translate_each({apply, Line, [Left, Right, Args]}, S) when is_list(Args) ->
    record(apply, S),
    { TLeft,  SL } = translate_each(Left, S),
    { TRight, SR } = translate_each(Right, umergec(S, SL)),
    translate_apply(Line, TLeft, TRight, Args, S, SL, SR);
  
  %% Variables & Function calls
  
  
negative.code: 
    { {atom, Line, Final }, S };
  
  %% Quoting
  
  translate_each({quote, _Line, [[{do,Exprs}]]}, S) ->
  