Add Kernel.LexicalTracker

Author: José Valim

lib/elixir/lib/kernel/lexical_tracker.ex

@@ -0,0 +1,161 @@
+defmodule Kernel.LexicalTracker do
+  @timeout  30_000
+  @behavior :gen_server
+
+  @import 2
+  @alias  3
+
+  @doc """
+  Returns all remotes linked to in this lexical scope.
+  """
+  def remotes(pid) do
+    ets = :gen_server.call(to_pid(pid), :ets, @timeout)
+    :ets.match(ets, { :"$1", :_, :_ }) |> List.flatten
+  end
+
+  defp to_pid(pid) when is_pid(pid),  do: pid
+  defp to_pid(mod) when is_atom(mod) do
+    table = :elixir_module.data_table(mod)
+    [{ _, val }] = :ets.lookup(table, :__lexical_tracker)
+    val
+  end
+
+  # Internal API
+
+  # Starts the tracker and returns its pid.
+  @doc false
+  def start_link do
+    { :ok, pid } = :gen_server.start_link(__MODULE__, [], [])
+    pid
+  end
+
+  @doc false
+  def stop(pid) do
+    :gen_server.cast(pid, :stop)
+  end
+
+  @doc false
+  def add_import(pid, module, line, warn) do
+    :gen_server.cast(pid, { :add_import, module, line, warn })
+  end
+
+  @doc false
+  def add_alias(pid, module, line, warn) do
+    :gen_server.cast(pid, { :add_alias, module, line, warn })
+  end
+
+  @doc false
+  def remote_dispatch(pid, module) do
+    :gen_server.cast(pid, { :remote_dispatch, module })
+  end
+
+  @doc false
+  def import_dispatch(pid, module) do
+    :gen_server.cast(pid, { :import_dispatch, module })
+  end
+
+  @doc false
+  def alias_dispatch(pid, module) do
+    :gen_server.cast(pid, { :alias_dispatch, module })
+  end
+
+  @doc false
+  def collect_unused_imports(pid) do
+    unused(pid, @import)
+  end
+
+  @doc false
+  def collect_unused_aliases(pid) do
+    unused(pid, @alias)
+  end
+
+  defp unused(pid, pos) do
+    ets = :gen_server.call(pid, :ets, @timeout)
+    :ets.foldl(fn
+      { module, _, _ } = tuple, acc when is_integer(:erlang.element(pos, tuple)) ->
+        [{ module, :erlang.element(pos, tuple) }|acc]
+      _, acc ->
+        acc
+    end, [], ets) |> Enum.sort
+  end
+
+  # Callbacks
+
+
+  def init([]) do
+    { :ok, :ets.new(:lexical, [:protected]) }
+  end
+
+  def handle_call(:ets, _from, d) do
+    { :reply, d, d }
+  end
+
+  def handle_call(_request, _from, d) do
+    { :noreply, d }
+  end
+
+  def handle_cast({ :remote_dispatch, module }, d) do
+    add_module(d, module)
+    { :noreply, d }
+  end
+
+  def handle_cast({ :import_dispatch, module }, d) do
+    add_dispatch(d, module, @import)
+    { :noreply, d }
+  end
+
+  def handle_cast({ :alias_dispatch, module }, d) do
+    add_dispatch(d, module, @alias)
+    { :noreply, d }
+  end
+
+  def handle_cast({ :add_import, module, line, warn }, d) do
+    add_directive(d, module, line, warn, @import)
+    { :noreply, d }
+  end
+
+  def handle_cast({ :add_alias, module, line, warn }, d) do
+    add_directive(d, module, line, warn, @alias)
+    { :noreply, d }
+  end
+
+  def handle_cast(:stop, d) do
+    { :stop, :normal, d }
+  end
+
+  def handle_cast(_msg, d) do
+    { :noreply, d }
+  end
+
+  def handle_info(_msg, d) do
+    { :noreply, d }
+  end
+
+  def terminate(_reason, _d) do
+    :ok
+  end
+
+  def code_change(_old, d, _extra) do
+    { :ok, d }
+  end
+
+  # Callbacks helpers
+
+  # In the table we keep imports and aliases.
+  # If the value is false, it was not imported/aliased
+  # If the value is true, it was imported/aliased
+  # If the value is a line, it was imported/aliased and has a pending warning
+  defp add_module(d, module) do
+    :ets.insert_new(d, { module, false, false })
+  end
+
+  defp add_dispatch(d, module, pos) do
+    :ets.update_element(d, module, { pos, true })
+  end
+
+  defp add_directive(d, module, line, warn, pos) do
+    add_module(d, module)
+    marker = if warn, do: line, else: true
+    :ets.update_element(d, module, { pos, marker })
+  end
+end

lib/elixir/lib/kernel/parallel_compiler.ex

@@ -113,13 +113,13 @@ defmodule Kernel.ParallelCompiler do
         # list because someone invoked try/rescue UndefinedFunctionError
         new_waiting = List.keydelete(waiting, child, 0)
         spawn_compilers(files, original, output, callbacks, new_waiting, new_queued, schedulers, result)
-      { :module_available, child, file, module, binary } ->
+      { :module_available, child, ref, file, module, binary } ->
         if callback = Keyword.get(callbacks, :each_module) do
           callback.(file, module, binary)
         end
 
         # Release the module loader which is waiting for an ack
-        child <- { self, :ack }
+        child <- { ref, :ack }
 
         new_waiting = release_waiting_processes(module, waiting)
         new_result  = [module|result]

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_tracker.record_alias(receiver, env.module)
+        :elixir_lexical.record_alias(env.file, receiver)
         { 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_tracker.record_alias(receiver, env.module)
+            :elixir_lexical.record_alias(env.file, receiver)
             { receiver, true, cache }
           false -> { original, false, cache }
         end

lib/elixir/lib/module/dispatch_tracker.ex

@@ -5,15 +5,11 @@
 # ## Implementation
 #
 # The implementation uses the digraph module to track
-# all dependencies. The graph starts with three main
-# vertices:
+# all dependencies. The graph starts with one main vertice:
 #
 # * `:local` - points to local functions
-# * `:import` - points to imported modules
-# * `:warn` - points to imported modules that should be warned
-# * `:remote` - points to remote modules
 #
-# Besides those, we have can the following vertices:
+# We also have can the following vertices:
 #
 # * `Module` - a module that was invoked via an import or remotely
 # * `{ name, arity }` - a local function/arity pair
@@ -24,9 +20,7 @@
 # as described below:
 #
 # * `Module`
-#   * in neighbours: `:import`, `:remote`, `:warn`,
-#     `{ :import, name, arity }` and `{ :remote, name arity }`
-#   * out neighbours: `:warn`
+#   * in neighbours:  `{ :import, name, arity }` and `{ :remote, name arity }`
 #
 # * `{ name, arity }`
 #   * in neighbours: `:local`, `{ name, arity }`
@@ -92,15 +86,6 @@ defmodule Module.DispatchTracker do
     :digraph.out_neighbours(d, { name, arity }) |> only_tuples
   end
 
-  @doc """
-  Returns all the modules which were imported.
-  """
-  @spec imports(ref) :: [module]
-  def imports(ref) do
-    d = :gen_server.call(to_pid(ref), :digraph, @timeout)
-    :digraph.out_neighbours(d, :import)
-  end
-
   @doc """
   Returns all imported modules that had the given
   `{ name, arity }` invoked.
@@ -111,24 +96,6 @@ defmodule Module.DispatchTracker do
     :digraph.out_neighbours(d, { :import, name, arity })
   end
 
-  @doc """
-  Returns all the aliases defined in the given module.
-  """
-  @spec aliases(ref) :: [module]
-  def aliases(ref) do
-    d = :gen_server.call(to_pid(ref), :digraph, @timeout)
-    :digraph.out_neighbours(d, :alias)
-  end
-
-  @doc """
-  Returns all the modules which were remotely dispatched to.
-  """
-  @spec remotes(ref) :: [module]
-  def remotes(ref) do
-    d = :gen_server.call(to_pid(ref), :digraph, @timeout)
-    :digraph.out_neighbours(d, :remote)
-  end
-
   @doc """
   Returns all modules that had the given `{ name, arity }`
   invoked remotely.
@@ -206,12 +173,6 @@ defmodule Module.DispatchTracker do
     :gen_server.cast(pid, { :add_local, from, to })
   end
 
-  # Adds an alias.
-  @doc false
-  def add_alias(pid, module) when is_atom(module) do
-    :gen_server.cast(pid, { :add_alias, module })
-  end
-
   # Adds a remote dispatch to the given target.
   @doc false
   def add_remote(pid, function, module, target) when is_atom(module) and is_tuple(target) do
@@ -224,40 +185,14 @@ defmodule Module.DispatchTracker do
     :gen_server.cast(pid, { :add_external, :import, function, module, target })
   end
 
-  # Associates a module with a warn. This adds the given
-  # module and associates it with the `:import` vertex
-  # permanently, even if warn is false.
-  @doc false
-  def add_warnable(pid, module, warn, line) when is_atom(module) and is_boolean(warn) do
-    :gen_server.cast(pid, { :add_warnable, module, warn, line })
-  end
-
-  # Collect all unused imports where warn has been set to true.
-  def collect_unused_imports(pid) do
-    d = :gen_server.call(pid, :digraph, @timeout)
-    warnable = :digraph.out_neighbours(d, :warn)
-
-    lc mod inlist warnable, not has_imports?(d, mod), line = get_warn_line(d, mod) do
-      { mod, line }
-    end
-  end
-
-  defp get_warn_line(d, mod) do
-    [edge] = :digraph.out_edges(d, mod)
-    { ^edge, ^mod, :warn, line } = :digraph.edge(d, edge)
-    line
-  end
-
-  defp has_imports?(d, mod) do
-    Enum.any?(:digraph.in_neighbours(d, mod), &match?({ :import, _, _ }, &1))
-  end
-
   # Yanks a local node. Returns its in and out vertices in a tuple.
   @doc false
   def yank(pid, local) do
     :gen_server.call(to_pid(pid), { :yank, local }, @timeout)
   end
 
+  # Reattach a previously yanked node
+  @doc false
   def reattach(pid, kind, tuple, neighbours) do
     pid = to_pid(pid)
     add_definition(pid, kind, tuple)
@@ -322,10 +257,6 @@ defmodule Module.DispatchTracker do
   def init([]) do
     d = :digraph.new([:protected])
     :digraph.add_vertex(d, :local)
-    :digraph.add_vertex(d, :alias)
-    :digraph.add_vertex(d, :import)
-    :digraph.add_vertex(d, :remote)
-    :digraph.add_vertex(d, :warn)
     { :ok, d }
   end
 
@@ -353,30 +284,11 @@ defmodule Module.DispatchTracker do
     { :noreply, d }
   end
 
-  def handle_cast({ :add_alias, module }, d) do
-    :digraph.add_vertex(d, module)
-    replace_edge!(d, :alias, module)
-    { :noreply, d }
-  end
-
   def handle_cast({ :add_external, kind, function, module, { name, arity } }, d) do
     handle_import_or_remote(d, kind, function, module, name, arity)
     { :noreply, d }
   end
 
-  def handle_cast({ :add_warnable, module, warn, line }, d) do
-    :digraph.add_vertex(d, module)
-    replace_edge!(d, :import, module)
-
-    if warn do
-      :digraph.add_edge(d, :warn, module, line)
-      :digraph.add_edge(d, module, :warn, line)
-    else
-      :digraph.del_path(d, :warn, module)
-    end
-    { :noreply, d }
-  end
-
   def handle_cast({ :add_definition, kind, tuple }, d) do
     handle_add_definition(d, kind, tuple)
     { :noreply, d }
@@ -414,7 +326,6 @@ defmodule Module.DispatchTracker do
 
   defp handle_import_or_remote(d, kind, function, module, name, arity) do
     :digraph.add_vertex(d, module)
-    replace_edge!(d, kind, module)
 
     tuple = { kind, name, arity }
     :digraph.add_vertex(d, tuple)