Move unreachable tracker to typing

Author: josevalim

lib/elixir/lib/module/parallel_checker.ex

@@ -47,9 +47,12 @@ defmodule Module.ParallelChecker do
   @doc """
   Spawns a process that runs the parallel checker.
   """
-  def spawn(pid_checker, module_map, log?, env) do
+  def spawn(pid_checker, module_map, log?, private, used, env) do
     %{module: module, definitions: definitions, file: file} = module_map
-    {signatures, unreachable} = Module.Types.infer(module, file, definitions, env)
+
+    {signatures, unreachable} =
+      Module.Types.infer(module, file, definitions, private, used, env)
+
     module_map = %{module_map | signatures: signatures, unreachable: unreachable}
 
     with {pid, checker} <- pid_checker do

lib/elixir/lib/module/types.ex

@@ -10,7 +10,7 @@ defmodule Module.Types do
   @no_infer [__protocol__: 1, behaviour_info: 1]
 
   @doc false
-  def infer(module, file, defs, env) do
+  def infer(module, file, defs, private, used, env) do
     finder = &List.keyfind(defs, &1, 0)
     handler = &local_handler(&1, &2, &3, finder)
     stack = stack(:infer, file, module, {:__info__, 1}, :all, env, handler)
@@ -31,14 +31,55 @@ defmodule Module.Types do
       end
 
     unreachable =
-      for {fun_arity, kind, meta, _clauses} <- defs,
-          kind == :defp or kind == :defmacrop,
+      for {fun_arity, _kind, _meta, _defaults} = info <- private,
+          maybe_warn_unused(info, local_sigs, used, env),
           not is_map_key(local_sigs, fun_arity),
-          do: {fun_arity, meta}
+          do: fun_arity
 
     {Map.new(types), unreachable}
   end
 
+  defp maybe_warn_unused({_fun_arity, _kind, false, _}, _reachable, _used, _env) do
+    :ok
+  end
+
+  defp maybe_warn_unused({fun_arity, kind, meta, 0}, reachable, used, env) do
+    case meta == false or Map.has_key?(reachable, fun_arity) or fun_arity in used do
+      true -> :ok
+      false -> :elixir_errors.file_warn(meta, env, __MODULE__, {:unused_def, fun_arity, kind})
+    end
+
+    :ok
+  end
+
+  defp maybe_warn_unused({tuple, kind, meta, default}, reachable, used, env) when default > 0 do
+    {name, arity} = tuple
+    min = arity - default
+    max = arity
+
+    case min_reachable_default(max, min, :none, name, reachable, used) do
+      :none -> :elixir_errors.file_warn(meta, env, __MODULE__, {:unused_def, tuple, kind})
+      ^min -> :ok
+      ^max -> :elixir_errors.file_warn(meta, env, __MODULE__, {:unused_args, tuple})
+      diff -> :elixir_errors.file_warn(meta, env, __MODULE__, {:unused_args, tuple, diff})
+    end
+
+    :ok
+  end
+
+  defp min_reachable_default(max, min, last, name, reachable, used) when max >= min do
+    fun_arity = {name, max}
+
+    case Map.has_key?(reachable, fun_arity) or fun_arity in used do
+      true -> min_reachable_default(max - 1, min, max, name, reachable, used)
+      false -> min_reachable_default(max - 1, min, last, name, reachable, used)
+    end
+  end
+
+  defp min_reachable_default(_max, _min, last, _name, _reachable, _used) do
+    last
+  end
+
   @doc false
   def warnings(module, file, defs, no_warn_undefined, cache) do
     finder = &List.keyfind(defs, &1, 0)
@@ -247,4 +288,22 @@ defmodule Module.Types do
       message: "this clause of #{kind} #{fun}/#{arity} is never used"
     }
   end
+
+  ## Module errors
+
+  def format_error({:unused_args, {name, arity}}),
+    do: "default values for the optional arguments in #{name}/#{arity} are never used"
+
+  def format_error({:unused_args, {name, arity}, count}) when arity - count == 1,
+    do: "the default value for the last optional argument in #{name}/#{arity} is never used"
+
+  def format_error({:unused_args, {name, arity}, count}),
+    do:
+      "the default values for the last #{arity - count} optional arguments in #{name}/#{arity} are never used"
+
+  def format_error({:unused_def, {name, arity}, :defp}),
+    do: "function #{name}/#{arity} is unused"
+
+  def format_error({:unused_def, {name, arity}, :defmacrop}),
+    do: "macro #{name}/#{arity} is unused"
 end

lib/elixir/src/elixir_module.erl

@@ -147,7 +147,7 @@ compile(Meta, Module, ModuleAsCharlist, Block, Vars, Prune, E) ->
         NifsAttribute = lists:keyfind(nifs, 1, Attributes),
         validate_nifs_attribute(NifsAttribute, AllDefinitions, Line, E),
 
-        Unreachable = elixir_locals:warn_unused_local(Module, AllDefinitions, NewPrivate, E),
+        % Unreachable = elixir_locals:warn_unused_local(Module, AllDefinitions, NewPrivate, E),
         elixir_locals:ensure_no_undefined_local(Module, AllDefinitions, E),
         elixir_locals:ensure_no_import_conflict(Module, AllDefinitions, E),
 
@@ -160,37 +160,35 @@ compile(Meta, Module, ModuleAsCharlist, Block, Vars, Prune, E) ->
          'Elixir.Module':'__check_attributes__'(E, DataSet, DataBag),
 
         RawCompileOpts = bag_lookup_element(DataBag, {accumulate, compile}, 2),
-        CompileOpts = validate_compile_opts(RawCompileOpts, AllDefinitions, Unreachable, Line, E),
+        CompileOpts = validate_compile_opts(RawCompileOpts, AllDefinitions, Line, E),
         Impls = bag_lookup_element(DataBag, impls, 2),
 
         AfterVerify = bag_lookup_element(DataBag, {accumulate, after_verify}, 2),
         [elixir_env:trace({remote_function, [], VerifyMod, VerifyFun, 1}, CallbackE) ||
          {VerifyMod, VerifyFun} <- AfterVerify],
 
-        %% Compute signatures only if the module is valid.
-        case ets:member(DataSet, {elixir, taint}) of
-          true -> elixir_errors:compile_error(E);
-          false -> ok
-        end,
-
-        ModuleMapWithoutSignatures = #{
+        PartialModuleMap = #{
           struct => get_struct(DataSet),
           module => Module,
           anno => Anno,
           file => File,
           relative_file => elixir_utils:relative_to_cwd(File),
           attributes => Attributes,
           definitions => AllDefinitions,
-          unreachable => Unreachable,
           after_verify => AfterVerify,
           compile_opts => CompileOpts,
           deprecated => get_deprecated(DataBag),
           defines_behaviour => defines_behaviour(DataBag),
           impls => Impls,
+          unreachable => [],
           signatures => #{}
         },
 
-        ModuleMap = spawn_parallel_checker(CheckerInfo, ModuleMapWithoutSignatures, CallbackE),
+        %% Compute signatures only if the module is valid.
+        compile_error_if_tainted(DataSet, E),
+        ModuleMap = spawn_parallel_checker(DataBag, CheckerInfo, PartialModuleMap, NewPrivate, E),
+        compile_error_if_tainted(DataSet, E),
+
         Binary = elixir_erl:compile(ModuleMap),
         Autoload = proplists:get_value(autoload, CompileOpts, true),
         {Binary, PersistedAttributes, Autoload}
@@ -223,41 +221,33 @@ compile(Meta, Module, ModuleAsCharlist, Block, Vars, Prune, E) ->
     elixir_code_server:call({undefmodule, Ref})
   end.
 
-validate_compile_opts(Opts, Defs, Unreachable, Line, E) ->
-  lists:flatmap(fun (Opt) -> validate_compile_opt(Opt, Defs, Unreachable, Line, E) end, Opts).
+compile_error_if_tainted(DataSet, E) ->
+  case ets:member(DataSet, {elixir, taint}) of
+    true -> elixir_errors:compile_error(E);
+    false -> ok
+  end.
+
+validate_compile_opts(Opts, Defs, Line, E) ->
+  lists:flatmap(fun (Opt) -> validate_compile_opt(Opt, Defs, Line, E) end, Opts).
 
 %% TODO: Make this an error on v2.0
-validate_compile_opt({parse_transform, Module} = Opt, _Defs, _Unreachable, Line, E) ->
+validate_compile_opt({parse_transform, Module} = Opt, _Defs, Line, E) ->
   elixir_errors:file_warn([{line, Line}], E, ?MODULE, {parse_transform, Module}),
   [Opt];
-validate_compile_opt({inline, Inlines}, Defs, Unreachable, Line, E) ->
-  case validate_inlines(Inlines, Defs, Unreachable, []) of
-    {ok, []} ->
-      [];
-    {ok, FilteredInlines} ->
-      [{inline, FilteredInlines}];
-    {error, Reason} ->
-      elixir_errors:module_error([{line, Line}], E, ?MODULE, Reason),
-      []
-  end;
-validate_compile_opt(Opt, Defs, Unreachable, Line, E) when is_list(Opt) ->
-  validate_compile_opts(Opt, Defs, Unreachable, Line, E);
-validate_compile_opt(Opt, _Defs, _Unreachable, _Line, _E) ->
-  [Opt].
-
-validate_inlines([Inline | Inlines], Defs, Unreachable, Acc) ->
-  case lists:keyfind(Inline, 1, Defs) of
+validate_compile_opt({inline, Inlines} = Opt, Defs, Line, E) ->
+  [case lists:keyfind(Inline, 1, Defs) of
     false ->
-      {error, {undefined_function, {compile, inline}, Inline}};
+      elixir_errors:module_error([{line, Line}], E, ?MODULE, {undefined_function, {compile, inline}, Inline});
     {_Def, Type, _Meta, _Clauses} when Type == defmacro; Type == defmacrop ->
-      {error, {bad_macro, {compile, inline}, Inline}};
+      elixir_errors:module_error([{line, Line}], E, ?MODULE, {bad_macro, {compile, inline}, Inline});
     _ ->
-      case lists:member(Inline, Unreachable) of
-        true -> validate_inlines(Inlines, Defs, Unreachable, Acc);
-        false -> validate_inlines(Inlines, Defs, Unreachable, [Inline | Acc])
-      end
-  end;
-validate_inlines([], _Defs, _Unreachable, Acc) -> {ok, Acc}.
+      ok
+  end || Inline <- Inlines],
+  [Opt];
+validate_compile_opt(Opt, Defs, Line, E) when is_list(Opt) ->
+  validate_compile_opts(Opt, Defs, Line, E);
+validate_compile_opt(Opt, _Defs, _Line, _E) ->
+  [Opt].
 
 validate_on_load_attribute({on_load, Def}, Defs, Private, Line, E) ->
   case lists:keyfind(Def, 1, Defs) of
@@ -533,19 +523,18 @@ checker_info() ->
     _ -> 'Elixir.Module.ParallelChecker':get()
   end.
 
-spawn_parallel_checker(CheckerInfo, ModuleMap, E) ->
+spawn_parallel_checker(DataBag, CheckerInfo, ModuleMap, Private, E) ->
   Log =
     case erlang:get(elixir_code_diagnostics) of
       {_, false} -> false;
       _ -> true
     end,
 
-  if
-    %% We need this clause for bootstrap reasons
-    CheckerInfo /= nil ->
-      'Elixir.Module.ParallelChecker':spawn(CheckerInfo, ModuleMap, Log, E);
-    true ->
-      ModuleMap
+  Used = bag_lookup_element(DataBag, macro_private_calls, 2),
+
+  case elixir_config:is_bootstrap() of
+    true -> ModuleMap;
+    false -> 'Elixir.Module.ParallelChecker':spawn(CheckerInfo, ModuleMap, Log, Private, Used, E)
   end.
 
 make_module_available(Module, Binary) ->