Improve how aliases for defmodule are generated

Author: José Valim

lib/elixir/src/elixir_aliases.erl

@@ -1,5 +1,5 @@
 -module(elixir_aliases).
--export([nesting/2, last/1, concat/1, safe_concat/1, lookup/2,
+-export([nesting_alias/2, last/1, concat/1, safe_concat/1, lookup/2,
   format_error/1, ensure_loaded/3, expand/2]).
 -include("elixir.hrl").
 -compile({parse_transform, elixir_transform}).
@@ -8,18 +8,18 @@
 %% Otherwise returns the list of aliases args.
 
 expand({ '__aliases__', _Line, [H] }, Aliases) when H /= 'Elixir' ->
-  expand_alias(H, Aliases);
+  expand_one(H, Aliases);
 
 expand({ '__aliases__', _Line, [H|T] }, Aliases) when is_atom(H) ->
   concat(case H of
     'Elixir' -> [H|T];
-    _        -> [expand_alias(H, Aliases)|T]
+    _        -> [expand_one(H, Aliases)|T]
   end);
 
 expand({ '__aliases__', _Line, List }, _Aliases) ->
   List.
 
-expand_alias(H, Aliases) ->
+expand_one(H, Aliases) ->
   lookup(list_to_atom("Elixir-" ++ atom_to_list(H)), Aliases).
 
 %% Ensure a module is loaded before its usage.
@@ -49,18 +49,29 @@ last([$-|_], Acc) -> Acc;
 last([H|T], Acc) -> last(T, [H|Acc]);
 last([], Acc) -> Acc.
 
-%% Returns the nesting between two aliases.
-
-nesting(nil, _Full) -> false;
-
-nesting(Prefix, Full) ->
+%% Gets two modules names and return an alias
+%% which can be passed down to the alias directive
+%% and it will create a proper shortcut representing
+%% the given nesting.
+%%
+%% Examples:
+%%
+%%   nesting_alias('Elixir.Foo.Bar', 'Elixir.Foo.Bar.Baz')
+%%   { '__aliases__', [], ['Elixir', 'Foo', 'Bar', 'Baz'] }
+%%
+nesting_alias(nil, _Full) -> false;
+
+nesting_alias(Prefix, Full) ->
   PrefixList = list_nesting(Prefix),
   FullList   = list_nesting(Full),
-
-  (PrefixList /= []) andalso
-    (PrefixList /= FullList) andalso
-    lists:prefix(PrefixList, FullList) andalso
-    binary_to_atom(<<"Elixir-", (hd(FullList -- PrefixList))/binary>>, utf8).
+  (PrefixList /= []) andalso do_nesting(PrefixList, FullList, []).
+
+do_nesting([X|PreTail], [X|Tail], Acc) ->
+  do_nesting(PreTail, Tail, [X|Acc]);
+do_nesting([], [H|_], Acc) ->
+  { '__aliases__', [], ['Elixir'|[binary_to_atom(X, utf8) || X <- lists:reverse([H|Acc])]] };
+do_nesting(_, _, _Acc) ->
+  false.
 
 list_nesting(Atom) ->
   case binary:split(atom_to_binary(Atom, utf8), <<$->>, [global]) of

lib/elixir/src/elixir_macros.erl

@@ -196,11 +196,11 @@ translate({defmodule, Meta, [Ref, KV]}, S) ->
 
   { FRef, FS } = case TRef of
     { atom, _, Module } ->
-      FullModule = module_ref(Ref, Module, S#elixir_scope.module),
+      FullModule = module_ref(Ref, Module, S),
 
-      RS = case elixir_aliases:nesting(S#elixir_scope.module, FullModule) of
-        false -> S;
-        Alias -> element(2, translate_each({ alias, Meta, [FullModule, [{ as, Alias }]] }, S))
+      RS = case elixir_aliases:nesting_alias(S#elixir_scope.module, FullModule) of
+        false   -> S;
+        Nesting -> element(2, translate_each({ alias, Meta, [Nesting] }, S))
       end,
 
       {
@@ -327,14 +327,23 @@ rewrite_case_clauses([{do,[{in,_,[{'_',_,_},[false,nil]]}],False},{do,[{'_',_,_}
 rewrite_case_clauses(Clauses) ->
   Clauses.
 
-module_ref(Raw, Module, Nesting) when is_atom(Raw); Nesting == nil ->
+module_ref(Raw, Module, #elixir_scope{module=Nesting}) when is_atom(Raw); Nesting == nil ->
   Module;
 
-module_ref({ '__aliases__', _, ['Elixir'|_] }, Module, _Nesting) ->
+module_ref({ '__aliases__', _, ['Elixir'|_] }, Module, _S) ->
   Module;
 
-module_ref(_Raw, Module, Nesting) ->
-  elixir_aliases:concat([Nesting, Module]).
+% In case the module is an alias and it was already
+% expanded we should not expand it twice
+module_ref({ '__aliases__', _, [H|_] }, Module, #elixir_scope{aliases=Aliases} = S) ->
+  Full = list_to_atom("Elixir-" ++ atom_to_list(H)),
+  case elixir_aliases:lookup(Full, Aliases) of
+    Full -> elixir_aliases:concat([S#elixir_scope.module, Module]);
+    _    -> Module
+  end;
+
+module_ref(_Raw, Module, S) ->
+  elixir_aliases:concat([S#elixir_scope.module, Module]).
 
 is_reserved_data(moduledoc) -> true;
 is_reserved_data(doc)       -> true;

lib/elixir/src/elixir_quote.erl

@@ -54,15 +54,15 @@ do_quote({ unquote, _Meta, [Expr] }, #elixir_quote{unquote=true}, S) ->
 do_quote({ 'alias!', _Meta, [Expr] }, Q, S) ->
   do_quote(Expr, Q#elixir_quote{expand_aliases=false}, S);
 
-do_quote({ '__aliases__', Meta, [H|_] = Aliases }, #elixir_quote{expand_aliases=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__', Meta, [H|_] = Aliases }, #elixir_quote{expand_aliases=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({ { { '.', 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/alias_test.exs

@@ -26,4 +26,56 @@ defmodule Kernel.AliasTest do
     alias List, as: Nested
     assert Nested.flatten([[13]]) == [13]
   end
-end
+end
+
+defmodule Kernel.AliasNestingGenerator do
+  defmacro create do
+    quote do
+      defmodule Parent do
+        def a, do: :a
+      end
+
+      defmodule Parent.Child do
+        def b, do: Parent.a
+      end
+    end
+  end
+end
+
+defmodule Kernel.AliasNestingTest do
+  use ExUnit.Case, async: true
+
+  require Kernel.AliasNestingGenerator
+  Kernel.AliasNestingGenerator.create
+
+  test :aliases_nesting do
+    assert Parent.a == :a
+    assert Parent.Child.b == :a
+  end
+end
+
+defmodule Kernel.FullAliasNestingGenerator do
+  defmacro create do
+    quote do
+      defmodule Parent do
+        def a, do: :a
+      end
+
+      defmodule Parent.Child do
+        def b, do: Parent.a
+      end
+    end
+  end
+end
+
+defmodule Kernel.FullAliasNestingTest do
+  use ExUnit.Case, async: true
+
+  require Kernel.FullAliasNestingGenerator
+  Kernel.FullAliasNestingGenerator.create
+
+  test :aliases_nesting do
+    assert Parent.a == :a
+    assert Parent.Child.b == :a
+  end
+end