Ensure aliases expansion also works for implicit aliases

Author: José Valim

lib/elixir/include/elixir.hrl

@@ -25,8 +25,9 @@
   counter=[],              %% a counter for the variables defined
   local=nil,               %% the scope to evaluate local functions against
   scheduled=[],            %% scheduled modules to be loaded
-  file,                    %% the current scope filename
+  macro_aliases=[],        %% keep aliases defined inside a macro
   aliases,                 %% an orddict with aliases by new -> old names
+  file,                    %% the current scope filename
   requires,                %% a set with modules required
   macros,                  %% a list with macros imported by module
   functions}).             %% a list with functions imported by module

lib/elixir/lib/kernel/special_forms.ex

@@ -452,7 +452,7 @@ defmodule Kernel.SpecialForms do
 
   ### Hygiene in aliases
 
-  Aliases inside quote are expanded by default.
+  Aliases inside quote are hygienic by default.
   Consider the following example:
 
       defmodule Hygiene do
@@ -464,24 +464,43 @@ defmodule Kernel.SpecialForms do
       end
 
       require Hygiene
-      Hygiene.no_interference #=> HashDict[]
+      Hygiene.no_interference #=> #HashDict<[]>
 
   Notice that, even though the alias `D` is not available
   in the context the macro is expanded, the code above works
-  because `D` was expanded when the quote was generated.
+  because `D` still expands to `HashDict`.
 
-  There are two ways to disable this behaviour. By disabling
-  hygiene for aliases or by using the `alias!` macro inside
-  the quote:
+  In some particular cases you may want to access an alias
+  or a module defined in the caller. In such scenarios, you
+  can access it by disabling hygiene with `hygiene: [aliases: false]`
+  or by using the `alias!` macro inside the quote:
 
-      defmodule NoHygiene do
+      defmodule Hygiene do
+        # This will expand to Elixir.Nested.hello
+        defmacro no_interference do
+          quote do: Nested.hello
+        end
+
+        # This will expand to Nested.hello for
+        # whatever is Nested in the caller
         defmacro interference do
-          quote do: alias!(D).new
+          quote do: alias!(Nested).hello
         end
       end
 
-      require NoHygiene
-      NoHygiene.interference #=> UndefinedFunctionError
+      defmodule Parent do
+        defmodule Nested do
+          def hello, do: "world"
+        end
+
+        require Hygiene
+        Hygiene.no_interference
+        #=> ** (UndefinedFunctionError) ...
+
+        Hygiene.interference
+        #=> "world"
+      end
+
 
   ## Hygiene in imports
 
@@ -564,7 +583,7 @@ defmodule Kernel.SpecialForms do
   particular, the macro `__FILE__` and exceptions happening inside
   the quote will always point to `GenServer.Behaviour` file.
   """
-  defmacro quote(opts, do: contents)
+  defmacro quote(opts, block)
 
   @doc """
   When used inside quoting, marks that the variable should

lib/elixir/lib/macro.ex

@@ -443,7 +443,7 @@ defmodule Macro do
   def expand(aliases, env)
 
   def expand({ :__aliases__, _, _ } = original, env) do
-    case :elixir_aliases.expand(original, env.aliases) do
+    case :elixir_aliases.expand(original, env.aliases, []) do
       atom when is_atom(atom) -> atom
       aliases ->
         aliases = lc alias inlist aliases, do: expand(alias, env)

lib/elixir/src/elixir_aliases.erl

@@ -1,41 +1,46 @@
 -module(elixir_aliases).
 -export([nesting_alias/2, last/1, concat/1, safe_concat/1,
-  format_error/1, ensure_loaded/3, expand/2]).
+  format_error/1, ensure_loaded/3, expand/3]).
 -include("elixir.hrl").
 -compile({parse_transform, elixir_transform}).
 
 %% Expand an alias. It returns an atom (meaning that there
 %% was an expansion) or a list of atoms.
 
-expand({ '__aliases__', Meta, _ } = Alias, Aliases) ->
+expand({ '__aliases__', Meta, _ } = Alias, Aliases, MacroAliases) ->
   case lists:keyfind(alias, 1, Meta) of
+    { alias, false } ->
+      expand(Alias, MacroAliases);
     { alias, Atom } when is_atom(Atom) ->
-      Atom;
+      case expand(Alias, MacroAliases) of
+        OtherAtom when is_atom(OtherAtom) -> OtherAtom;
+        OtherAliases when is_list(OtherAliases) -> Atom
+      end;
     false ->
-      do_expand(Alias, Aliases)
+      expand(Alias, Aliases)
   end.
 
-do_expand({ '__aliases__', _Meta, [H] }, Aliases) when H /= 'Elixir' ->
-  case do_expand_one(H, Aliases) of
+expand({ '__aliases__', _Meta, [H] }, Aliases) when H /= 'Elixir' ->
+  case expand_one(H, Aliases) of
     false -> [H];
     Atom  -> Atom
   end;
 
-do_expand({ '__aliases__', _Meta, [H|T] }, Aliases) when is_atom(H) ->
+expand({ '__aliases__', _Meta, [H|T] }, Aliases) when is_atom(H) ->
   case H of
     'Elixir' ->
       concat(T);
     _ ->
-      case do_expand_one(H, Aliases) of
+      case expand_one(H, Aliases) of
         false -> [H|T];
         Atom  -> concat([Atom|T])
       end
   end;
 
-do_expand({ '__aliases__', _Meta, List }, _Aliases) ->
+expand({ '__aliases__', _Meta, List }, _Aliases) ->
   List.
 
-do_expand_one(H, Aliases) ->
+expand_one(H, Aliases) ->
   Lookup = list_to_atom("Elixir-" ++ atom_to_list(H)),
   case lookup(Lookup, Aliases) of
     Lookup -> false;

lib/elixir/src/elixir_dispatch.erl

@@ -182,9 +182,13 @@ expand_macro_named(Meta, Receiver, Name, Arity, Args, Module, Requires, SEnv) ->
 translate_expansion(Meta, Tree, S) ->
   { TR, TS } = elixir_translator:translate_each(
     elixir_quote:linify(?line(Meta), Tree),
-    S#elixir_scope{check_clauses=false}
+    S#elixir_scope{
+      check_clauses=false,
+      macro_aliases=[] }
   ),
-  { TR, TS#elixir_scope{check_clauses=S#elixir_scope.check_clauses} }.
+  { TR, TS#elixir_scope{
+    check_clauses=S#elixir_scope.check_clauses,
+    macro_aliases=S#elixir_scope.macro_aliases } }.
 
 %% Helpers
 

lib/elixir/src/elixir_macros.erl

@@ -200,7 +200,9 @@ translate({defmodule, Meta, [Ref, KV]}, S) ->
 
       RS = case elixir_aliases:nesting_alias(S#elixir_scope.module, FullModule) of
         { New, Old } ->
-          S#elixir_scope{aliases=orddict:store(New, Old, S#elixir_scope.aliases)};
+          S#elixir_scope{
+            aliases=orddict:store(New, Old, S#elixir_scope.aliases),
+            macro_aliases=orddict:store(New, Old, S#elixir_scope.macro_aliases)};
         false ->
           S
       end,
@@ -333,7 +335,7 @@ expand_module(Raw, Module, #elixir_scope{module=Nesting}) when is_atom(Raw); Nes
   Module;
 
 expand_module({ '__aliases__', _, _ } = Alias, Module, S) ->
-  case elixir_aliases:expand(Alias, S#elixir_scope.aliases) of
+  case elixir_aliases:expand(Alias, S#elixir_scope.aliases, S#elixir_scope.macro_aliases) of
     Atom when is_atom(Atom) ->
       Module;
     Aliases when is_list(Aliases) ->

lib/elixir/src/elixir_quote.erl

@@ -54,18 +54,18 @@ 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__', 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
+do_quote({ '__aliases__', Meta, [H|T] } = Alias, #elixir_quote{aliases_hygiene=true} = Q, S) when is_atom(H) and (H /= 'Elixir') ->
+  Annotation = case elixir_aliases:expand(Alias, S#elixir_scope.aliases, S#elixir_scope.macro_aliases) of
+    Atom when is_atom(Atom) -> Atom;
+    Aliases when is_list(Aliases) -> false
   end,
 
   Line = ?line(Meta),
   { TAliases, SA } = do_quote([H|T], Q, S),
 
   { { tuple, Line, [
     { atom, Line, '__aliases__' },
-    meta(Meta, Q),
+    meta([{alias,Annotation}|Meta], Q),
     TAliases
   ] }, SA };
 

lib/elixir/src/elixir_scope.erl

@@ -96,7 +96,8 @@ filename(Other) -> element(3, Other).
 serialize(S) ->
   elixir_tree_helpers:abstract_syntax(
     { S#elixir_scope.file, S#elixir_scope.functions, S#elixir_scope.check_clauses,
-      S#elixir_scope.requires, S#elixir_scope.macros, S#elixir_scope.aliases, S#elixir_scope.scheduled }
+      S#elixir_scope.requires, S#elixir_scope.macros, S#elixir_scope.aliases,
+      S#elixir_scope.macro_aliases, S#elixir_scope.scheduled }
   ).
 
 serialize_with_vars(Line, S) when is_integer(Line) ->
@@ -114,14 +115,15 @@ serialize_with_vars(Line, S) when is_integer(Line) ->
 
 deserialize(Tuple) -> deserialize_with_vars(Tuple, []).
 
-deserialize_with_vars({ File, Functions, CheckClauses, Requires, Macros, Aliases, Scheduled }, Vars) ->
+deserialize_with_vars({ File, Functions, CheckClauses, Requires, Macros, Aliases, MacroAliases, Scheduled }, Vars) ->
   #elixir_scope{
     file=File,
     functions=Functions,
     check_clauses=CheckClauses,
     requires=Requires,
     macros=Macros,
     aliases=Aliases,
+    macro_aliases=MacroAliases,
     scheduled=Scheduled,
     vars=orddict:from_list(Vars),
     counter=[{'',length(Vars)}]

lib/elixir/src/elixir_translator.erl

@@ -107,7 +107,8 @@ translate_each({ alias, Meta, [Ref, KV] }, S) ->
         { as, false } ->
           { Old, SR };
         { as, Other } ->
-          { TOther, SA } = translate_each(Other, SR#elixir_scope{aliases=[]}),
+          { TOther, SA } = translate_each(no_alias_expansion(Other),
+            SR#elixir_scope{aliases=[],macro_aliases=[]}),
           case TOther of
             { atom, _, Atom } -> { Atom, SA };
             _ -> syntax_error(Meta, S#elixir_scope.file,
@@ -127,7 +128,8 @@ translate_each({ alias, Meta, [Ref, KV] }, S) ->
           end,
 
           { { nil, ?line(Meta) }, SF#elixir_scope{
-            aliases=orddict:store(New, Old, S#elixir_scope.aliases)
+            aliases=orddict:store(New, Old, S#elixir_scope.aliases),
+            macro_aliases=orddict:store(New, Old, S#elixir_scope.macro_aliases)
           } }
       end;
     _ ->
@@ -213,7 +215,7 @@ translate_each({ '__CALLER__', Meta, Atom }, S) when is_atom(Atom) ->
 %% Aliases
 
 translate_each({ '__aliases__', Meta, _ } = Alias, S) ->
-  case elixir_aliases:expand(Alias, S#elixir_scope.aliases) of
+  case elixir_aliases:expand(Alias, S#elixir_scope.aliases, S#elixir_scope.macro_aliases) of
     Atom when is_atom(Atom) -> { { atom, ?line(Meta), Atom }, S };
     Aliases ->
       { TAliases, SA } = translate_args(Aliases, S),
@@ -555,6 +557,12 @@ expand_var_context(Meta, Alias, Msg, S) ->
       syntax_error(Meta, S#elixir_scope.file, "~ts, expected a compile time available alias or an atom", [Msg])
   end.
 
+no_alias_expansion({ '__aliases__', Meta, [H|T] }) when (H /= 'Elixir') and is_atom(H) ->
+  { '__aliases__', Meta, ['Elixir',H|T] };
+
+no_alias_expansion(Other) ->
+  Other.
+
 %% Translate args
 
 %% Variables in arguments are not propagated from one

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

@@ -159,14 +159,41 @@ defmodule Kernel.QuoteTest.AliasHygieneTest do
 
   alias Dict, as: SuperDict
 
-  test :expand_aliases do
-    assert quote(do: Foo.Bar) == { :__aliases__, [], [:Foo, :Bar] }
-    assert quote(do: Dict.Bar) == { :__aliases__, [], [:Dict, :Bar] }
+  defmacro dict do
+    quote do: Dict.Bar
+  end
+
+  defmacro super_dict do
+    quote do: SuperDict.Bar
+  end
+
+  test :annotate_aliases do
+    assert quote(do: Foo.Bar) == { :__aliases__, [alias: false], [:Foo, :Bar] }
+    assert quote(do: Dict.Bar) == { :__aliases__, [alias: false], [:Dict, :Bar] }
     assert quote(do: SuperDict.Bar) == { :__aliases__, [alias: Dict.Bar], [:SuperDict, :Bar] }
     assert quote(do: alias!(SuperDict.Bar)) == { :__aliases__, [], [:SuperDict, :Bar] }
+  end
 
+  test :expand_aliases do
     assert Code.eval_quoted(quote do: SuperDict.Bar) == { Elixir.Dict.Bar, [] }
     assert Code.eval_quoted(quote do: alias!(SuperDict.Bar)) == { Elixir.SuperDict.Bar, [] }
+
+    assert Code.eval_quoted(quote do
+      alias HashDict, as: SuperDict
+      SuperDict.Bar
+    end) == { Elixir.HashDict.Bar, [] }
+
+    assert Code.eval_quoted(quote do
+      alias HashDict, as: Dict
+      require Kernel.QuoteTest.AliasHygieneTest
+      Kernel.QuoteTest.AliasHygieneTest.dict
+    end) == { Elixir.Dict.Bar, [] }
+
+    assert Code.eval_quoted(quote do
+      alias HashDict, as: SuperDict
+      require Kernel.QuoteTest.AliasHygieneTest
+      Kernel.QuoteTest.AliasHygieneTest.super_dict
+    end) == { Elixir.Dict.Bar, [] }
   end
 end