Move environment cache to locals tracker, which is per module

Author: José Valim

lib/elixir/lib/kernel.ex

@@ -2989,7 +2989,7 @@ defmodule Kernel do
 
     # Do not check clauses if any expression was unquoted
     check_clauses = not(ue or uc)
-    pos = :elixir_env.cache(env)
+    pos = :elixir_locals.cache_env(env)
 
     quote do
       :elixir_def.store_definition(unquote(line), unquote(kind), unquote(check_clauses),

lib/elixir/lib/kernel/lexical_tracker.ex

@@ -83,16 +83,6 @@ defmodule Kernel.LexicalTracker do
     unused(pid, @alias)
   end
 
-  @doc false
-  def cache(pid, env) do
-    :gen_server.call(pid, { :cache, env }, @timeout)
-  end
-
-  @doc false
-  def get_cached(pid, ref) do
-    :gen_server.call(pid, { :get_cached, ref }, @timeout)
-  end
-
   defp unused(pid, pos) do
     ets = :gen_server.call(pid, :ets, @timeout)
     :ets.foldl(fn
@@ -107,75 +97,60 @@ defmodule Kernel.LexicalTracker do
 
 
   def init([]) do
-    { :ok, { :ets.new(:lexical, [:protected]), [] } }
-  end
-
-  def handle_call({ :cache, env }, _from, { d, cache }) do
-    case cache do
-      [{i,^env}|_] ->
-        { :reply, i, { d, cache } }
-      t ->
-        i = length(t)
-        { :reply, i, { d, [{i,env}|t] } }
-    end
-  end
-
-  def handle_call({ :get_cached, ref }, _from, { _, cache } = state) do
-    { ^ref, env } = :lists.keyfind(ref, 1, cache)
-    { :reply, env, state }
+    { :ok, :ets.new(:lexical, [:protected]) }
   end
 
-  def handle_call(:ets, _from, { d, _ } = state) do
-    { :reply, d, state }
+  def handle_call(:ets, _from, d) do
+    { :reply, d, d }
   end
 
-  def handle_call(_request, _from, state) do
-    { :noreply, state }
+  def handle_call(request, _from, d) do
+    { :stop, { :bad_call, request }, d }
   end
 
-  def handle_cast({ :remote_dispatch, module }, { d, _ } = state) do
+  def handle_cast({ :remote_dispatch, module }, d) do
     add_module(d, module)
-    { :noreply, state }
+    { :noreply, d }
   end
 
-  def handle_cast({ :import_dispatch, module }, { d, _ } = state) do
+  def handle_cast({ :import_dispatch, module }, d) do
     add_dispatch(d, module, @import)
-    { :noreply, state }
+    { :noreply, d }
   end
 
-  def handle_cast({ :alias_dispatch, module }, { d, _ } = state) do
+  def handle_cast({ :alias_dispatch, module }, d) do
     add_dispatch(d, module, @alias)
-    { :noreply, state }
+    { :noreply, d }
   end
 
-  def handle_cast({ :add_import, module, line, warn }, { d, _ } = state) do
+  def handle_cast({ :add_import, module, line, warn }, d) do
     add_directive(d, module, line, warn, @import)
-    { :noreply, state }
+    { :noreply, d }
   end
 
-  def handle_cast({ :add_alias, module, line, warn }, { d, _ } = state) do
+  def handle_cast({ :add_alias, module, line, warn }, d) do
     add_directive(d, module, line, warn, @alias)
-    { :noreply, state }
+    { :noreply, d }
   end
 
-  def handle_cast(:stop, state) do
-    { :stop, :normal, state }
+  def handle_cast(:stop, d) do
+    { :stop, :normal, d }
   end
 
-  def handle_cast(_msg, state) do
-    { :noreply, state }
+  def handle_cast(msg, d) do
+    { :stop, { :bad_cast, msg }, d }
   end
 
-  def handle_info(_msg, state) do
-    { :noreply, state }
+  def handle_info(_msg, d) do
+    { :noreply, d }
   end
 
-  def terminate(_reason, _state) do
+  def terminate(_reason, _d) do
     :ok
   end
 
-  def code_change(_old, state, _extra) do
-    { :ok, state }
+  def code_change(_old, d, _extra) do
+    { :ok, d }
   end
 
   # Callbacks helpers

lib/elixir/lib/module/locals_tracker.ex

@@ -186,6 +186,16 @@ defmodule Module.LocalsTracker do
     end
   end
 
+  @doc false
+  def cache_env(pid, env) do
+    :gen_server.call(pid, { :cache_env, env }, @timeout)
+  end
+
+  @doc false
+  def get_cached_env(pid, ref) do
+    :gen_server.call(pid, { :get_cached_env, ref }, @timeout)
+  end
+
   # Stops the gen server
   @doc false
   def stop(pid) do
@@ -197,71 +207,86 @@ defmodule Module.LocalsTracker do
   def init([]) do
     d = :digraph.new([:protected])
     :digraph.add_vertex(d, :local)
-    { :ok, d }
+    { :ok, { d, [] } }
+  end
+
+  def handle_call({ :cache_env, env }, _from, { d, cache }) do
+    case cache do
+      [{i,^env}|_] ->
+        { :reply, i, { d, cache } }
+      t ->
+        i = length(t)
+        { :reply, i, { d, [{i,env}|t] } }
+    end
+  end
+
+  def handle_call({ :get_cached_env, ref }, _from, { _, cache } = state) do
+    { ^ref, env } = :lists.keyfind(ref, 1, cache)
+    { :reply, env, state }
   end
 
-  def handle_call({ :yank, local }, _from, d) do
+  def handle_call({ :yank, local }, _from, { d, _ } = state) do
     in_vertices  = :digraph.in_neighbours(d, local)
     out_vertices = :digraph.out_neighbours(d, local)
     :digraph.del_vertex(d, local)
-    { :reply, { in_vertices, out_vertices }, d }
+    { :reply, { in_vertices, out_vertices }, state }
   end
 
-  def handle_call(:digraph, _from, d) do
-    { :reply, d, d }
+  def handle_call(:digraph, _from, { d, _ } = state) do
+    { :reply, d, state }
   end
 
-  def handle_call(_request, _from, d) do
-    { :noreply, d }
+  def handle_call(request, _from, state) do
+    { :stop, { :bad_call, request }, state }
   end
 
-  def handle_info(_msg, d) do
-    { :noreply, d }
+  def handle_info(_msg, state) do
+    { :noreply, state }
   end
 
-  def handle_cast({ :add_local, from, to }, d) do
+  def handle_cast({ :add_local, from, to }, { d, _ } = state) do
     handle_add_local(d, from, to)
-    { :noreply, d }
+    { :noreply, state }
   end
 
-  def handle_cast({ :add_import, function, module, { name, arity } }, d) do
+  def handle_cast({ :add_import, function, module, { name, arity } }, { d, _ } = state) do
     handle_import(d, function, module, name, arity)
-    { :noreply, d }
+    { :noreply, state }
   end
 
-  def handle_cast({ :add_definition, kind, tuple }, d) do
+  def handle_cast({ :add_definition, kind, tuple }, { d, _ } = state) do
     handle_add_definition(d, kind, tuple)
-    { :noreply, d }
+    { :noreply, state }
   end
 
-  def handle_cast({ :add_defaults, kind, { name, arity }, defaults }, d) do
+  def handle_cast({ :add_defaults, kind, { name, arity }, defaults }, { d, _ } = state) do
     lc i inlist :lists.seq(arity - defaults, arity - 1) do
       handle_add_definition(d, kind, { name, i })
       handle_add_local(d, { name, i }, { name, i + 1 })
     end
-    { :noreply, d }
+    { :noreply, state }
   end
 
-  def handle_cast({ :reattach, tuple, { in_neigh, out_neigh } }, d) do
+  def handle_cast({ :reattach, tuple, { in_neigh, out_neigh } }, { d, _ } = state) do
     lc from inlist in_neigh, do: replace_edge(d, from, tuple)
     lc to inlist out_neigh,  do: replace_edge(d, tuple, to)
-    { :noreply, d }
+    { :noreply, state }
   end
 
-  def handle_cast(:stop, d) do
-    { :stop, :normal, d }
+  def handle_cast(:stop, state) do
+    { :stop, :normal, state }
   end
 
-  def handle_cast(_msg, d) do
-    { :noreply, d }
+  def handle_cast(msg, state) do
+    { :stop, { :bad_cast, msg }, state }
   end
 
-  def terminate(_reason, _d) do
+  def terminate(_reason, _state) do
     :ok
   end
 
-  def code_change(_old, d, _extra) do
-    { :ok, d }
+  def code_change(_old, state, _extra) do
+    { :ok, state }
   end
 
   defp handle_import(d, function, module, name, arity) do

lib/elixir/src/elixir_bootstrap.erl

@@ -38,7 +38,7 @@
 define({Line,E}, Kind, Call, Expr) ->
   { EscapedCall, UC } = elixir_quote:escape(Call, true),
   { EscapedExpr, UE } = elixir_quote:escape(Expr, true),
-  Args = [Line, Kind, not(UC or UE), EscapedCall, EscapedExpr, elixir_env:cache(E)],
+  Args = [Line, Kind, not(UC or UE), EscapedCall, EscapedExpr, elixir_locals:cache_env(E)],
   { { '.', [], [elixir_def, store_definition] }, [], Args }.
 
 unless_loaded(Fun, Args, Callback) ->

lib/elixir/src/elixir_compiler.erl

@@ -200,6 +200,7 @@ core_main() ->
     <<"lib/elixir/lib/macro/env.ex">>,
     <<"lib/elixir/lib/exception.ex">>,
     <<"lib/elixir/lib/code.ex">>,
+    <<"lib/elixir/lib/module/locals_tracker.ex">>,
     <<"lib/elixir/lib/protocol.ex">>,
     <<"lib/elixir/lib/stream/reducers.ex">>,
     <<"lib/elixir/lib/enum.ex">>,
@@ -217,8 +218,7 @@ core_main() ->
     <<"lib/elixir/lib/kernel/error_handler.ex">>,
     <<"lib/elixir/lib/kernel/parallel_compiler.ex">>,
     <<"lib/elixir/lib/kernel/record_rewriter.ex">>,
-    <<"lib/elixir/lib/kernel/lexical_tracker.ex">>,
-    <<"lib/elixir/lib/module/locals_tracker.ex">>
+    <<"lib/elixir/lib/kernel/lexical_tracker.ex">>
   ].
 
 binary_to_path({ModuleName, Binary}, CompilePath) ->

lib/elixir/src/elixir_def.erl

@@ -49,7 +49,7 @@ delete_definition(Module, Tuple) ->
 % Each function is then added to the function table.
 
 store_definition(Line, Kind, CheckClauses, Call, Body, Pos) ->
-  E = (elixir_env:get_cached(Pos))#elixir_env{line=Line},
+  E = (elixir_locals:get_cached_env(Pos))#elixir_env{line=Line},
   { NameAndArgs, Guards } = elixir_clauses:extract_guards(Call),
 
   { Name, Args } = case NameAndArgs of

lib/elixir/src/elixir_env.erl

@@ -1,9 +1,7 @@
 -module(elixir_env).
 -include("elixir.hrl").
 -export([ex_to_env/1, env_to_scope/1, env_to_scope_with_vars/2, env_to_ex/1]).
--export([cache/1, get_cached/1]).
 -export([mergea/2, mergev/2]).
--define(tracker, 'Elixir.Kernel.LexicalTracker').
 
 %% Conversion in between #elixir_env, #elixir_scope and Macro.Env
 
@@ -38,20 +36,3 @@ mergev(E1, E2) ->
 
 mergea(E1, E2) ->
   E2#elixir_env{vars=E1#elixir_env.vars}.
-
-%% Caching
-
-cache(#elixir_env{} = RE) ->
-  E = RE#elixir_env{line=nil,vars=[]},
-  case E#elixir_env.lexical_tracker of
-    nil -> escape(E);
-    Pid -> { Pid, ?tracker:cache(Pid, E) }
-  end;
-cache(ExEnv) ->
-  cache(ex_to_env(ExEnv)).
-
-get_cached({Pid,Ref}) -> ?tracker:get_cached(Pid, Ref);
-get_cached(Env) -> Env.
-
-escape(E) ->
-  { Escaped, _ } = elixir_quote:escape(E, false), Escaped.

lib/elixir/src/elixir_locals.erl

@@ -1,7 +1,7 @@
 %% Module responsible for tracking invocations of module calls.
 -module(elixir_locals).
 -export([
-  setup/1, cleanup/1,
+  setup/1, cleanup/1, cache_env/1, get_cached_env/1,
   record_local/2, record_local/3, record_import/4,
   record_definition/3, record_defaults/4,
   ensure_no_function_conflict/4, warn_unused_local/3, format_error/1
@@ -123,6 +123,24 @@ if_tracker(Module, Callback) ->
     error:badarg -> false
   end.
 
+%% CACHING
+
+cache_env(#elixir_env{module=Module} = RE) ->
+  E = RE#elixir_env{line=nil,vars=[]},
+  try ets:lookup_element(Module, ?attr, 2) of
+    Pid ->
+      { Pid, ?tracker:cache_env(Pid, E) }
+  catch
+    error:badarg ->
+      { Escaped, _ } = elixir_quote:escape(E, false),
+      Escaped
+  end;
+cache_env(ExEnv) ->
+  cache_env(elixir_env:ex_to_env(ExEnv)).
+
+get_cached_env({Pid,Ref}) -> ?tracker:get_cached_env(Pid, Ref);
+get_cached_env(Env) -> Env.
+
 %% ERROR HANDLING
 
 ensure_no_function_conflict(Meta, File, Module, AllDefined) ->