Get rid of elixir_locals too

Author: josevalim

lib/elixir/lib/kernel.ex

@@ -3646,7 +3646,7 @@ defmodule Kernel do
             :ok
 
           true ->
-            pos = :elixir_locals.cache_env(__CALLER__)
+            pos = :elixir_module.cache_env(__CALLER__)
             %{line: line, file: file, module: module} = __CALLER__
 
             quote do
@@ -5323,7 +5323,7 @@ defmodule Kernel do
           key
       end
 
-    pos = :elixir_locals.cache_env(env)
+    pos = :elixir_module.cache_env(env)
 
     quote do
       :elixir_def.store_definition(unquote(kind), unquote(store), unquote(pos))

lib/elixir/lib/kernel/cli.ex

@@ -196,7 +196,7 @@ defmodule Kernel.CLI do
   end
 
   @elixir_internals [:elixir, :elixir_aliases, :elixir_expand, :elixir_compiler, :elixir_module] ++
-                      [:elixir_clauses, :elixir_lexical, :elixir_def, :elixir_map, :elixir_locals] ++
+                      [:elixir_clauses, :elixir_lexical, :elixir_def, :elixir_map] ++
                       [:elixir_erl, :elixir_erl_clauses, :elixir_erl_compiler, :elixir_erl_pass] ++
                       [Kernel.ErrorHandler, Module.ParallelChecker]
 

lib/elixir/lib/kernel/typespec.ex

@@ -138,7 +138,7 @@ defmodule Kernel.Typespec do
     case type_to_signature(expr) do
       {name, arity} = signature when signature in @reserved_signatures ->
         compile_error(
-          :elixir_locals.get_cached_env(pos),
+          :elixir_module.get_cached_env(pos),
           "type #{name}/#{arity} is a reserved type and it cannot be defined"
         )
 
@@ -247,7 +247,7 @@ defmodule Kernel.Typespec do
 
   defp collect_defined_type_pairs(type_typespecs) do
     fun = fn {_kind, expr, pos}, type_pairs ->
-      %{file: file, line: line} = env = :elixir_locals.get_cached_env(pos)
+      %{file: file, line: line} = env = :elixir_module.get_cached_env(pos)
 
       case type_to_signature(expr) do
         {name, arity} = type_pair ->
@@ -292,7 +292,7 @@ defmodule Kernel.Typespec do
 
   defp translate_type({kind, {:"::", _, [{name, meta, args}, definition]}, pos}, state)
        when is_list(meta) do
-    caller = :elixir_locals.get_cached_env(pos)
+    caller = :elixir_module.get_cached_env(pos)
     state = clean_local_state(state)
 
     args =
@@ -349,12 +349,12 @@ defmodule Kernel.Typespec do
   defp underspecified?(_kind, _arity, _spec), do: false
 
   defp translate_spec({kind, {:when, _meta, [spec, guard]}, pos}, state) do
-    caller = :elixir_locals.get_cached_env(pos)
+    caller = :elixir_module.get_cached_env(pos)
     translate_spec(kind, spec, guard, caller, state)
   end
 
   defp translate_spec({kind, spec, pos}, state) do
-    caller = :elixir_locals.get_cached_env(pos)
+    caller = :elixir_module.get_cached_env(pos)
     translate_spec(kind, spec, [], caller, state)
   end
 

lib/elixir/src/elixir_bootstrap.erl

@@ -50,7 +50,7 @@ define({Line, _S, #{module := Module} = E}, Kind, Call, Expr) ->
         Key
     end,
 
-  Args = [Kind, Store, elixir_locals:cache_env(E#{line := Line})],
+  Args = [Kind, Store, elixir_module:cache_env(E#{line := Line})],
   {{'.', [], [elixir_def, store_definition]}, [], Args}.
 
 unless_loaded(Fun, Args, Callback) ->

lib/elixir/src/elixir_def.erl

@@ -135,10 +135,10 @@ head_and_definition_meta(_, _Meta, _HeadDefaults, [{_, _, HeadMeta, _} | _]) ->
 %% Section for storing definitions
 
 store_definition(Kind, {Call, Body}, Pos) ->
-  E = elixir_locals:get_cached_env(Pos),
+  E = elixir_module:get_cached_env(Pos),
   store_definition(Kind, false, Call, Body, E);
 store_definition(Kind, Key, Pos) ->
-  #{module := Module} = E = elixir_locals:get_cached_env(Pos),
+  #{module := Module} = E = elixir_module:get_cached_env(Pos),
   {Call, Body} = elixir_module:read_cache(Module, Key),
   store_definition(Kind, true, Call, Body, E).
 

lib/elixir/src/elixir_dispatch.erl

@@ -55,7 +55,7 @@ import_function(Meta, Name, Arity, E) ->
   case find_import_by_name_arity(Meta, Tuple, [], E) of
     {function, Receiver} ->
       elixir_env:trace({imported_function, Meta, Receiver, Name, Arity}, E),
-      elixir_locals:record_import(Tuple, Receiver, ?key(E, module), ?key(E, function)),
+      elixir_import:record(Tuple, Receiver, ?key(E, module), ?key(E, function)),
       remote_function(Meta, Receiver, Name, Arity, E);
     {macro, _Receiver} ->
       false;
@@ -192,13 +192,13 @@ do_expand_import(Result, Meta, Name, Arity, Module, E, Trace) ->
     {function, Receiver} ->
       Trace andalso begin
         elixir_env:trace({imported_function, Meta, Receiver, Name, Arity}, E),
-        elixir_locals:record_import({Name, Arity}, Receiver, Module, ?key(E, function))
+        elixir_import:record({Name, Arity}, Receiver, Module, ?key(E, function))
       end,
       {function, Receiver, Name};
     {macro, Receiver} ->
       Trace andalso begin
         elixir_env:trace({imported_macro, Meta, Receiver, Name, Arity}, E),
-        elixir_locals:record_import({Name, Arity}, Receiver, Module, ?key(E, function))
+        elixir_import:record({Name, Arity}, Receiver, Module, ?key(E, function))
       end,
       {macro, Receiver, expander_macro_named(Meta, Receiver, Name, Arity, E)};
     {import, Receiver} ->

lib/elixir/src/elixir_import.erl

@@ -2,7 +2,9 @@
 %% between local functions and imports.
 %% For imports dispatch, please check elixir_dispatch.
 -module(elixir_import).
--export([import/6, import/7, special_form/2, format_error/1]).
+-export([import/6, import/7, special_form/2,
+         record/4, ensure_no_local_conflict/3,
+         format_error/1]).
 -compile(inline_list_funcs).
 -include("elixir.hrl").
 
@@ -135,6 +137,31 @@ calculate_key(Meta, Key, Old, New, E, Warn) ->
       {true, FinalSet, [{Key, FinalSet} | keydelete(Key, Old)]}
   end.
 
+%% Record function calls for local conflicts
+
+record(_Tuple, Receiver, Module, Function)
+  when Function == nil; Module == Receiver -> false;
+record(Tuple, Receiver, Module, _Function) ->
+  try
+    {Set, _Bag} = elixir_module:data_tables(Module),
+    ets:insert(Set, {{import, Tuple}, Receiver}),
+    true
+  catch
+    error:badarg -> false
+  end.
+
+ensure_no_local_conflict('Elixir.Kernel', _All, _E) ->
+  ok;
+ensure_no_local_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].
+
 %% Retrieve functions and macros from modules
 
 get_functions(Module, InfoCallback) ->
@@ -229,7 +256,11 @@ format_error({special_form_conflict, {Receiver, Name, Arity}}) ->
     [elixir_aliases:inspect(Receiver), Name, Arity]);
 
 format_error({no_macros, Module}) ->
-  io_lib:format("could not load macros from module ~ts", [elixir_aliases:inspect(Module)]).
+  io_lib:format("could not load macros from module ~ts", [elixir_aliases:inspect(Module)]);
+
+format_error({import_conflict, Receiver, {Name, Arity}}) ->
+  io_lib:format("imported ~ts.~ts/~B conflicts with local function",
+    [elixir_aliases:inspect(Receiver), Name, Arity]).
 
 %% LIST HELPERS
 

lib/elixir/src/elixir_locals.erl

@@ -1,9 +1,10 @@
 -module(elixir_module).
 -export([file/1, data_tables/1, is_open/1, mode/1, delete_definition_attributes/6,
          compile/6, expand_callback/6, format_error/1, compiler_modules/0,
-         write_cache/3, read_cache/2, next_counter/1, taint/1]).
+         write_cache/3, read_cache/2, next_counter/1, taint/1, cache_env/1, get_cached_env/1]).
 -include("elixir.hrl").
 -define(counter_attr, {elixir, counter}).
+-define(cache_key, {elixir, cache_env}).
 
 %% Stores modules currently being defined by the compiler
 
@@ -71,6 +72,29 @@ taint(Module) ->
     _:_ -> false
   end.
 
+cache_env(#{line := Line, module := Module} = E) ->
+  {Set, _} = data_tables(Module),
+  Cache = elixir_env:reset_vars(E#{line := nil}),
+  PrevKey = ets:lookup_element(Set, ?cache_key, 2),
+
+  Pos =
+    case ets:lookup(Set, {cache_env, PrevKey}) of
+      [{_, Cache}] ->
+        PrevKey;
+      _ ->
+        NewKey = PrevKey + 1,
+        ets:insert(Set, [{{cache_env, NewKey}, Cache}, {?cache_key, NewKey}]),
+        NewKey
+    end,
+
+  {Module, {Line, Pos}}.
+
+get_cached_env({Module, {Line, Pos}}) ->
+  {Set, _} = data_tables(Module),
+  (ets:lookup_element(Set, {cache_env, Pos}, 2))#{line := Line};
+get_cached_env(Env) ->
+  Env.
+
 %% Compilation hook
 
 compile(Meta, Module, Block, Vars, Prune, Env) ->
@@ -146,7 +170,7 @@ compile(Meta, Module, ModuleAsCharlist, Block, Vars, Prune, E) ->
 
         NifsAttribute = lists:keyfind(nifs, 1, Attributes),
         validate_nifs_attribute(NifsAttribute, AllDefinitions, Line, E),
-        elixir_locals:ensure_no_import_conflict(Module, AllDefinitions, E),
+        elixir_import:ensure_no_local_conflict(Module, AllDefinitions, E),
 
         make_readonly(Module),
 
@@ -330,7 +354,6 @@ build(Module, Line, File, E) ->
   %% * {{type, Tuple}, ...}, {{opaque, Tuple}, ...}
   %% * {{callback, Tuple}, ...}, {{macrocallback, Tuple}, ...}
   %% * {{def, Tuple}, ...} (from elixir_def)
-  %% * {{import, Tuple}, ...} (from elixir_locals)
   %% * {{overridable, Tuple}, ...} (from elixir_overridable)
   %%
   DataSet = ets:new(Module, [set, public]),
@@ -346,8 +369,6 @@ build(Module, Line, File, E) ->
   %% * {overridables, ...} (from elixir_overridable)
   %% * {{default, Name}, ...} (from elixir_def)
   %% * {{clauses, Tuple}, ...} (from elixir_def)
-  %% * {reattach, ...} (from elixir_locals)
-  %% * {{local, Tuple}, ...} (from elixir_locals)
   %%
   DataBag = ets:new(Module, [duplicate_bag, public]),
 
@@ -374,6 +395,7 @@ build(Module, Line, File, E) ->
     {optional_callbacks, [], accumulate, []},
 
     % Others
+    {?cache_key, 0},
     {?counter_attr, 0}
   ]),
 
@@ -390,7 +412,6 @@ build(Module, Line, File, E) ->
   %% Setup definition related modules
   Tables = {DataSet, DataBag},
   elixir_def:setup(Tables),
-  elixir_locals:setup(Tables),
   Tuple = {Module, Tables, Line, File, all},
 
   Ref =