Move lexical tracker to scope

Author: José Valim

lib/elixir/include/elixir.hrl

@@ -26,6 +26,7 @@
   context_modules=[],      %% modules defined in the current context
   macro_aliases=[],        %% keep aliases defined inside a macro
   macro_counter=0,         %% macros expansions counter
+  lexical_tracker=nil,     %% holds the lexical tracker pid
   aliases,                 %% an orddict with aliases by new -> old names
   file,                    %% the current scope filename
   requires,                %% a set with modules required

lib/elixir/lib/macro.ex

@@ -536,15 +536,15 @@ defmodule Macro do
   defp expand_once({ :__aliases__, _, _ } = original, env, cache) do
     case :elixir_aliases.expand(original, env.aliases, env.macro_aliases) do
       receiver when is_atom(receiver) ->
-        :elixir_lexical.record_alias(env.file, receiver)
+        :elixir_lexical.record_alias(receiver, env.lexical_tracker)
         { receiver, true, cache }
       aliases ->
         aliases = lc alias inlist aliases, do: elem(expand_once(alias, env, cache), 0)
 
         case :lists.all(&is_atom/1, aliases) do
           true ->
             receiver = :elixir_aliases.concat(aliases)
-            :elixir_lexical.record_alias(env.file, receiver)
+            :elixir_lexical.record_alias(receiver, env.lexical_tracker)
             { receiver, true, cache }
           false -> { original, false, cache }
         end

lib/elixir/lib/macro/env.ex

@@ -34,14 +34,15 @@ defmodule Macro.Env do
   @type macros :: [{ module, [name_arity] }]
   @type context_modules :: [module]
   @type vars :: [{ atom, atom }]
+  @type lexical_tracker :: pid
 
-  fields = [:module, :file, :line, :function, :aliases, :context, :requires,
-            :functions, :macros, :context_modules, :macro_aliases, :vars]
+  fields = [:module, :file, :line, :function, :aliases, :context, :requires, :functions,
+            :macros, :context_modules, :macro_aliases, :vars, :lexical_tracker]
 
   types  = quote do: [module: module, file: file, line: line,
     function: name_arity, aliases: aliases, requires: requires,
     functions: functions, macros: macros, context_modules: context_modules,
-    macro_aliases: aliases, vars: vars]
+    macro_aliases: aliases, vars: vars, lexical_tracker: lexical_tracker]
 
   Record.deffunctions(fields, __MODULE__)
   Record.deftypes(fields, types, __MODULE__)

lib/elixir/src/elixir_code_server.erl

@@ -10,8 +10,7 @@
   at_exit=[],
   pool={[],0},
   compiler_options=[{docs,true},{debug_info,true},{warnings_as_errors,false}],
-  erl_compiler_options=nil,
-  lexical=[]
+  erl_compiler_options=nil
 }).
 
 call(Args) ->
@@ -81,9 +80,6 @@ handle_call(erl_compiler_options, _From, Config) ->
       { reply, Opts, Config }
   end;
 
-handle_call({ lexical, File }, _From, #elixir_code_server{lexical=Lexical} = Config) ->
-  { reply, orddict:find(File, Lexical), Config };
-
 handle_call(_Request, _From, Config) ->
   { reply, undef, Config }.
 
@@ -128,12 +124,6 @@ handle_cast({ unload_files, Files }, Config) ->
 handle_cast({ return_module_name, H }, #elixir_code_server{pool={T,Counter}} = Config) ->
   { noreply, Config#elixir_code_server{pool={[H|T],Counter}} };
 
-handle_cast({ register_lexical, File, Pid }, #elixir_code_server{lexical=Lexical} = Config) ->
-  { noreply, Config#elixir_code_server{lexical=orddict:store(File, Pid, Lexical)} };
-
-handle_cast({ unregister_lexical, File }, #elixir_code_server{lexical=Lexical} = Config) ->
-  { noreply, Config#elixir_code_server{lexical=orddict:erase(File, Lexical)} };
-
 handle_cast(_Request, Config) ->
   { noreply, Config }.
 

lib/elixir/src/elixir_compiler.erl

@@ -30,7 +30,9 @@ quoted(Forms, File) when is_binary(File) ->
   try
     put(elixir_compiled, []),
     elixir_lexical:run(File, fun
-      () -> eval_forms(Forms, 1, [], elixir:scope_for_eval([{file,File}]))
+      (Pid) ->
+        Scope = elixir:scope_for_eval([{file,File}]),
+        eval_forms(Forms, 1, [], Scope#elixir_scope{lexical_tracker=Pid})
     end),
     lists:reverse(get(elixir_compiled))
   after

lib/elixir/src/elixir_dispatch.erl

@@ -24,11 +24,11 @@ find_import(Meta, Name, Arity, S) ->
 
   case find_dispatch(Meta, Tuple, S) of
     { function, Receiver } ->
-      elixir_lexical:record_import(S#elixir_scope.file, Receiver),
+      elixir_lexical:record_import(Receiver, S#elixir_scope.lexical_tracker),
       elixir_tracker:record_import(Tuple, Receiver, S#elixir_scope.module, S#elixir_scope.function),
       Receiver;
     { macro, Receiver } ->
-      elixir_lexical:record_import(S#elixir_scope.file, Receiver),
+      elixir_lexical:record_import(Receiver, S#elixir_scope.lexical_tracker),
       elixir_tracker:record_import(Tuple, Receiver, S#elixir_scope.module, S#elixir_scope.function),
       Receiver;
     _ ->
@@ -41,7 +41,7 @@ import_function(Meta, Name, Arity, S) ->
   Tuple = { Name, Arity },
   case find_dispatch(Meta, Tuple, S) of
     { function, Receiver } ->
-      elixir_lexical:record_import(S#elixir_scope.file, Receiver),
+      elixir_lexical:record_import(Receiver, S#elixir_scope.lexical_tracker),
       elixir_tracker:record_import(Tuple, Receiver, S#elixir_scope.module, S#elixir_scope.function),
       remote_function(Meta, Receiver, Name, Arity, S);
     { macro, _Receiver } ->
@@ -63,7 +63,7 @@ require_function(Meta, Receiver, Name, Arity, S) ->
   case is_element(Tuple, get_optional_macros(Receiver)) of
     true  -> false;
     false ->
-      elixir_lexical:record_remote(S#elixir_scope.file, Receiver),
+      elixir_lexical:record_remote(Receiver, S#elixir_scope.lexical_tracker),
       elixir_tracker:record_remote(Tuple, Receiver, S#elixir_scope.module, S#elixir_scope.function),
       remote_function(Meta, Receiver, Name, Arity, S)
   end.
@@ -77,23 +77,23 @@ dispatch_import(Meta, Name, Args, S, Callback) ->
 
   case find_dispatch(Meta, Tuple, S) of
     { function, Receiver } ->
-      elixir_lexical:record_import(S#elixir_scope.file, Receiver),
+      elixir_lexical:record_import(Receiver, S#elixir_scope.lexical_tracker),
       elixir_tracker:record_import(Tuple, Receiver, Module, S#elixir_scope.function),
       Endpoint = case (Receiver == ?builtin) andalso is_element(Tuple, in_erlang_functions()) of
         true  -> erlang;
         false -> Receiver
       end,
       elixir_translator:translate_each({ { '.', Meta, [Endpoint, Name] }, Meta, Args }, S);
     { import, Receiver } ->
-      elixir_lexical:record_remote(S#elixir_scope.file, Receiver),
+      elixir_lexical:record_remote(Receiver, S#elixir_scope.lexical_tracker),
       elixir_tracker:record_remote(Tuple, Receiver, S#elixir_scope.module, S#elixir_scope.function),
       elixir_translator:translate_each({ { '.', Meta, [Receiver, Name] }, [{require,false}|Meta], Args }, S);
     Result ->
       case do_expand_import(Meta, Tuple, Args, Module, S, Result) of
         { error, noexpansion } ->
           Callback();
         { error, internal } ->
-          elixir_lexical:record_import(S#elixir_scope.file, ?builtin),
+          elixir_lexical:record_import(?builtin, S#elixir_scope.lexical_tracker),
           elixir_tracker:record_import(Tuple, ?builtin, Module, S#elixir_scope.function),
           elixir_macros:translate({ Name, Meta, Args }, S);
         { ok, Receiver, Tree } ->
@@ -108,7 +108,7 @@ dispatch_require(Meta, Receiver, Name, Args, S, Callback) ->
 
   case (Receiver == ?builtin) andalso is_element(Tuple, in_erlang_functions()) of
     true ->
-      elixir_lexical:record_remote(S#elixir_scope.file, Receiver),
+      elixir_lexical:record_remote(Receiver, S#elixir_scope.lexical_tracker),
       elixir_tracker:record_remote(Tuple, Receiver, S#elixir_scope.module, S#elixir_scope.function),
       { TArgs, SA } = elixir_translator:translate_args(Args, S),
       { ?wrap_call(?line(Meta), erlang, Name, TArgs), SA };
@@ -117,7 +117,7 @@ dispatch_require(Meta, Receiver, Name, Args, S, Callback) ->
         { error, noexpansion } ->
           Callback();
         { error, internal } ->
-          elixir_lexical:record_remote(S#elixir_scope.file, ?builtin),
+          elixir_lexical:record_remote(?builtin, S#elixir_scope.lexical_tracker),
           elixir_tracker:record_remote(Tuple, ?builtin, S#elixir_scope.module, S#elixir_scope.function),
           elixir_macros:translate({ Name, Meta, Args }, S);
         { ok, Receiver, Tree } ->
@@ -159,12 +159,12 @@ do_expand_import_no_local(Meta, { Name, Arity } = Tuple, Args, Module, S, Result
       case is_element(Tuple, in_erlang_macros()) of
         true  -> { error, internal };
         false ->
-          elixir_lexical:record_import(S#elixir_scope.file, ?builtin),
+          elixir_lexical:record_import(?builtin, S#elixir_scope.lexical_tracker),
           elixir_tracker:record_import(Tuple, ?builtin, Module, S#elixir_scope.function),
           { ok, ?builtin, expand_macro_named(Meta, ?builtin, Name, Arity, Args, Module, S) }
       end;
     { macro, Receiver } ->
-      elixir_lexical:record_import(S#elixir_scope.file, Receiver),
+      elixir_lexical:record_import(Receiver, S#elixir_scope.lexical_tracker),
       elixir_tracker:record_import(Tuple, Receiver, Module, S#elixir_scope.function),
       { ok, Receiver, expand_macro_named(Meta, Receiver, Name, Arity, Args, Module, S) };
     { import, Receiver } ->
@@ -179,7 +179,7 @@ expand_require(Meta, ?builtin, { Name, Arity } = Tuple, Args, Module, S) ->
     false ->
       case is_element(Tuple, in_elixir_macros()) of
         true  ->
-          elixir_lexical:record_remote(S#elixir_scope.file, ?builtin),
+          elixir_lexical:record_remote(?builtin, S#elixir_scope.lexical_tracker),
           elixir_tracker:record_remote(Tuple, ?builtin, S#elixir_scope.module, S#elixir_scope.function),
           { ok, ?builtin, expand_macro_named(Meta, ?builtin, Name, Arity, Args, Module, S) };
         false ->
@@ -197,7 +197,7 @@ expand_require(Meta, Receiver, { Name, Arity } = Tuple, Args, Module, S) ->
     false ->
       case is_element(Tuple, get_optional_macros(Receiver)) of
         true  ->
-          elixir_lexical:record_remote(S#elixir_scope.file, Receiver),
+          elixir_lexical:record_remote(Receiver, S#elixir_scope.lexical_tracker),
           elixir_tracker:record_remote(Tuple, Receiver, Module, Function),
           { ok, Receiver, expand_macro_named(Meta, Receiver, Name, Arity, Args, Module, S) };
         false -> { error, noexpansion }

lib/elixir/src/elixir_import.erl

@@ -38,14 +38,14 @@ import_macros(Force, Meta, Ref, Opts, S) ->
     S#elixir_scope.macro_macros, Existing, S),
   S#elixir_scope{macros=Macros, macro_macros=Temp}.
 
-record_warn(Meta, Ref, Opts, #elixir_scope{file=File}) ->
+record_warn(Meta, Ref, Opts, S) ->
   Warn =
     case keyfind(warn, Opts) of
       { warn, false } -> false;
       { warn, true } -> true;
       false -> not lists:keymember(context, 1, Meta)
     end,
-  elixir_lexical:record_import(File, Ref, ?line(Meta), Warn).
+  elixir_lexical:record_import(Ref, ?line(Meta), Warn, S#elixir_scope.lexical_tracker).
 
 %% Calculates the imports based on only and except
 

lib/elixir/src/elixir_lexical.erl

@@ -1,6 +1,6 @@
 %% Module responsible for tracking lexical information.
 -module(elixir_lexical).
--export([run/2, pid/1,
+-export([run/2,
   record_alias/4, record_alias/2,
   record_import/4, record_import/2,
   record_remote/2, format_error/1
@@ -9,70 +9,57 @@
 
 -define(tracker, 'Elixir.Kernel.LexicalTracker').
 
-pid(File) ->
-  if_tracker(File, fun(Pid) -> Pid end).
-
-%% TODO: This only works if the file is not duplicated.
-%% We need to store the PID in the lexical scope.
 run(File, Callback) ->
   case code:is_loaded(?tracker) of
     { file, _ } ->
       Pid = ?tracker:start_link(),
-      elixir_code_server:cast({ register_lexical, File, Pid }),
+
       try
-        Callback()
+        Callback(Pid)
       after
-        %% Emit the warnings
         warn_unused_imports(File, Pid),
-
-        %% Unlink and turn off tracker
-        unlink(Pid),
-        ?tracker:stop(Pid),
-        elixir_code_server:cast({ unregister_lexical, File })
+        unlink(Pid), ?tracker:stop(Pid)
       end;
     false ->
-      Callback()
+      Callback(nil)
   end.
 
 %% RECORD
 
-record_alias(File, Module, Line, Warn) ->
-  if_tracker(File, fun(Pid) ->
+record_alias(Module, Line, Warn, Ref) ->
+  if_tracker(Ref, fun(Pid) ->
     ?tracker:add_alias(Pid, Module, Line, Warn),
     true
   end).
 
-record_import(File, Module, Line, Warn) ->
-  if_tracker(File, fun(Pid) ->
+record_import(Module, Line, Warn, Ref) ->
+  if_tracker(Ref, fun(Pid) ->
     ?tracker:add_import(Pid, Module, Line, Warn),
     true
   end).
 
-record_alias(File, Module) ->
-  if_tracker(File, fun(Pid) ->
+record_alias(Module, Ref) ->
+  if_tracker(Ref, fun(Pid) ->
     ?tracker:alias_dispatch(Pid, Module),
     true
   end).
 
-record_import(File, Module) ->
-  if_tracker(File, fun(Pid) ->
+record_import(Module, Ref) ->
+  if_tracker(Ref, fun(Pid) ->
     ?tracker:import_dispatch(Pid, Module),
     true
   end).
 
-record_remote(File, Module) ->
-  if_tracker(File, fun(Pid) ->
+record_remote(Module, Ref) ->
+  if_tracker(Ref, fun(Pid) ->
     ?tracker:remote_dispatch(Pid, Module),
     true
   end).
 
 %% HELPERS
 
-if_tracker(File, Callback) ->
-  case elixir_code_server:call({ lexical, File }) of
-    { ok, Pid } -> Callback(Pid);
-    error -> false
-  end.
+if_tracker(nil, _Callback) -> false;
+if_tracker(Pid, Callback) when is_pid(Pid) -> Callback(Pid).
 
 %% ERROR HANDLING
 

lib/elixir/src/elixir_module.erl

@@ -63,7 +63,7 @@ compile(Line, Module, Block, Vars, #elixir_scope{context_modules=FileModules} =
   FileList = elixir_utils:characters_to_list(File),
 
   check_module_availability(Line, File, Module, C),
-  build(Line, File, Module),
+  build(Line, File, Module, S#elixir_scope.lexical_tracker),
 
   try
     Result = eval_form(Line, Module, Block, Vars, S),
@@ -110,7 +110,7 @@ compile(Line, Module, Block, Vars, RawS) ->
 
 %% Hook that builds both attribute and functions and set up common hooks.
 
-build(Line, File, Module) ->
+build(Line, File, Module, Lexical) ->
   %% Table with meta information about the module.
   DataTable = data_table(Module),
 
@@ -132,7 +132,7 @@ build(Line, File, Module) ->
   ets:insert(DataTable, { ?acc_attr, [before_compile, after_compile, on_definition|Attributes] }),
   ets:insert(DataTable, { ?persisted_attr, [vsn|Attributes] }),
   ets:insert(DataTable, { ?docs_attr, ets:new(DataTable, [ordered_set, public]) }),
-  ets:insert(DataTable, { ?lexical_attr, elixir_lexical:pid(File) }),
+  ets:insert(DataTable, { ?lexical_attr, Lexical }),
   ets:insert(DataTable, { ?overridable_attr, [] }),
 
   %% Setup other modules