anchor.diff:      false -> length(ArgsOrAtom)
     end,
   
  -  case (keyfind(import, Meta) == false) andalso
  +  NewMeta = case (keyfind(import, Meta) == false) andalso
         elixir_dispatch:find_import(Meta, Name, Arity, S) of
       false ->
  -      AmbMeta =
  -        case (Arity == 1) andalso keyfind(ambiguous_op, Meta) of
  -          { ambiguous_op, nil } -> keystore(ambiguous_op, Meta, Q#elixir_quote.context);
  -          _ -> Meta
  -        end,
  -      do_quote_tuple({ Name, AmbMeta, ArgsOrAtom }, Q, S);
  +      case (Arity == 1) andalso keyfind(ambiguous_op, Meta) of
  +        { ambiguous_op, nil } -> keystore(ambiguous_op, Meta, Q#elixir_quote.context);
  +        _ -> Meta
  +      end;
       Receiver ->
  -      ImportMeta = keystore(import,
  -        keystore(context, Meta, Q#elixir_quote.context),
  -        Receiver),
  -      do_quote_tuple({ Name, ImportMeta, ArgsOrAtom }, Q, S)
  -  end;
  +      keystore(import, keystore(context, Meta, Q#elixir_quote.context), Receiver)
  +  end,
  +
  +  Annotated = annotate({ Name, NewMeta, ArgsOrAtom }, Q#elixir_quote.context),
  +  do_quote_tuple(Annotated, Q, S);
   
   do_quote({ _, _, _ } = Tuple, #elixir_quote{escape=false} = Q, S) ->
  -  do_quote_tuple(Tuple, Q, S);
  +  do_quote_tuple(annotate(Tuple, Q#elixir_quote.context), Q, S);
   
   %% Literals
   
  
positive.code:       { { '.', Meta, [Left, Right] }, Meta, [] }
    end;
  
  unquote(Meta, Left, { Right, _, Context }, nil) when is_atom(Right), is_atom(Context) ->
    { { '.', Meta, [Left, Right] }, Meta, [] };
  
  unquote(Meta, Left, { Right, _, Args }, nil) when is_atom(Right) ->
    { { '.', Meta, [Left, Right] }, Meta, Args };
  
  unquote(_Meta, _Left, Right, nil) ->
    argument_error(<<"expected unquote after dot to return an atom, an alias or a quoted call, got: ",
                     ('Elixir.Macro':to_string(Right))/binary>>);
  
  unquote(Meta, Left, Right, Args) when is_atom(Right) ->
    { { '.', Meta, [Left, Right] }, Meta, Args };
  
  unquote(Meta, Left, { Right, _, Context }, Args) when is_atom(Right), is_atom(Context) ->
    { { '.', Meta, [Left, Right] }, Meta, Args };
  
  unquote(_Meta, _Left, Right, _Args) ->
    argument_error(<<"expected unquote after dot with args to return an atom or a quoted call, got: ",
                     ('Elixir.Macro':to_string(Right))/binary>>).
  
  join(Left, Right) when is_list(Right) ->
    validate_join(Left),
    Left ++ Right.
  
  tail_join(Left, Right, Tail) when is_list(Right), is_list(Tail) ->
    validate_join(Left),
    Tail ++ Left ++ Right;
  
  tail_join(Left, Right, Tail) when is_list(Left) ->
    validate_join(Left),
    [H|T] = lists:reverse(Tail ++ Left),
    lists:reverse([{ '|', [], [H, Right] }|T]).
  
  validate_join(List) when is_list(List) ->
    ok;
  validate_join(List) when not is_list(List) ->
    argument_error(<<"expected a list with quoted expressions in unquote_splicing/1, got: ",
                     ('Elixir.Kernel':inspect(List))/binary>>).
  
  argument_error(Message) ->
    error('Elixir.ArgumentError':exception([{message,Message}])).
  
  %% Escapes the given expression. It is similar to quote, but
  %% lines are kept and hygiene mechanisms are disabled.
  
negative.code:   %% 1, 2 and 3, which could even be unquotes.
    { TT, QT } = do_splice(T, Q, S, [], []),
    { TR, QR } = do_quote(Right, QT, S),
    { do_runtime_list(Meta, tail_list, [Left, TR, TT]), QR#elixir_quote{unquoted=true} };
  
  do_splice(List, Q, S) ->
    do_splice(List, Q, S, [], []).
  
  do_splice([{ unquote_splicing, Meta, [Expr] }|T], #elixir_quote{unquote=true} = Q, S, Buffer, Acc) ->
    do_splice(T, Q#elixir_quote{unquoted=true}, S, [], do_runtime_list(Meta, list, [Expr, do_join(Buffer, Acc)]));
  
  do_splice([H|T], Q, S, Buffer, Acc) ->
    { TH, TQ } = do_quote(H, Q, S),
  