Ensure default calls are connected in dispatch tracker

Author: José Valim

lib/elixir/lib/module/dispatch_tracker.ex

@@ -180,6 +180,12 @@ defmodule Module.DispatchTracker do
     :gen_server.cast(pid, { :add_definition, kind, tuple })
   end
 
+  # Adds and tracks defaults for a definition into the tracker.
+  @doc false
+  def add_defaults(pid, kind, tuple, defaults) when kind in [:def, :defp, :defmacro, :defmacrop] do
+    :gen_server.cast(pid, { :add_defaults, kind, tuple, defaults })
+  end
+
   # Adds a local dispatch to the given target.
   def add_local(pid, to) when is_tuple(to) do
     :gen_server.cast(pid, { :add_local, :local, to })
@@ -327,18 +333,17 @@ defmodule Module.DispatchTracker do
   end
 
   def handle_cast({ :add_local, from, to }, d) do
-    :digraph.add_vertex(d, to)
-    replace_edge!(d, from, to)
+    handle_add_local(d, from, to)
     { :noreply, d }
   end
 
   def handle_cast({ :add_remote, function, module, { name, arity } }, d) do
-    record_import_or_remote(d, :remote, function, module, name, arity)
+    handle_import_or_remote(d, :remote, function, module, name, arity)
     { :noreply, d }
   end
 
   def handle_cast({ :add_import, function, module, { name, arity } }, d) do
-    record_import_or_remote(d, :import, function, module, name, arity)
+    handle_import_or_remote(d, :import, function, module, name, arity)
     { :noreply, d }
   end
 
@@ -355,14 +360,16 @@ defmodule Module.DispatchTracker do
     { :noreply, d }
   end
 
-  def handle_cast({ :add_definition, public, tuple }, d) when public in [:def, :defmacro] do
-    :digraph.add_vertex(d, tuple)
-    replace_edge!(d, :local, tuple)
+  def handle_cast({ :add_definition, kind, tuple }, d) do
+    handle_add_definition(d, kind, tuple)
     { :noreply, d }
   end
 
-  def handle_cast({ :add_definition, private, tuple }, d) when private in [:defp, :defmacrop] do
-    :digraph.add_vertex(d, tuple)
+  def handle_cast({ :add_defaults, kind, { name, arity }, defaults }, d) 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 }
   end
 
@@ -388,7 +395,7 @@ defmodule Module.DispatchTracker do
     { :ok, d }
   end
 
-  defp record_import_or_remote(d, kind, function, module, name, arity) do
+  defp handle_import_or_remote(d, kind, function, module, name, arity) do
     :digraph.add_vertex(d, module)
     replace_edge!(d, kind, module)
 
@@ -401,6 +408,20 @@ defmodule Module.DispatchTracker do
     end
   end
 
+  defp handle_add_local(d, from, to) do
+    :digraph.add_vertex(d, to)
+    replace_edge!(d, from, to)
+  end
+
+  defp handle_add_definition(d, public, tuple) when public in [:def, :defmacro] do
+    :digraph.add_vertex(d, tuple)
+    replace_edge!(d, :local, tuple)
+  end
+
+  defp handle_add_definition(d, private, tuple) when private in [:defp, :defmacrop] do
+    :digraph.add_vertex(d, tuple)
+  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_def.erl

@@ -124,13 +124,16 @@ store_definition(Kind, Line, CheckClauses, Module, Name, Args, Guards, Body, #el
 
   { Function, Defaults, TS } = translate_definition(Kind, Line, Name, Args, Guards, Body, S),
 
+  DefaultsLength = length(Defaults),
+  elixir_tracker:record_defaults(Tuple, Kind, Module, DefaultsLength),
+
   File  = TS#elixir_scope.file,
   Table = table(Module),
   CTable = clauses_table(Module),
 
   compile_super(Module, TS),
   store_each(CheckClauses, Kind, File, Location,
-    Table, CTable, length(Defaults), Function),
+    Table, CTable, DefaultsLength, Function),
 
   [store_each(false, Kind, File, Location, Table, CTable, 0,
     default_function_for(Kind, Name, Default)) || Default <- Defaults],

lib/elixir/src/elixir_tracker.erl

@@ -6,6 +6,7 @@
   record_local/2, record_local/3,
   record_import/4, record_remote/4,
   record_warn/4, record_definition/3,
+  record_defaults/4,
   ensure_no_import_conflict/4, ensure_all_imports_used/3,
   warn_unused_local/3, format_error/1
 ]).
@@ -70,6 +71,14 @@ record_definition(Tuple, Kind, Module) ->
     true
   end).
 
+record_defaults(_Tuple, _Kind, _Module, 0) ->
+  true;
+record_defaults(Tuple, Kind, Module, Defaults) ->
+  if_tracker(Module, fun(Pid) ->
+    ?tracker:add_defaults(Pid, Kind, Tuple, Defaults),
+    true
+  end).
+
 %% HELPERS
 
 if_tracker(Module, Callback) ->

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

@@ -103,6 +103,36 @@ defmodule Module.DispatchTrackerTest do
     assert unused == []
   end
 
+  ## Defaults
+
+  test "can add defaults", config do
+    D.add_definition(config[:pid], :def, { :foo, 4 })
+    D.add_defaults(config[:pid], :def, { :foo, 4 }, 2)
+  end
+
+  test "defaults are reachable if public", config do
+    D.add_definition(config[:pid], :def, { :foo, 4 })
+    D.add_defaults(config[:pid], :def, { :foo, 4 }, 2)
+    assert { :foo, 2 } in D.reachable(config[:pid])
+    assert { :foo, 3 } in D.reachable(config[:pid])
+  end
+
+  test "defaults are not reachable if private", config do
+    D.add_definition(config[:pid], :defp, { :foo, 4 })
+    D.add_defaults(config[:pid], :defp, { :foo, 4 }, 2)
+    refute { :foo, 2 } in D.reachable(config[:pid])
+    refute { :foo, 3 } in D.reachable(config[:pid])
+  end
+
+  test "defaults are connected", config do
+    D.add_definition(config[:pid], :defp, { :foo, 4 })
+    D.add_defaults(config[:pid], :defp, { :foo, 4 }, 2)
+    D.add_local(config[:pid], { :foo, 2 })
+    assert { :foo, 2 } in D.reachable(config[:pid])
+    assert { :foo, 3 } in D.reachable(config[:pid])
+    assert { :foo, 4 } in D.reachable(config[:pid])
+  end
+
   ## Imports
 
   test "can add import", config do