Rename Kernel.LocalsTracker to Module.DispatchTracker

Author: José Valim

lib/elixir/lib/kernel/locals_tracker.ex renamed to lib/elixir/lib/module/dispatch_tracker.ex

@@ -42,7 +42,7 @@
 #
 # Note that since this is required for bootstrap, we can't use
 # any of the `GenServer.Behaviour` conveniences.
-defmodule Kernel.LocalsTracker do
+defmodule Module.DispatchTracker do
   @moduledoc false
 
   @timeout  30_000
@@ -81,9 +81,9 @@ defmodule Kernel.LocalsTracker do
   end
 
   defp reduce_reachable(d, vertex, vertices) do
-    neighbours = :digraph.out_neighbours(d, vertex)
-    remaining  = neighbours -- vertices
-    vertices   = neighbours ++ vertices
+    neighbours = :digraph.out_neighbours(d, vertex) |> :ordsets.from_list
+    remaining  = :ordsets.subtract(neighbours, vertices)
+    vertices   = :ordsets.union(neighbours, vertices)
     :lists.foldl(reduce_reachable(d, &1, &2), vertices, remaining)
   end
 

lib/elixir/src/elixir_clauses.erl

@@ -1,5 +1,5 @@
-%% Handle code related to rocket args, guard and -> matching
-%% for case, fn, receive and friends. try is handled in elixir_try.
+%% Handle code related to args, guard and -> matching for case,
+%% fn, receive and friends. try is handled in elixir_try.
 -module(elixir_clauses).
 -export([
   assigns/3, assigns_block/5, assigns_block/6, extract_last_guards/1,

lib/elixir/src/elixir_compiler.erl

@@ -225,8 +225,8 @@ core_main() ->
     "lib/elixir/lib/kernel/cli.ex",
     "lib/elixir/lib/kernel/error_handler.ex",
     "lib/elixir/lib/kernel/parallel_compiler.ex",
-    "lib/elixir/lib/kernel/locals_tracker.ex",
-    "lib/elixir/lib/kernel/record_rewriter.ex"
+    "lib/elixir/lib/kernel/record_rewriter.ex",
+    "lib/elixir/lib/module/dispatch_tracker.ex"
   ].
 
 %% ERROR HANDLING

lib/elixir/src/elixir_def_local.erl

@@ -0,0 +1,62 @@
+%% Module responsible for local invocation of macros and functions.
+-module(elixir_def_local).
+-export([macro_for/3, function_for/3]).
+-include("elixir.hrl").
+
+macro_for(_Tuple, _All, #elixir_scope{module=nil}) -> false;
+
+macro_for(Tuple, All, #elixir_scope{module=Module} = S) ->
+  try elixir_def:lookup_definition(Module, Tuple) of
+    { { Tuple, Kind, Line, _, _, _, _ }, Clauses } when Kind == defmacro; All, Kind == defmacrop ->
+      elixir_tracker:record_local(Tuple, S),
+      get_function(Line, Module, Clauses);
+    _ ->
+      false
+  catch
+    error:badarg -> false
+  end.
+
+function_for(Module, Name, Arity) ->
+  Tuple = { Name, Arity },
+  case elixir_def:lookup_definition(Module, Tuple) of
+    { { Tuple, _, Line, _, _, _, _ }, Clauses } ->
+      %% There is no need to record such calls
+      %% since they come from funtions that were
+      %% already analyzed at compilation time.
+      get_function(Line, Module, Clauses);
+    _ ->
+      [_|T] = erlang:get_stacktrace(),
+      erlang:raise(error, undef, [{Module,Name,Arity,[]}|T])
+  end.
+
+get_function(Line, Module, Clauses) ->
+  RewrittenClauses = [rewrite_clause(Clause, Module) || Clause <- Clauses],
+  Fun = { 'fun', Line, {clauses, RewrittenClauses } },
+  { value, Result, _Binding } = erl_eval:exprs([Fun], []),
+  Result.
+
+rewrite_clause({ call, Line, { atom, Line, RawName }, Args }, Module) ->
+  Remote = { remote, Line,
+    { atom, Line, ?MODULE },
+    { atom, Line, function_for }
+  },
+
+  %% If we have a macro, its arity in the table is
+  %% actually one less than in the function call
+  { Name, Arity } = case atom_to_list(RawName) of
+    "MACRO-" ++ Rest -> { list_to_atom(Rest), length(Args) - 1 };
+    _ -> { RawName, length(Args) }
+  end,
+
+  FunCall = { call, Line, Remote, [
+    { atom, Line, Module }, { atom, Line, Name }, { integer, Line, Arity }
+  ] },
+  { call, Line, FunCall, Args };
+
+rewrite_clause(Tuple, Module) when is_tuple(Tuple) ->
+  list_to_tuple(rewrite_clause(tuple_to_list(Tuple), Module));
+
+rewrite_clause(List, Module) when is_list(List) ->
+  [rewrite_clause(Item, Module) || Item <- List];
+
+rewrite_clause(Else, _) -> Else.

lib/elixir/src/elixir_dispatch.erl

@@ -34,14 +34,14 @@ import_function(Meta, Name, Arity, S) ->
   Tuple = { Name, Arity },
   case find_dispatch(Meta, Tuple, S) of
     { function, Receiver } ->
-      elixir_locals:record_import(Tuple, Receiver, S#elixir_scope.module),
+      elixir_tracker:record_import(Tuple, Receiver, S#elixir_scope.module),
       remote_function(Meta, Receiver, Name, Arity, S);
     { macro, _Receiver } ->
       false;
     { import, Receiver } ->
       require_function(Meta, Receiver, Name, Arity, S);
     nomatch ->
-      elixir_locals:record_local(Tuple, S),
+      elixir_tracker:record_local(Tuple, S),
       { { 'fun', ?line(Meta), { function, Name, Arity } }, S }
   end.
 
@@ -62,7 +62,7 @@ dispatch_import(Meta, Name, Args, S, Callback) ->
 
   case find_dispatch(Meta, Tuple, S) of
     { function, Receiver } ->
-      elixir_locals:record_import(Tuple, Receiver, Module),
+      elixir_tracker:record_import(Tuple, Receiver, Module),
       Endpoint = case (Receiver == ?builtin) andalso is_element(Tuple, in_erlang_functions()) of
         true  -> erlang;
         false -> Receiver
@@ -75,7 +75,7 @@ dispatch_import(Meta, Name, Args, S, Callback) ->
         { error, noexpansion } ->
           Callback();
         { error, internal } ->
-          elixir_locals:record_import(Tuple, ?builtin, Module),
+          elixir_tracker:record_import(Tuple, ?builtin, Module),
           elixir_macros:translate({ Name, Meta, Args }, S);
         { ok, _Receiver, Tree } ->
           translate_expansion(Meta, Tree, S)
@@ -114,17 +114,17 @@ do_expand_import(Meta, { Name, Arity } = Tuple, Args, Module, S, Result) ->
       case is_element(Tuple, in_erlang_macros()) of
         true  -> { error, internal };
         false ->
-          elixir_locals:record_import(Tuple, ?builtin, Module),
+          elixir_tracker:record_import(Tuple, ?builtin, Module),
           { ok, ?builtin, expand_macro_named(Meta, ?builtin, Name, Arity, Args, Module, S) }
       end;
     { macro, Receiver } ->
-      elixir_locals:record_import(Tuple, Receiver, Module),
+      elixir_tracker:record_import(Tuple, Receiver, Module),
       { ok, Receiver, expand_macro_named(Meta, Receiver, Name, Arity, Args, Module, S) };
     { import, Receiver } ->
       expand_require(Meta, Receiver, Tuple, Args, Module, S);
     _ ->
       Fun = (S#elixir_scope.function /= Tuple) andalso
-        elixir_locals:macro_for(Tuple, true, S),
+        elixir_def_local:macro_for(Tuple, true, S),
       case Fun of
         false -> { error, noexpansion };
         _ ->
@@ -144,7 +144,7 @@ expand_require(Meta, ?builtin, { Name, Arity } = Tuple, Args, Module, S) ->
 
 expand_require(Meta, Receiver, { Name, Arity } = Tuple, Args, Module, S) ->
   Fun = (Module == Receiver) andalso (S#elixir_scope.function /= Tuple) andalso
-    elixir_locals:macro_for(Tuple, false, S),
+    elixir_def_local:macro_for(Tuple, false, S),
 
   case Fun of
     false ->

lib/elixir/src/elixir_import.erl

@@ -49,7 +49,7 @@ record_warn(Meta, Ref, Opts, #elixir_scope{module=Module}) ->
       false -> not lists:keymember(context, 1, Meta)
     end,
 
-  elixir_locals:record_warn(Ref, Warn, ?line(Meta), Module).
+  elixir_tracker:record_warn(Ref, Warn, ?line(Meta), Module).
 
 %% Calculates the imports based on only and except
 

lib/elixir/src/elixir_literal.erl

@@ -1,3 +1,4 @@
+%% Handle translation of Elixir literals to Erlang AST.
 -module(elixir_literal).
 -export([translate/2]).
 -import(elixir_translator, [translate_each/2, translate_args/2]).

lib/elixir/src/elixir_module.erl

@@ -77,12 +77,12 @@ compile(Line, Module, Block, Vars, #elixir_scope{context_modules=FileModules} =
     case ets:lookup(data_table(Module), 'on_load') of
       [] -> ok;
       [{on_load,OnLoad}] ->
-        [elixir_locals:record_local(Tuple, Module) || Tuple <- OnLoad]
+        [elixir_tracker:record_local(Tuple, Module) || Tuple <- OnLoad]
     end,
 
-    elixir_locals:warn_unused_local(File, Module, Private),
-    elixir_locals:ensure_no_import_conflict(Line, File, Module, All),
-    elixir_locals:ensure_all_imports_used(Line, File, Module),
+    elixir_tracker:warn_unused_local(File, Module, Private),
+    elixir_tracker:ensure_no_import_conflict(Line, File, Module, All),
+    elixir_tracker:ensure_all_imports_used(Line, File, Module),
 
     elixir_import:ensure_no_local_conflict(Line, File, Module, All),
 
@@ -94,7 +94,7 @@ compile(Line, Module, Block, Vars, #elixir_scope{context_modules=FileModules} =
     Binary = load_form(Line, Final, S),
     { module, Module, Binary, Result }
   after
-    elixir_locals:cleanup(Module),
+    elixir_tracker:cleanup(Module),
     elixir_def:cleanup(Module),
     ets:delete(docs_table(Module)),
     ets:delete(data_table(Module))
@@ -136,7 +136,7 @@ build(Line, File, Module) ->
 
   %% Setup other modules
   elixir_def:setup(Module),
-  elixir_locals:setup(Module).
+  elixir_tracker:setup(Module).
 
 %% Receives the module representation and evaluates it.
 

lib/elixir/src/elixir_partials.erl

@@ -1,3 +1,4 @@
+%% Responsible handling Elixir partials with &1, &2 and so on.
 -module(elixir_partials).
 -export([handle/2, handle/3, is_sequential/1]).
 -include("elixir.hrl").

lib/elixir/src/elixir_quote.erl

@@ -1,3 +1,4 @@
+%% Implements Elixir quote.
 -module(elixir_quote).
 -export([escape/2, erl_escape/3, erl_quote/3, linify/2, unquote/5]).
 -include("elixir.hrl").