anchor.diff:        { { '.', Meta, [Left, Right] }, Meta, [] }
     end;
   
  -unquote(Meta, Left, { Right, _, Context }, nil) when is_atom(Right), is_atom(Context) ->
  +dot(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) ->
  +dot(Meta, Left, { Right, _, Args }, nil) when is_atom(Right) ->
     { { '.', Meta, [Left, Right] }, Meta, Args };
   
  -unquote(_Meta, _Left, Right, nil) ->
  +dot(_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) ->
  +dot(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) ->
  +dot(Meta, Left, { Right, _, Context }, Args) when is_atom(Right), is_atom(Context) ->
     { { '.', Meta, [Left, Right] }, Meta, Args };
   
  -unquote(_Meta, _Left, Right, _Args) ->
  +dot(_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),
  +list(Left, Right) when is_list(Right) ->
  +  validate_list(Left),
     Left ++ Right.
   
  -tail_join(Left, Right, Tail) when is_list(Right), is_list(Tail) ->
  -  validate_join(Left),
  +tail_list(Left, Right, Tail) when is_list(Right), is_list(Tail) ->
  +  validate_list(Left),
     Tail ++ Left ++ Right;
   
  -tail_join(Left, Right, Tail) when is_list(Left) ->
  -  validate_join(Left),
  +tail_list(Left, Right, Tail) when is_list(Left) ->
  +  validate_list(Left),
     [H|T] = lists:reverse(Tail ++ Left),
     lists:reverse([{ '|', [], [H, Right] }|T]).
   
  -validate_join(List) when is_list(List) ->
  +validate_list(List) when is_list(List) ->
     ok;
  -validate_join(List) when not is_list(List) ->
  +validate_list(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}])).
  +
  +%% Annotates the AST with context and other info
  +
  +annotate({ defmodule, Meta, [{ '__aliases__', AliasMeta, Atoms } = H|T] }, Context) ->
  +  %% Only store the context if we actually have a full alias as
  +  %% argument, otherwise the expression is being automatically
  +  %% generated and we don't want the alias to count.
  +  NewH =
  +    case lists:all(fun is_atom/1, Atoms) of
  +      true  ->
  +        { '__aliases__', keystore(context, AliasMeta, Context), Atoms };
  +      false ->
  +        H
  +    end,
  +  { defmodule, Meta, [NewH|T] };
  +
  +annotate({ Def, Meta, [{ H, M, A }|T] }, Context) when ?defs(Def) ->
  +  %% Store the context information in the first element of the
  +  %% definition tuple so we can access it later on.
  +  MM = keystore(context, M, Context),
  +  { Def, Meta, [{ H, MM, A }|T] };
  +annotate({ { '.', _, [_, Def] } = Target, Meta, [{ H, M, A }|T] }, Context) when ?defs(Def) ->
  +  MM = keystore(context, M, Context),
  +  { Target, Meta, [{ H, MM, A }|T] };
  +
  +annotate({ Def, Meta, [_|_] = Args }, Context) when Def == alias; Def == import ->
  +  NewMeta = keystore(context, Meta, Context),
  +  { Def, NewMeta, Args };
  +annotate({ { '.', _, [_, Def] } = Target, Meta, Args }, Context) when Def == alias; Def == import ->
  +  NewMeta = keystore(context, Meta, Context),
  +  { Target, NewMeta, Args };
  +
  +annotate(Tree, _Context) -> Tree.
   
   %% Escapes the given expression. It is similar to quote, but
   %% lines are kept and hygiene mechanisms are disabled.
  
positive.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_join(Meta, tail_join, [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_join(Meta, join, [Expr, do_join(Buffer, Acc)]));
  
  do_splice([H|T], Q, S, Buffer, Acc) ->
    { TH, TQ } = do_quote(H, Q, S),
  
negative.code: %% Quote helpers
  
  do_quote_call(Left, Meta, Expr, Args, Q, S) ->
    All  = [meta(Meta, Q), Left, { unquote, Meta, [Expr] }, Args, Q#elixir_quote.context],
    { TAll, TQ } = lists:mapfoldl(fun(X, Acc) -> do_quote(X, Acc, S) end, Q, All),
    { { { '.', Meta, [elixir_quote, dot] }, Meta, TAll }, TQ }.
  
  do_quote_fa(Target, Meta, Args, F, A, Q, S) ->
    NewMeta =
  