Improve aliases hygiene by using metadata

Author: José Valim

lib/elixir/src/elixir_aliases.erl

@@ -4,30 +4,38 @@
 -include("elixir.hrl").
 -compile({parse_transform, elixir_transform}).
 
-%% Expand an alias. It returns an atom (mearning that there
+%% Expand an alias. It returns an atom (meaning that there
 %% was an expansion) or a list of atoms.
 
-expand({ '__aliases__', _Meta, [H] }, Aliases) when H /= 'Elixir' ->
-  case expand_one(H, Aliases) of
+expand({ '__aliases__', Meta, _ } = Alias, Aliases) ->
+  case lists:keyfind(alias, 1, Meta) of
+    { alias, Atom } when is_atom(Atom) ->
+      Atom;
+    false ->
+      do_expand(Alias, Aliases)
+  end.
+
+do_expand({ '__aliases__', _Meta, [H] }, Aliases) when H /= 'Elixir' ->
+  case do_expand_one(H, Aliases) of
     false -> [H];
     Atom  -> Atom
   end;
 
-expand({ '__aliases__', _Meta, [H|T] }, Aliases) when is_atom(H) ->
+do_expand({ '__aliases__', _Meta, [H|T] }, Aliases) when is_atom(H) ->
   case H of
     'Elixir' ->
       concat(T);
     _ ->
-      case expand_one(H, Aliases) of
+      case do_expand_one(H, Aliases) of
         false -> [H|T];
         Atom  -> concat([Atom|T])
       end
   end;
 
-expand({ '__aliases__', _Meta, List }, _Aliases) ->
+do_expand({ '__aliases__', _Meta, List }, _Aliases) ->
   List.
 
-expand_one(H, Aliases) ->
+do_expand_one(H, Aliases) ->
   Lookup = list_to_atom("Elixir-" ++ atom_to_list(H)),
   case lookup(Lookup, Aliases) of
     Lookup -> false;
@@ -69,7 +77,7 @@ last([], Acc) -> Acc.
 %% Examples:
 %%
 %%     nesting_alias('Elixir.Foo.Bar', 'Elixir.Foo.Bar.Baz.Bat')
-%%     { '__aliases__', [], ['Elixir', 'Foo', 'Bar', 'Baz'] }
+%%     { 'Elixir.Baz', 'Elixir.Foo.Bar.Baz' }
 %%
 %% When passed to alias, the example above will generate an
 %% alias like:
@@ -86,7 +94,7 @@ nesting_alias(Prefix, Full) ->
 do_nesting([X|PreTail], [X|Tail], Acc) ->
   do_nesting(PreTail, Tail, [X|Acc]);
 do_nesting([], [H|_], Acc) ->
-  { '__aliases__', [], ['Elixir'|[list_to_atom(X) || X <- lists:reverse([H|Acc])]] };
+  { list_to_atom("Elixir-" ++ H), concat(lists:reverse([H|Acc])) };
 do_nesting(_, _, _Acc) ->
   false.
 

lib/elixir/src/elixir_macros.erl

@@ -196,11 +196,13 @@ translate({defmodule, Meta, [Ref, KV]}, S) ->
 
   { FRef, FS } = case TRef of
     { atom, _, Module } ->
-      FullModule = module_ref(Ref, Module, S),
+      FullModule = expand_module(Ref, Module, S),
 
       RS = case elixir_aliases:nesting_alias(S#elixir_scope.module, FullModule) of
-        false   -> S;
-        Nesting -> element(2, translate_each({ alias, Meta, [Nesting] }, S))
+        { New, Old } ->
+          S#elixir_scope{aliases=orddict:store(New, Old, S#elixir_scope.aliases)};
+        false ->
+          S
       end,
 
       {
@@ -327,18 +329,18 @@ rewrite_case_clauses([{do,[{in,_,[{'_',_,_},[false,nil]]}],False},{do,[{'_',_,_}
 rewrite_case_clauses(Clauses) ->
   Clauses.
 
-module_ref(Raw, Module, #elixir_scope{module=Nesting}) when is_atom(Raw); Nesting == nil ->
+expand_module(Raw, Module, #elixir_scope{module=Nesting}) when is_atom(Raw); Nesting == nil ->
   Module;
 
-module_ref({ '__aliases__', _, _ } = Alias, Module, S) ->
+expand_module({ '__aliases__', _, _ } = Alias, Module, S) ->
   case elixir_aliases:expand(Alias, S#elixir_scope.aliases) of
     Atom when is_atom(Atom) ->
       Module;
     Aliases when is_list(Aliases) ->
       elixir_aliases:concat([S#elixir_scope.module, Module])
   end;
 
-module_ref(_Raw, Module, S) ->
+expand_module(_Raw, Module, S) ->
   elixir_aliases:concat([S#elixir_scope.module, Module]).
 
 is_reserved_data(moduledoc) -> true;

lib/elixir/src/elixir_quote.erl

@@ -54,15 +54,20 @@ do_quote({ unquote, _Meta, [Expr] }, #elixir_quote{unquote=true}, S) ->
 do_quote({ 'alias!', _Meta, [Expr] }, Q, S) ->
   do_quote(Expr, Q#elixir_quote{aliases_hygiene=false}, S);
 
-% do_quote({ '__aliases__', Meta, [H|_] = Aliases }, #elixir_quote{aliases_hygiene=true} = Q, S) when is_atom(H) and H /= 'Elixir' ->
-%   Line = ?line(Meta),
-%   { TAliases, SA } = do_quote(['Elixir'|Aliases], Q, S),
-% 
-%   { { tuple, Line, [
-%     { atom, Line, '__aliases__' },
-%     meta(Meta, Q),
-%     TAliases
-%   ] }, SA };
+do_quote({ '__aliases__', RawMeta, [H|T] } = Alias, #elixir_quote{aliases_hygiene=true} = Q, S) when is_atom(H) and (H /= 'Elixir') ->
+  Meta = case elixir_aliases:expand(Alias, S#elixir_scope.aliases) of
+    Atom when is_atom(Atom) -> [{alias,Atom}|RawMeta];
+    Aliases when is_list(Aliases) -> RawMeta
+  end,
+
+  Line = ?line(Meta),
+  { TAliases, SA } = do_quote([H|T], Q, S),
+
+  { { tuple, Line, [
+    { atom, Line, '__aliases__' },
+    meta(Meta, Q),
+    TAliases
+  ] }, SA };
 
 do_quote({ { { '.', Meta, [Left, unquote] }, _, [Expr] }, _, Args }, #elixir_quote{unquote=true} = Q, S) ->
   All  = [Left, { unquote, Meta, [Expr] }, Args, S#elixir_scope.file],

lib/elixir/test/elixir/kernel/quote_test.exs

@@ -157,10 +157,16 @@ end
 defmodule Kernel.QuoteTest.AliasHygieneTest do
   use ExUnit.Case, async: true
 
+  alias Dict, as: SuperDict
+
   test :expand_aliases do
-    assert Code.eval_quoted(quote do: Foo.Bar)  == { Elixir.Foo.Bar, [] }
-    assert Code.eval_quoted(quote do: alias!(Foo.Bar))  == { Foo.Bar, [] }
-    assert Code.eval_quoted(quote expand_aliases: false, do: Foo.Bar)  == { Foo.Bar, [] }
+    assert quote(do: Foo.Bar) == { :__aliases__, [], [:Foo, :Bar] }
+    assert quote(do: Dict.Bar) == { :__aliases__, [], [:Dict, :Bar] }
+    assert quote(do: SuperDict.Bar) == { :__aliases__, [alias: Dict.Bar], [:SuperDict, :Bar] }
+    assert quote(do: alias!(SuperDict.Bar)) == { :__aliases__, [], [:SuperDict, :Bar] }
+
+    assert Code.eval_quoted(quote do: SuperDict.Bar) == { Elixir.Dict.Bar, [] }
+    assert Code.eval_quoted(quote do: alias!(SuperDict.Bar)) == { Elixir.SuperDict.Bar, [] }
   end
 end