Refactor elixir_dispatch to rely more on elixir_scope

Author: José Valim

lib/elixir/lib/macro.ex

@@ -502,13 +502,15 @@ defmodule Macro do
       end
 
   """
-  def expand(aliases, env)
+  def expand(aliases, env) do
+    expand(aliases, env, nil)
+  end
 
-  def expand({ :__aliases__, _, _ } = original, env) do
+  defp expand({ :__aliases__, _, _ } = original, env, cache) 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)
+        aliases = lc alias inlist aliases, do: expand(alias, env, cache)
 
         case :lists.all(is_atom(&1), aliases) do
           true  -> :elixir_aliases.concat(aliases)
@@ -518,20 +520,20 @@ defmodule Macro do
   end
 
   # Expand @ calls
-  def expand({ :@, _, [{ name, _, args }] } = original, env) when is_atom(args) or args == [] do
+  defp expand({ :@, _, [{ name, _, args }] } = original, env, _cache) when is_atom(args) or args == [] do
     case (module = env.module) && Module.open?(module) do
       true  -> Module.get_attribute(module, name)
       false -> original
     end
   end
 
   # Expand pseudo-variables
-  def expand({ :__MODULE__, _, atom }, env) when is_atom(atom), do: env.module
-  def expand({ :__FILE__, _, atom }, env)   when is_atom(atom), do: env.file
-  def expand({ :__ENV__, _, atom }, env)    when is_atom(atom), do: env
+  defp expand({ :__MODULE__, _, atom }, env, _cache) when is_atom(atom), do: env.module
+  defp expand({ :__FILE__, _, atom }, env, _cache)   when is_atom(atom), do: env.file
+  defp expand({ :__ENV__, _, atom }, env, _cache)    when is_atom(atom), do: env
 
   # Expand possible macro import invocation
-  def expand({ atom, line, args } = original, env) when is_atom(atom) do
+  defp expand({ atom, line, args } = original, env, cache) when is_atom(atom) do
     args = case is_atom(args) do
       true  -> []
       false -> args
@@ -549,7 +551,7 @@ defmodule Macro do
         end
 
         expand = :elixir_dispatch.expand_import(line, { atom, length(args) }, args,
-          env.module, env.function, env.requires, env.functions, extra ++ env.macros, env)
+          env.module, extra, to_erl_env(env, cache))
         case expand do
           { :ok, _, expanded } -> expanded
           { :error, _ }     -> original
@@ -558,14 +560,14 @@ defmodule Macro do
   end
 
   # Expand possible macro require invocation
-  def expand({ { :., _, [left, right] }, line, args } = original, env) when is_atom(right) do
+  defp expand({ { :., _, [left, right] }, line, args } = original, env, cache) when is_atom(right) do
     receiver = expand(left, env)
 
     case is_atom(receiver) and not is_partial?(args) do
       false -> original
       true  ->
         expand = :elixir_dispatch.expand_require(line, receiver, { right, length(args) },
-          args, env.module, env.function, env.requires, env)
+          args, env.module, to_erl_env(env, cache))
         case expand do
           { :ok, expanded } -> expanded
           { :error, _ }     -> original
@@ -574,7 +576,10 @@ defmodule Macro do
   end
 
   # Anything else is just returned
-  def expand(other, _env), do: other
+  defp expand(other, _env, _cache), do: other
+
+  defp to_erl_env(env, nil),    do: :elixir_scope.to_erl_env(env)
+  defp to_erl_env(_env, cache), do: cache
 
   ## Helpers
 

lib/elixir/src/elixir_dispatch.erl

@@ -5,7 +5,7 @@
 -export([default_macros/0, default_functions/0, default_requires/0,
   dispatch_require/6, dispatch_import/5,
   require_function/5, import_function/4,
-  expand_import/9, expand_require/8, find_import/4,
+  expand_import/6, expand_require/6, find_import/4,
   format_error/1, in_erlang_functions/0, in_erlang_macros/0]).
 -include("elixir.hrl").
 -compile({parse_transform, elixir_transform}).
@@ -23,7 +23,7 @@ default_requires() ->
 find_import(Meta, Name, Arity, S) ->
   Tuple = { Name, Arity },
 
-  case find_dispatch(Meta, Tuple, S#elixir_scope.functions, S#elixir_scope.macros, S#elixir_scope.file) of
+  case find_dispatch(Meta, Tuple, S) of
     { function, Receiver } -> Receiver;
     { macro, Receiver } -> Receiver;
     nomatch -> false
@@ -33,7 +33,7 @@ find_import(Meta, Name, Arity, S) ->
 
 import_function(Meta, Name, Arity, S) ->
   Tuple = { Name, Arity },
-  case find_dispatch(Meta, Tuple, S#elixir_scope.functions, S#elixir_scope.macros, S#elixir_scope.file) of
+  case find_dispatch(Meta, Tuple, S) of
     { function, Receiver } ->
       elixir_import:record(import, Tuple, Receiver, S#elixir_scope.module),
       remote_function(Meta, Receiver, Name, Arity, S);
@@ -58,7 +58,7 @@ dispatch_import(Meta, Name, Args, S, Callback) ->
   Arity  = length(Args),
   Tuple  = { Name, Arity },
 
-  case find_dispatch(Meta, Tuple, S#elixir_scope.functions, S#elixir_scope.macros, S#elixir_scope.file) of
+  case find_dispatch(Meta, Tuple, S) of
     { function, Receiver } ->
       elixir_import:record(import, Tuple, Receiver, Module),
       Endpoint = case (Receiver == ?BUILTIN) andalso is_element(Tuple, in_erlang_functions()) of
@@ -67,8 +67,7 @@ dispatch_import(Meta, Name, Args, S, Callback) ->
       end,
       elixir_translator:translate_each({ { '.', Meta, [Endpoint, Name] }, Meta, Args }, S);
     Result ->
-      case expand_import(Meta, Tuple, Args, Module, S#elixir_scope.function,
-          S#elixir_scope.requires, S, Result) of
+      case do_expand_import(Meta, Tuple, Args, Module, S, Result) of
         { error, noexpansion } ->
           Callback();
         { error, internal } ->
@@ -88,8 +87,7 @@ dispatch_require(Meta, Receiver, Name, Args, S, Callback) ->
     true ->
       elixir_translator:translate_each({ { '.', Meta, [erlang, Name] }, Meta, Args }, S);
     false ->
-      case expand_require(Meta, Receiver, Tuple, Args, Module,
-          S#elixir_scope.function, S#elixir_scope.requires, S) of
+      case expand_require(Meta, Receiver, Tuple, Args, Module, S) of
         { error, noexpansion } ->
           Callback();
         { error, internal } ->
@@ -101,84 +99,85 @@ dispatch_require(Meta, Receiver, Name, Args, S, Callback) ->
 
 %% Macros expansion
 
-expand_import(Meta, { Name, Arity } = Tuple, Args, Module, Function, Requires, SEnv, Result) ->
+expand_import(Meta, Tuple, Args, Module, Extra, S) ->
+  Result = find_dispatch(Meta, Tuple, Extra, S),
+  do_expand_import(Meta, Tuple, Args, Module, S, Result).
+
+do_expand_import(Meta, { Name, Arity } = Tuple, Args, Module, S, Result) ->
   case Result of
     { macro, ?BUILTIN } ->
       case is_element(Tuple, in_erlang_macros()) of
         true  -> { error, internal };
         false ->
           elixir_import:record(import, Tuple, ?BUILTIN, Module),
-          { ok, ?BUILTIN, expand_macro_named(Meta, ?BUILTIN, Name, Arity, Args, Module, Requires, SEnv) }
+          { ok, ?BUILTIN, expand_macro_named(Meta, ?BUILTIN, Name, Arity, Args, Module, S) }
       end;
     { macro, Receiver } ->
       elixir_import:record(import, Tuple, Receiver, Module),
-      { ok, Receiver, expand_macro_named(Meta, Receiver, Name, Arity, Args, Module, Requires, SEnv) };
+      { ok, Receiver, expand_macro_named(Meta, Receiver, Name, Arity, Args, Module, S) };
     _ ->
-      Fun = (Function /= Tuple) andalso
+      Fun = (S#elixir_scope.function /= Tuple) andalso
         elixir_def_local:macro_for(Tuple, true, Module),
       case Fun of
         false -> { error, noexpansion };
         _ ->
           elixir_import:record(import, Tuple, Module, Module),
-          { ok, Module, expand_macro_fun(Meta, Fun, Module, Name, Args, Module, Requires, SEnv) }
+          { ok, Module, expand_macro_fun(Meta, Fun, Module, Name, Args, Module, S) }
       end
   end.
 
-expand_import(Meta, Tuple, Args, Module, Function, Requires, Functions, Macros, SEnv) ->
-  Result = find_dispatch(Meta, Tuple, Functions, Macros, elixir_scope:filename(SEnv)),
-  expand_import(Meta, Tuple, Args, Module, Function, Requires, SEnv, Result).
-
-expand_require(Meta, ?BUILTIN, { Name, Arity } = Tuple, Args, Module, _Function, Requires, SEnv) ->
+expand_require(Meta, ?BUILTIN, { Name, Arity } = Tuple, Args, Module, S) ->
   case is_element(Tuple, in_erlang_macros()) of
     true  -> { error, internal };
     false ->
       case is_element(Tuple, in_elixir_macros()) of
-        true  -> { ok, expand_macro_named(Meta, ?BUILTIN, Name, Arity, Args, Module, Requires, SEnv) };
+        true  -> { ok, expand_macro_named(Meta, ?BUILTIN, Name, Arity, Args, Module, S) };
         false -> { error, noexpansion }
       end
   end;
 
-expand_require(Meta, Receiver, { Name, Arity } = Tuple, Args, Module, Function, Requires, SEnv) ->
-  Fun = (Module == Receiver) andalso (Function /= Tuple) andalso
+expand_require(Meta, Receiver, { Name, Arity } = Tuple, Args, Module, S) ->
+  Fun = (Module == Receiver) andalso (S#elixir_scope.function /= Tuple) andalso
     elixir_def_local:macro_for(Tuple, false, Module),
 
   case Fun of
     false ->
       case is_element(Tuple, get_optional_macros(Receiver)) of
-        true  -> { ok, expand_macro_named(Meta, Receiver, Name, Arity, Args, Module, Requires, SEnv) };
+        true  -> { ok, expand_macro_named(Meta, Receiver, Name, Arity, Args, Module, S) };
         false -> { error, noexpansion }
       end;
     _ ->
       elixir_import:record(import, Tuple, Receiver, Module),
-      { ok, expand_macro_fun(Meta, Fun, Receiver, Name, Args, Module, Requires, SEnv) }
+      { ok, expand_macro_fun(Meta, Fun, Receiver, Name, Args, Module, S) }
   end.
 
 %% Expansion helpers
 
-expand_macro_fun(Meta, Fun, Receiver, Name, Args, Module, Requires, SEnv) ->
-  case (Receiver == Module) or is_element(Receiver, Requires) or skip_requires(SEnv) of
+expand_macro_fun(Meta, Fun, Receiver, Name, Args, Module, S) ->
+  Requires = S#elixir_scope.requires,
+  case (Receiver == Module) or is_element(Receiver, Requires) or not(S#elixir_scope.check_requires) of
     true  -> ok;
     false ->
       Tuple = { unrequired_module, { Receiver, Name, length(Args), Requires } },
-      elixir_errors:form_error(Meta, elixir_scope:filename(SEnv), ?MODULE, Tuple)
+      elixir_errors:form_error(Meta, S#elixir_scope.file, ?MODULE, Tuple)
   end,
 
   Line = ?line(Meta),
-  SArg = {Line,SEnv},
+  SArg = {Line,S},
 
   try
     apply(Fun, [SArg|Args])
   catch
     Kind:Reason ->
-      Info = { Receiver, Name, length(Args), [{ file, elixir_scope:filename(SEnv) }, { line, Line }] },
+      Info = { Receiver, Name, length(Args), [{ file, S#elixir_scope.file }, { line, Line }] },
       erlang:raise(Kind, Reason, munge_stacktrace(Info, erlang:get_stacktrace(), SArg))
   end.
 
-expand_macro_named(Meta, Receiver, Name, Arity, Args, Module, Requires, SEnv) ->
+expand_macro_named(Meta, Receiver, Name, Arity, Args, Module, S) ->
   ProperName  = ?elixir_macro(Name),
   ProperArity = Arity + 1,
   Fun         = fun Receiver:ProperName/ProperArity,
-  expand_macro_fun(Meta, Fun, Receiver, Name, Args, Module, Requires, SEnv).
+  expand_macro_fun(Meta, Fun, Receiver, Name, Args, Module, S).
 
 translate_expansion(Meta, Tree, S) ->
   { TR, TS } = elixir_translator:translate_each(
@@ -197,10 +196,20 @@ merge_aliases(A1, A2) ->
 
 %% Helpers
 
-skip_requires(#elixir_scope{check_requires=false}) -> true;
-skip_requires(_) -> false.
+% case lists:keyfind(import, 1, Meta) of
+%   { import, Receiver } ->
+%     { TRes, TS } = translate_each({ { '.', Meta, [Receiver, Atom] }, Meta, Args },
+%       S#elixir_scope{check_requires=false}),
+%     { TRes, TS#elixir_scope{check_requires=S#elixir_scope.check_requires} };
+%   false ->
+
+find_dispatch(Meta, Tuple, S) ->
+  find_dispatch(Meta, Tuple, [], S).
 
-find_dispatch(Meta, Tuple, Functions, Macros, File) ->
+find_dispatch(Meta, Tuple, Extra, S) ->
+  Functions = S#elixir_scope.functions,
+  Macros = Extra ++ S#elixir_scope.macros,
+  File = S#elixir_scope.file,
   FunMatch = find_dispatch(Tuple, Functions),
   MacMatch = find_dispatch(Tuple, Macros),
 

lib/elixir/src/elixir_macros.erl

@@ -56,10 +56,10 @@ translate({ function, Meta, [[{do,{ '->',_,Pairs}}]] }, S) ->
   assert_no_match_or_guard_scope(Meta, 'function', S),
   elixir_translator:translate_fn(Meta, Pairs, S);
 
-translate({ function, Meta, [{ '/', _, [{{ '.', _ ,[M, F] }, _ , [] }, A]}] }, S) when is_atom(F), is_integer(A) ->
+translate({ function, _, [{ '/', _, [{{ '.', Meta, [M, F] }, _ , []}, A]}] }, S) when is_atom(F), is_integer(A) ->
   translate({ function, Meta, [M, F, A] }, S);
 
-translate({ function, Meta, [{ '/', _, [{F, _, C}, A]}] }, S) when is_atom(F), is_integer(A), is_atom(C) ->
+translate({ function, _, [{ '/', _, [{F, Meta, C}, A]}] }, S) when is_atom(F), is_integer(A), is_atom(C) ->
   assert_no_match_or_guard_scope(Meta, 'function', S),
 
   case elixir_dispatch:import_function(Meta, F, A, S) of

lib/elixir/src/elixir_scope.erl

@@ -5,9 +5,9 @@
   build_erl_var/2, build_ex_var/2,
   serialize/1, deserialize/1,
   serialize_with_vars/2, deserialize_with_vars/2,
-  to_erl_env/1, to_ex_env/1, filename/1,
+  to_erl_env/1, to_ex_env/1,
   umergev/2, umergec/2, merge_clause_vars/2
-  ]).
+]).
 -include("elixir.hrl").
 -compile({parse_transform, elixir_transform}).
 
@@ -77,20 +77,16 @@ build_ex_var(Line, Key, Name, S) when is_integer(Line) ->
 
 % Handle Macro.Env conversion
 
-to_erl_env(Scope) ->
-  elixir_tree_helpers:abstract_syntax(to_ex_env(Scope)).
-
-to_ex_env({ Line, Tuple }) when element(1, Tuple) == 'Elixir.Macro.Env', is_integer(Line) ->
-  setelement(4, Tuple, Line);
+to_erl_env({ 'Elixir.Macro.Env', Module, File, _Line, Function, Aliases, Context, Requires, Functions, Macros }) ->
+  #elixir_scope{module=Module,file=File,
+    function=Function,aliases=Aliases,context=Context,
+    requires=Requires,macros=Macros,functions=Functions}.
 
 to_ex_env({ Line, #elixir_scope{module=Module,file=File,
     function=Function,aliases=Aliases,context=Context,
     requires=Requires,macros=Macros,functions=Functions} }) when is_integer(Line) ->
   { 'Elixir.Macro.Env', Module, File, Line, Function, Aliases, Context, Requires, Functions, Macros }.
 
-filename(#elixir_scope{file=File}) -> File;
-filename(Other) -> element(3, Other).
-
 % Provides a tuple with only the scope information we want to serialize.
 
 serialize(S) ->

lib/elixir/src/elixir_translator.erl

@@ -207,7 +207,8 @@ translate_each({ '__FILE__', _Meta, Atom }, S) when is_atom(Atom) ->
   translate_each(S#elixir_scope.file, S);
 
 translate_each({ '__ENV__', Meta, Atom }, S) when is_atom(Atom) ->
-  { elixir_scope:to_erl_env({ ?line(Meta), S }), S };
+  Env = elixir_scope:to_ex_env({ ?line(Meta), S }),
+  { elixir_tree_helpers:abstract_syntax(Env), S };
 
 translate_each({ '__CALLER__', Meta, Atom }, S) when is_atom(Atom) ->
   { { var, ?line(Meta), '__CALLER__' }, S#elixir_scope{caller=true} };
@@ -438,8 +439,8 @@ translate_each({ Atom, Meta, Args } = Original, S) when is_atom(Atom) ->
                     Arity = length(Args),
                     File  = S#elixir_scope.file,
                     case Arity of
-                      0 -> syntax_error(Meta, File, "unknown variable ~s or cannot invoke local ~s/~B inside guard", [Atom, Atom, Arity]);
-                      _ -> syntax_error(Meta, File, "cannot invoke local ~s/~B inside guard", [Atom, Arity])
+                      0 -> syntax_error(Meta, File, "unknown variable ~ts or cannot invoke local ~ts/~B inside guard", [Atom, Atom, Arity]);
+                      _ -> syntax_error(Meta, File, "cannot invoke local ~ts/~B inside guard", [Atom, Arity])
                     end;
                   _ ->
                     translate_local(Meta, Atom, Args, S)