Module.DispatchTracker also records remotes

Author: José Valim

lib/elixir/lib/module/dispatch_tracker.ex

@@ -51,8 +51,9 @@ defmodule Module.DispatchTracker do
   # Public API
 
   @doc """
-  Returns all the modules which were imported and
-  made a call to.
+  Returns all the modules which were imported.
+  All external dependencies to a module is the sum
+  of imports and remotes.
   """
   def imports(pid) do
     d = :gen_server.call(to_pid(pid), :digraph, @timeout)
@@ -61,13 +62,32 @@ defmodule Module.DispatchTracker do
 
   @doc """
   Returns all imported modules that had the given
-  { name, arity } invoked.
+  `{ name, arity }` invoked.
   """
   def imports_with_dispatch(pid, { name, arity }) do
     d = :gen_server.call(to_pid(pid), :digraph, @timeout)
     :digraph.out_neighbours(d, { :import, name, arity })
   end
 
+  @doc """
+  Returns all the modules which were remotely dispatched
+  to. All external dependencies to a module is the sum
+  of imports and remotes.
+  """
+  def remotes(pid) do
+    d = :gen_server.call(to_pid(pid), :digraph, @timeout)
+    :digraph.out_neighbours(d, :remote)
+  end
+
+  @doc """
+  Returns all modules that had the given `{ name, arity }`
+  invoked remotely.
+  """
+  def remotes_with_dispatch(pid, { name, arity }) do
+    d = :gen_server.call(to_pid(pid), :digraph, @timeout)
+    :digraph.out_neighbours(d, { :remote, name, arity })
+  end
+
   @doc """
   Returns all locals that are reachable.
 
@@ -119,6 +139,12 @@ defmodule Module.DispatchTracker do
     :gen_server.cast(pid, { :add_local, from, to })
   end
 
+  # Adds a remote dispatch to the given target.
+  @doc false
+  def add_remote(pid, module, target) when is_atom(module) and is_tuple(target) do
+    :gen_server.cast(pid, { :add_remote, module, target })
+  end
+
   # Adds a import dispatch to the given target.
   @doc false
   def add_import(pid, module, target) when is_atom(module) and is_tuple(target) do
@@ -224,6 +250,7 @@ defmodule Module.DispatchTracker do
     d = :digraph.new([:protected])
     :digraph.add_vertex(d, :local)
     :digraph.add_vertex(d, :import)
+    :digraph.add_vertex(d, :remote)
     :digraph.add_vertex(d, :warn)
     { :ok, d }
   end
@@ -253,14 +280,13 @@ defmodule Module.DispatchTracker do
     { :noreply, d }
   end
 
-  def handle_cast({ :add_import, module, { name, arity } }, d) do
-    :digraph.add_vertex(d, module)
-    replace_edge!(d, :import, module)
-
-    tuple = { :import, name, arity }
-    :digraph.add_vertex(d, tuple)
-    replace_edge!(d, tuple, module)
+  def handle_cast({ :add_remote, module, { name, arity } }, d) do
+    record_import_or_remote(d, :remote, module, name, arity)
+    { :noreply, d }
+  end
 
+  def handle_cast({ :add_import, module, { name, arity } }, d) do
+    record_import_or_remote(d, :import, module, name, arity)
     { :noreply, d }
   end
 
@@ -310,6 +336,15 @@ defmodule Module.DispatchTracker do
     { :ok, d }
   end
 
+  defp record_import_or_remote(d, kind, module, name, arity) do
+    :digraph.add_vertex(d, module)
+    replace_edge!(d, kind, module)
+
+    tuple = { kind, name, arity }
+    :digraph.add_vertex(d, tuple)
+    replace_edge!(d, tuple, module)
+  end
+
   defp replace_edge!(d, from, to) do
     unless :lists.member(to, :digraph.out_neighbours(d, from)) do
       [:"$e"|_] = :digraph.add_edge(d, from, to)

lib/elixir/src/elixir_dispatch.erl

@@ -50,7 +50,9 @@ require_function(Meta, Receiver, Name, Arity, S) ->
 
   case is_element(Tuple, get_optional_macros(Receiver)) of
     true  -> false;
-    false -> remote_function(Meta, Receiver, Name, Arity, S)
+    false ->
+      elixir_tracker:record_remote(Tuple, Receiver, S#elixir_scope.module),
+      remote_function(Meta, Receiver, Name, Arity, S)
   end.
 
 %% Function dispatch
@@ -69,6 +71,7 @@ dispatch_import(Meta, Name, Args, S, Callback) ->
       end,
       elixir_translator:translate_each({ { '.', Meta, [Endpoint, Name] }, Meta, Args }, S);
     { import, Receiver } ->
+      elixir_tracker:record_remote(Tuple, Receiver, S#elixir_scope.module),
       elixir_translator:translate_each({ { '.', Meta, [Receiver, Name] }, [{require,false}|Meta], Args }, S);
     Result ->
       case do_expand_import(Meta, Tuple, Args, Module, S, Result) of
@@ -89,13 +92,15 @@ dispatch_require(Meta, Receiver, Name, Args, S, Callback) ->
 
   case (Receiver == ?builtin) andalso is_element(Tuple, in_erlang_functions()) of
     true ->
+      elixir_tracker:record_remote(Tuple, Receiver, S#elixir_scope.module),
       { TArgs, SA } = elixir_translator:translate_args(Args, S),
       { ?wrap_call(?line(Meta), erlang, Name, TArgs), SA };
     false ->
       case expand_require(Meta, Receiver, Tuple, Args, Module, S) of
         { error, noexpansion } ->
           Callback();
         { error, internal } ->
+          elixir_tracker:record_remote(Tuple, ?builtin, S#elixir_scope.module),
           elixir_macros:translate({ Name, Meta, Args }, S);
         { ok, _Receiver, Tree } ->
           translate_expansion(Meta, Tree, S)
@@ -137,8 +142,11 @@ expand_require(Meta, ?builtin, { Name, Arity } = Tuple, Args, Module, S) ->
     true  -> { error, internal };
     false ->
       case is_element(Tuple, in_elixir_macros()) of
-        true  -> { ok, ?builtin, expand_macro_named(Meta, ?builtin, Name, Arity, Args, Module, S) };
-        false -> { error, noexpansion }
+        true  ->
+          elixir_tracker:record_remote(Tuple, ?builtin, S#elixir_scope.module),
+          { ok, ?builtin, expand_macro_named(Meta, ?builtin, Name, Arity, Args, Module, S) };
+        false ->
+          { error, noexpansion }
       end
   end;
 
@@ -149,7 +157,9 @@ expand_require(Meta, Receiver, { Name, Arity } = Tuple, Args, Module, S) ->
   case Fun of
     false ->
       case is_element(Tuple, get_optional_macros(Receiver)) of
-        true  -> { ok, Receiver, expand_macro_named(Meta, Receiver, Name, Arity, Args, Module, S) };
+        true  ->
+          elixir_tracker:record_remote(Tuple, Receiver, S#elixir_scope.module),
+          { ok, Receiver, expand_macro_named(Meta, Receiver, Name, Arity, Args, Module, S) };
         false -> { error, noexpansion }
       end;
     _ ->

lib/elixir/src/elixir_tracker.erl

@@ -3,7 +3,7 @@
 -module(elixir_tracker).
 -export([
   setup/1, cleanup/1,
-  record_local/2, record_import/3,
+  record_local/2, record_import/3, record_remote/3,
   record_warn/4, record_definition/3,
   ensure_no_import_conflict/4, ensure_all_imports_used/3,
   warn_unused_local/3, format_error/1
@@ -53,6 +53,16 @@ record_import(Tuple, Receiver, Module) ->
     error:badarg -> false
   end.
 
+record_remote(_Tuple, Receiver, Module)
+  when Module == nil; Module == Receiver -> false;
+record_remote(Tuple, Receiver, Module) ->
+  try
+    Pid = ets:lookup_element(Module, ?attr, 2),
+    ?tracker:add_remote(Pid, Receiver, Tuple)
+  catch
+    error:badarg -> false
+  end.
+
 record_definition(Tuple, Kind, Module) ->
   if_tracker(Module, fun(Pid) ->
     ?tracker:add_definition(Pid, Kind, Tuple),

lib/elixir/test/elixir/module/dispatch_tracker_test.exs

@@ -139,4 +139,21 @@ defmodule Module.DispatchTrackerTest do
     D.add_import(config[:pid], Module, { :conflict, 1 })
     assert { [Module], :conflict, 1 } in D.collect_imports_conflicts(config[:pid], [conflict: 1])
   end
+
+  ## Remotes
+
+  test "can add remote", config do
+    D.add_remote(config[:pid], Module, { :concat, 1 })
+  end
+
+  test "can retrieve remotes", config do
+    D.add_remote(config[:pid], Module, { :concat, 1 })
+    assert Module in D.remotes(config[:pid])
+  end
+
+  test "find remotes from dispatch", config do
+    D.add_remote(config[:pid], Module, { :concat, 1 })
+    assert Module in D.remotes_with_dispatch(config[:pid], { :concat, 1 })
+    refute Module in D.remotes_with_dispatch(config[:pid], { :unknown, 1 })
+  end
 end