Remove locals tracker

Author: josevalim

lib/elixir/lib/module/locals_tracker.ex

@@ -190,7 +190,6 @@ bootstrap_files() ->
     [
      <<"list/chars.ex">>,
      <<"bitwise.ex">>,
-     <<"module/locals_tracker.ex">>,
      <<"module/parallel_checker.ex">>,
      <<"module/behaviour.ex">>,
      <<"module/types/helpers.ex">>,

lib/elixir/src/elixir_compiler.erl

@@ -1,63 +1,28 @@
 %% Module responsible for tracking invocations of module calls.
 -module(elixir_locals).
 -export([
-  setup/1, stop/1, cache_env/1, get_cached_env/1,
-  record_local/5, record_import/4, record_defaults/5,
-  yank/2, reattach/6, ensure_no_import_conflict/3,
+  setup/1, cache_env/1, get_cached_env/1,
+  record_import/4,
+  ensure_no_import_conflict/3,
   format_error/1
 ]).
 
 -include("elixir.hrl").
 -define(cache_key, {elixir, cache_env}).
--define(locals_key, {elixir, locals}).
--define(locals, 'Elixir.Module.LocalsTracker').
 
 setup({DataSet, _DataBag}) ->
   ets:insert(DataSet, {?cache_key, 0}),
-
-  case elixir_config:is_bootstrap() of
-    false -> ets:insert(DataSet, {?locals_key, true});
-    true -> ok
-  end,
-
   ok.
 
-stop({DataSet, _DataBag}) ->
-  ets:delete(DataSet, ?locals_key).
-
-yank(Tuple, Module) ->
-  if_tracker(Module, fun(Tracker) -> ?locals:yank(Tracker, Tuple) end).
-
-reattach(Tuple, Kind, Module, Function, Neighbours, Meta) ->
-  if_tracker(Module, fun(Tracker) -> ?locals:reattach(Tracker, Tuple, Kind, Function, Neighbours, Meta) end).
-
-record_local(_Tuple, _Module, nil, _Meta, _IsMacroDispatch) ->
-  ok;
-record_local(Tuple, Module, Function, Meta, IsMacroDispatch) ->
-  if_tracker(Module, fun(Tracker) -> ?locals:add_local(Tracker, Function, Tuple, Meta, IsMacroDispatch), ok end).
-
 record_import(_Tuple, Receiver, Module, Function)
   when Function == nil; Module == Receiver -> false;
-record_import(Tuple, Receiver, Module, Function) ->
-  if_tracker(Module, fun(Tracker) -> ?locals:add_import(Tracker, Function, Receiver, Tuple), ok end).
-
-record_defaults(_Tuple, _Kind, _Module, 0, _Meta) ->
-  ok;
-record_defaults(Tuple, Kind, Module, Defaults, Meta) ->
-  if_tracker(Module, fun(Tracker) -> ?locals:add_defaults(Tracker, Kind, Tuple, Defaults, Meta), ok end).
-
-if_tracker(Module, Callback) ->
-  if_tracker(Module, ok, Callback).
-
-if_tracker(Module, Default, Callback) ->
+record_import(Tuple, Receiver, Module, _Function) ->
   try
-    {DataSet, _} = Tables = elixir_module:data_tables(Module),
-    {ets:member(DataSet, ?locals_key), Tables}
-  of
-    {true, Tracker} -> Callback(Tracker);
-    {false, _} -> Default
+    {Set, _Bag} = elixir_module:data_tables(Module),
+    ets:insert(Set, {{import, Tuple}, Receiver}),
+    true
   catch
-    error:badarg -> Default
+    error:badarg -> false
   end.
 
 %% CACHING
@@ -89,13 +54,16 @@ get_cached_env(Env) ->
 
 ensure_no_import_conflict('Elixir.Kernel', _All, _E) ->
   ok;
-ensure_no_import_conflict(Module, All, E) ->
-  if_tracker(Module, ok, fun(Tracker) ->
-    [elixir_errors:module_error(Meta, E, ?MODULE, {function_conflict, Error})
-     || {Meta, Error} <- ?locals:collect_imports_conflicts(Tracker, All)],
-    ok
-  end).
+ensure_no_import_conflict(Module, AllDefinitions, E) ->
+  {Set, _} = elixir_module:data_tables(Module),
+
+  [try
+     Receiver = ets:lookup_element(Set, {import, Pair}, 2),
+     elixir_errors:module_error(Meta, E, ?MODULE, {import_conflict, Receiver, Pair})
+   catch
+    error:badarg -> false
+   end || {Pair, _, Meta, _} <- AllDefinitions].
 
-format_error({function_conflict, {Receiver, {Name, Arity}}}) ->
+format_error({import_conflict, Receiver, {Name, Arity}}) ->
   io_lib:format("imported ~ts.~ts/~B conflicts with local function",
     [elixir_aliases:inspect(Receiver), Name, Arity]).

lib/elixir/src/elixir_locals.erl

@@ -148,9 +148,6 @@ compile(Meta, Module, ModuleAsCharlist, Block, Vars, Prune, E) ->
         validate_nifs_attribute(NifsAttribute, AllDefinitions, Line, E),
         elixir_locals:ensure_no_import_conflict(Module, AllDefinitions, E),
 
-        %% We stop tracking locals here to avoid race conditions in case after_load
-        %% evaluates code in a separate process that may write to locals table.
-        elixir_locals:stop({DataSet, DataBag}),
         make_readonly(Module),
 
         (not elixir_config:is_bootstrap()) andalso