Ensure record aliases in the same quote can be accessed, closes #1915

This commit also simplifies macro expansion for both imports and aliases
to always give higher preference to the macro environment rather than
the caller one, if such is available. The deal is to simplify both the
code and understanding of how macros work.

Author: José Valim

lib/elixir/include/elixir.hrl

@@ -30,9 +30,7 @@
   aliases,                 %% an orddict with aliases by new -> old names
   file,                    %% the current scope filename
   requires,                %% a set with modules required
-  macro_macros=[],         %% a list with macros imported from module inside a macro
   macros,                  %% a list with macros imported from module
-  macro_functions=[],      %% a list with functions imported from module inside a macro
   functions                %% a list with functions imported from module
 }).
 
@@ -47,8 +45,7 @@
   functions,
   macros,
   macro_aliases=[],
-  macro_functions=[],
-  macro_macros=[],
+  macro_counter=0,
   context_modules=[],
   vars=[],
   lexical_tracker=nil

lib/elixir/lib/kernel.ex

@@ -2787,7 +2787,7 @@ defmodule Kernel do
 
           # Generate the alias for this module definition
           { new, old } = module_nesting(env_module(env), full)
-          meta = [defined: true] ++ alias_meta(alias)
+          meta = [defined: true, context: true] ++ alias_meta(alias)
 
           { full, { :alias, meta, [old, [as: new, warn: false]] } }
         false ->
@@ -3775,7 +3775,7 @@ defmodule Kernel do
   defp env_module(env),   do: :erlang.element(2, env)
   defp env_function(env), do: :erlang.element(5, env)
   defp env_context(env),  do: :erlang.element(6, env)
-  defp env_vars(env),     do: :erlang.element(15, env)
+  defp env_vars(env),     do: :erlang.element(14, env)
 
   defp expand_compact([{ :compact, false }|t]), do: expand_compact(t)
   defp expand_compact([{ :compact, true }|t]),  do: [:compact|expand_compact(t)]

lib/elixir/lib/kernel/special_forms.ex

@@ -752,9 +752,8 @@ defmodule Kernel.SpecialForms do
       alias SomethingElse, as: D
       Hygiene.no_interference #=> #HashDict<[]>
 
-  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 using the `alias!` macro inside the quote:
+  In some cases, you want to access an alias or a module defined
+  in the caller. For such, you can use the `alias!` macro:
 
       defmodule Hygiene do
         # This will expand to Elixir.Nested.hello

lib/elixir/lib/macro.ex

@@ -98,12 +98,16 @@ defmodule Macro do
 
       iex> Macro.decompose_call(quote do: foo)
       { :foo, [] }
+
       iex> Macro.decompose_call(quote do: foo())
       { :foo, [] }
+
       iex> Macro.decompose_call(quote do: foo(1, 2, 3))
       { :foo, [1, 2, 3] }
-      iex> Macro.decompose_call(quote do: M.N.foo(1, 2, 3))
-      { { :__aliases__, [alias: false], [:M, :N] }, :foo, [1, 2, 3] }
+
+      iex> Macro.decompose_call(quote do: Elixir.M.foo(1, 2, 3))
+      { { :__aliases__, [], [:Elixir, :M] }, :foo, [1, 2, 3] }
+
       iex> Macro.decompose_call(quote do: 42)
       :error
 

lib/elixir/lib/macro/env.ex

@@ -28,23 +28,25 @@ defmodule Macro.Env do
   @type file :: binary
   @type line :: non_neg_integer
   @type aliases :: [{ module, module }]
+  @type macro_aliases :: [{ module, { integer, module } }]
   @type context :: :match | :guard | nil
   @type requires :: [module]
   @type functions :: [{ module, [name_arity] }]
   @type macros :: [{ module, [name_arity] }]
   @type context_modules :: [module]
   @type vars :: [{ atom, atom | non_neg_integer }]
   @type lexical_tracker :: pid
+  @type counter :: non_neg_integer
 
   fields = [:module, :file, :line, :function, :context, :requires, :aliases, :functions,
-            :macros, :macro_aliases, :macro_functions, :macro_macros, :context_modules,
-            :vars, :lexical_tracker]
+            :macros, :macro_aliases, :macro_counter,
+            :context_modules, :vars, :lexical_tracker]
 
   types  = quote do: [module: module, file: file, line: line,
     function: name_arity, context: context, requires: requires, aliases: aliases,
     functions: functions, macros: macros,  macro_aliases: aliases,
-    macro_functions: functions, macro_macros: macros,
-    context_modules: context_modules, vars: vars, lexical_tracker: lexical_tracker]
+    macro_counter: counter, context_modules: context_modules, vars: vars,
+    lexical_tracker: lexical_tracker]
 
   Record.deffunctions(fields, __MODULE__)
   Record.deftypes(fields, types, __MODULE__)

lib/elixir/src/elixir_aliases.erl

@@ -8,11 +8,18 @@ store(_Meta, New, New, _TKV, Aliases, MacroAliases, _Lexical) ->
   { Aliases, MacroAliases };
 store(Meta, New, Old, TKV, Aliases, MacroAliases, Lexical) ->
   record_warn(Meta, New, TKV, Lexical),
-  NewAliases = orddict:store(New, Old, Aliases),
-
-  case lists:keymember(context, 1, Meta) of
-    true  -> { NewAliases, orddict:store(New, Old, MacroAliases) };
-    false -> { NewAliases, MacroAliases }
+  { store_alias(New, Old, Aliases),
+    store_macro_alias(Meta, New, Old, MacroAliases) }.
+
+store_alias(New, Old, Aliases) ->
+  lists:keystore(New, 1, Aliases, { New, Old }).
+store_macro_alias(Meta, New, Old, Aliases) ->
+  case lists:keymember(context, 1, Meta) andalso
+       lists:keyfind(counter, 1, Meta) of
+    { counter, Counter } when is_integer(Counter) ->
+      lists:keystore(New, 1, Aliases, { New, { Counter, Old } });
+    _ ->
+      Aliases
   end.
 
 record_warn(Meta, Ref, Opts, Lexical) ->
@@ -27,48 +34,38 @@ record_warn(Meta, Ref, Opts, Lexical) ->
 %% Expand an alias. It returns an atom (meaning that there
 %% was an expansion) or a list of atoms.
 
+expand({ '__aliases__', _Meta, ['Elixir'|_] = List }, _Aliases, _MacroAliases, _LexicalTracker) ->
+  concat(List);
+
 expand({ '__aliases__', Meta, _ } = Alias, Aliases, MacroAliases, LexicalTracker) ->
   case lists:keyfind(alias, 1, Meta) of
     { alias, false } ->
       expand(Alias, MacroAliases, LexicalTracker);
     { alias, Atom } when is_atom(Atom) ->
-      case expand(Alias, MacroAliases, LexicalTracker) of
-        OtherAtom when is_atom(OtherAtom) -> OtherAtom;
-        OtherAliases when is_list(OtherAliases) -> Atom
-      end;
+      Atom;
     false ->
       expand(Alias, Aliases, LexicalTracker)
   end.
 
-expand({ '__aliases__', _Meta, [H] }, Aliases, LexicalTracker) when H /= 'Elixir' ->
-  case expand_one(H, Aliases, LexicalTracker) of
-    false -> [H];
-    Atom  -> Atom
-  end;
-
-expand({ '__aliases__', _Meta, [H|T] }, Aliases, LexicalTracker) when is_atom(H) ->
-  case H of
-    'Elixir' ->
-      concat(T);
-    _ ->
-      case expand_one(H, Aliases, LexicalTracker) of
-        false -> [H|T];
-        Atom  -> concat([Atom|T])
+expand({ '__aliases__', Meta, [H|T] }, Aliases, LexicalTracker) when is_atom(H) ->
+  Lookup  = list_to_atom("Elixir." ++ atom_to_list(H)),
+  Counter = case lists:keyfind(counter, 1, Meta) of
+    { counter, C } -> C;
+    _ -> nil
+  end,
+  case lookup(Lookup, Aliases, Counter) of
+    Lookup -> [H|T];
+    Atom ->
+      elixir_lexical:record_alias(Lookup, LexicalTracker),
+      case T of
+        [] -> Atom;
+        _  -> concat([Atom|T])
       end
   end;
 
 expand({ '__aliases__', _Meta, List }, _Aliases, _LexicalTracker) ->
   List.
 
-expand_one(H, Aliases, LexicalTracker) ->
-  Lookup = list_to_atom("Elixir." ++ atom_to_list(H)),
-  case lookup(Lookup, Aliases) of
-    Lookup -> false;
-    Else ->
-      elixir_lexical:record_alias(Lookup, LexicalTracker),
-      Else
-  end.
-
 %% Ensure a module is loaded before its usage.
 
 ensure_loaded(Line, Ref, S) ->
@@ -129,9 +126,10 @@ to_partial(Arg) when is_binary(Arg)   -> Arg.
 
 %% Lookup an alias in the current scope.
 
-lookup(Else, Dict) ->
-  case orddict:find(Else, Dict) of
-    { ok, Value } when Value /= Else -> lookup(Value, Dict);
+lookup(Else, Dict, Counter) ->
+  case lists:keyfind(Else, 1, Dict) of
+    { Else, { Counter, Value } } -> lookup(Value, Dict, Counter);
+    { Else, Value } when is_atom(Value) -> lookup(Value, Dict, Counter);
     _ -> Else
   end.
 

lib/elixir/src/elixir_dispatch.erl

@@ -218,29 +218,15 @@ translate_expansion(Meta, Receiver, Tree, S) ->
   New  = S#elixir_scope.macro_counter + 1,
 
   try
-    { TE, TS } = elixir_translator:translate_each(
+    elixir_translator:translate_each(
       elixir_quote:linify_with_context_counter(Line, { Receiver, New }, Tree),
       S#elixir_scope{macro_counter=New}
-    ),
-    { TE,
-      TS#elixir_scope{
-        macro_macros=S#elixir_scope.macro_macros,
-        macro_aliases=merge_aliases(TS, S),
-        macro_functions=S#elixir_scope.macro_functions
-      } }
+    )
   catch
     Kind:Reason ->
       erlang:raise(Kind, Reason, prune_stacktrace(mfa(Line, S), erlang:get_stacktrace(), nil))
   end.
 
-%% We only keep aliases from module definitions.
-%% All others are discarded straight-away.
-merge_aliases(#elixir_scope{context_modules=Context, macro_aliases=New},
-              #elixir_scope{macro_aliases=Old}) ->
-  ContextAliases = [{ N, O } || { N, O } <- New, lists:member(O, Context)],
-  lists:foldl(fun({ N, O }, Acc) -> orddict:store(N, O, Acc) end,
-              ContextAliases, Old).
-
 mfa(Line, #elixir_scope{module=nil} = S) ->
   { elixir_compiler, '__FILE__', 2, location(Line, S) };
 
@@ -262,7 +248,7 @@ find_dispatch(Meta, Tuple, S) ->
   find_dispatch(Meta, Tuple, [], S).
 
 find_dispatch(Meta, Tuple, Extra, S) ->
-  case is_import(Meta, Tuple, S) of
+  case is_import(Meta) of
     { import, _ } = Import ->
       Import;
     false ->
@@ -287,29 +273,18 @@ find_dispatch(Meta, Tuple, Extra, S) ->
 find_dispatch(Tuple, List) ->
   [Receiver || { Receiver, Set } <- List, is_element(Tuple, Set)].
 
-is_import(Meta, Tuple, S) ->
+is_import(Meta) ->
   case lists:keyfind(import, 1, Meta) of
     { import, _ } = Import ->
       case lists:keyfind(context, 1, Meta) of
-        { context, Context } ->
-          not_an_import(Tuple, Context, S#elixir_scope.macro_functions)
-            andalso not_an_import(Tuple, Context, S#elixir_scope.macro_macros)
-            andalso Import;
+        { context, _ } -> Import;
         false ->
           false
       end;
     false ->
       false
   end.
 
-not_an_import(Tuple, Context, Dict) ->
-  case orddict:find(Context, Dict) of
-    { ok, Pairs } ->
-      not lists:any(fun({ _, List }) -> lists:member(Tuple, List) end, Pairs);
-    error ->
-      true
-  end.
-
 %% We've reached the invoked macro, skip it with the rest
 prune_stacktrace(Info, [{ _, _, [S|_], _ }|_], S) ->
   [Info];

lib/elixir/src/elixir_env.erl

@@ -11,15 +11,13 @@ ex_to_env(Env) when element(1, Env) == 'Elixir.Macro.Env' ->
 env_to_scope(#elixir_env{module=Module,file=File,
     function=Function,aliases=Aliases,context=Context,
     requires=Requires,macros=Macros,functions=Functions,
-    macro_functions=MacroFunctions,macro_macros=MacroMacros,
     context_modules=ContextModules,macro_aliases=MacroAliases,
-    lexical_tracker=Lexical}) ->
+    macro_counter=MacroCounter,lexical_tracker=Lexical}) ->
   #elixir_scope{module=Module,file=File,
     function=Function,aliases=Aliases,context=Context,
     requires=Requires,macros=Macros,functions=Functions,
-    macro_functions=MacroFunctions,macro_macros=MacroMacros,
     context_modules=ContextModules,macro_aliases=MacroAliases,
-    lexical_tracker=Lexical}.
+    macro_counter=MacroCounter,lexical_tracker=Lexical}.
 
 env_to_scope_with_vars(#elixir_env{} = Env, Vars) ->
   (env_to_scope(Env))#elixir_scope{
@@ -31,10 +29,9 @@ scope_to_ex({ Line, #elixir_scope{module=Module,file=File,
     function=Function,aliases=Aliases,context=Context,
     requires=Requires,macros=Macros,functions=Functions,
     context_modules=ContextModules,macro_aliases=MacroAliases,
-    macro_functions=MacroFunctions, macro_macros=MacroMacros,
-    vars=Vars,lexical_tracker=Lexical} }) when is_integer(Line) ->
+    macro_counter=MacroCounter,vars=Vars,lexical_tracker=Lexical} }) when is_integer(Line) ->
   { 'Elixir.Macro.Env', Module, File, Line, Function, Context, Requires, Aliases,
-    Functions, Macros, MacroAliases, MacroFunctions, MacroMacros, ContextModules,
+    Functions, Macros, MacroAliases, MacroCounter, ContextModules,
     [Pair || { Pair, _ } <- Vars], Lexical }.
 
 ex_to_scope(Env) ->

lib/elixir/src/elixir_import.erl

@@ -23,9 +23,9 @@ import(Meta, Ref, Opts, S) ->
   SI.
 
 import_functions(Meta, Ref, Opts, S) ->
-  { Functions, Temp } = calculate(Meta, Ref, Opts, S#elixir_scope.functions,
-    S#elixir_scope.macro_functions, fun() -> get_functions(Ref) end, S),
-  S#elixir_scope{functions=Functions, macro_functions=Temp}.
+  Functions = calculate(Meta, Ref, Opts, S#elixir_scope.functions,
+                        fun() -> get_functions(Ref) end, S),
+  S#elixir_scope{functions=Functions}.
 
 import_macros(Force, Meta, Ref, Opts, S) ->
   Existing = fun() ->
@@ -34,9 +34,8 @@ import_macros(Force, Meta, Ref, Opts, S) ->
       false -> get_optional_macros(Ref)
     end
   end,
-  { Macros, Temp } = calculate(Meta, Ref, Opts, S#elixir_scope.macros,
-    S#elixir_scope.macro_macros, Existing, S),
-  S#elixir_scope{macros=Macros, macro_macros=Temp}.
+  Macros = calculate(Meta, Ref, Opts, S#elixir_scope.macros, Existing, S),
+  S#elixir_scope{macros=Macros}.
 
 record_warn(Meta, Ref, Opts, S) ->
   Warn =
@@ -49,7 +48,7 @@ record_warn(Meta, Ref, Opts, S) ->
 
 %% Calculates the imports based on only and except
 
-calculate(Meta, Key, Opts, Old, Temp, Existing, S) ->
+calculate(Meta, Key, Opts, Old, Existing, S) ->
   New = case keyfind(only, Opts) of
     { only, Only } when is_list(Only) ->
       case Only -- get_exports(Key) of
@@ -77,24 +76,10 @@ calculate(Meta, Key, Opts, Old, Temp, Existing, S) ->
 
   case Final of
     [] ->
-      { keydelete(Key, Old),
-        if_quoted(Meta, Temp, fun(Value) -> keydelete(Key, Value) end) };
+      keydelete(Key, Old);
     _  ->
       ensure_no_special_form_conflict(Meta, S#elixir_scope.file, Key, Final),
-      { [{ Key, Final }|keydelete(Key, Old)],
-        if_quoted(Meta, Temp, fun(Value) -> [{ Key, Final }|keydelete(Key, Value)] end) }
-  end.
-
-if_quoted(Meta, Temp, Callback) ->
-  case lists:keyfind(context, 1, Meta) of
-    { context, Context } ->
-      Current = case orddict:find(Context, Temp) of
-        { ok, Value } -> Value;
-        error -> []
-      end,
-      orddict:store(Context, Callback(Current), Temp);
-    _ ->
-      Temp
+      [{ Key, Final }|keydelete(Key, Old)]
   end.
 
 %% Retrieve functions and macros from modules