Start moving unreachable checks to types

Author: josevalim

lib/elixir/lib/code.ex

@@ -249,7 +249,6 @@ defmodule Code do
     :debug_info,
     :ignore_already_consolidated,
     :ignore_module_conflict,
-    :infer_signatures,
     :relative_paths
   ]
 
@@ -1562,8 +1561,8 @@ defmodule Code do
 
   ## Examples
 
-      Code.compiler_options(infer_signatures: false)
-      #=> %{infer_signatures: true}
+      Code.compiler_options(ignore_module_conflict: true)
+      #=> %{ignore_module_conflict: false}
 
   """
   @spec compiler_options(Enumerable.t({atom, term})) :: %{optional(atom) => term}
@@ -1647,15 +1646,6 @@ defmodule Code do
     * `:ignore_module_conflict` - when `true`, does not warn when a module has
       already been defined. Defaults to `false`.
 
-    * `:infer_signatures` (since v1.18.0) - when `false`, it disables module-local
-      signature inference used when type checking remote calls to the compiled
-      module. Type checking will be executed regardless of this value of this option.
-      Defaults to `true`.
-
-      `mix test` automatically disables this option via the `:test_elixirc_options`
-      project configuration, as there is typically no need to store infer signatures
-      for test files.
-
     * `:relative_paths` - when `true`, uses relative paths in quoted nodes,
       warnings, and errors generated by the compiler. Note disabling this option
       won't affect runtime warnings and errors. Defaults to `true`.

lib/elixir/lib/module/parallel_checker.ex

@@ -47,15 +47,10 @@ defmodule Module.ParallelChecker do
   @doc """
   Spawns a process that runs the parallel checker.
   """
-  def spawn(pid_checker, module_map, log?, infer_types?, env) do
+  def spawn(pid_checker, module_map, log?, env) do
     %{module: module, definitions: definitions, file: file} = module_map
-
-    module_map =
-      if infer_types? do
-        %{module_map | signatures: Module.Types.infer(module, file, definitions, env)}
-      else
-        module_map
-      end
+    {signatures, unreachable} = Module.Types.infer(module, file, definitions, env)
+    module_map = %{module_map | signatures: signatures, unreachable: unreachable}
 
     with {pid, checker} <- pid_checker do
       ets = :gen_server.call(checker, :ets, :infinity)

lib/elixir/lib/module/types.ex

@@ -16,16 +16,27 @@ defmodule Module.Types do
     stack = stack(:infer, file, module, {:__info__, 1}, :all, env, handler)
     context = context(%{})
 
-    {types, _context} =
+    {types, %{local_sigs: local_sigs}} =
       for {fun_arity, kind, _meta, _clauses} = def <- defs,
-          kind == :def and fun_arity not in @no_infer,
+          kind == :def or kind == :defmacro,
           reduce: {[], context} do
         {types, context} ->
           {_kind, inferred, context} = local_handler(fun_arity, stack, context, fn _ -> def end)
-          {[{fun_arity, inferred} | types], context}
+
+          if kind == :def and fun_arity not in @no_infer do
+            {[{fun_arity, inferred} | types], context}
+          else
+            {types, context}
+          end
       end
 
-    Map.new(types)
+    unreachable =
+      for {fun_arity, kind, meta, _clauses} <- defs,
+          kind == :defp or kind == :defmacrop,
+          not is_map_key(local_sigs, fun_arity),
+          do: {fun_arity, meta}
+
+    {Map.new(types), unreachable}
   end
 
   @doc false

lib/elixir/src/elixir.erl

@@ -88,7 +88,6 @@ start(_Type, _Args) ->
 
     %% Compiler options
     {docs, true},
-    {infer_signatures, true},
     {ignore_already_consolidated, false},
     {ignore_module_conflict, false},
     {on_undefined_variable, raise},

lib/elixir/src/elixir_compiler.erl

@@ -144,7 +144,6 @@ bootstrap() ->
   elixir_config:static(#{bootstrap => true}),
   elixir_config:put(docs, false),
   elixir_config:put(ignore_module_conflict, true),
-  elixir_config:put(infer_signatures, false),
   elixir_config:put(on_undefined_variable, raise),
   elixir_config:put(parser_options, []),
   elixir_config:put(relative_paths, false),

lib/elixir/src/elixir_def.erl

@@ -37,9 +37,11 @@ fun_for(Meta, Module, Name, Arity, Kinds, External) ->
     {[{_, Kind, LocalMeta, _, _, _}], ClausesPairs} ->
       case (Kinds == all) orelse (lists:member(Kind, Kinds)) of
         true ->
-          Local = {value, fun(Fun, Args) -> invoke_local(Meta, Module, Fun, Args, External) end},
+          TrackLocal = (Kind == defmacrop),
+          TrackLocal andalso track_local(Module, Tuple),
+          Local = {value, fun(Fun, Args) -> invoke_local(Meta, Module, Fun, Args, TrackLocal, External) end},
           Clauses = [Clause || {_, Clause} <- ClausesPairs],
-          elixir_erl:definition_to_anonymous(Kind, LocalMeta, Clauses, Local, External);
+          {Kind, elixir_erl:definition_to_anonymous(Kind, LocalMeta, Clauses, Local, External)};
         false ->
           false
       end;
@@ -49,17 +51,22 @@ fun_for(Meta, Module, Name, Arity, Kinds, External) ->
     _:_ -> false
   end.
 
-invoke_local(Meta, Module, ErlName, Args, External) ->
+invoke_local(Meta, Module, ErlName, Args, TrackLocal, External) ->
   {Name, Arity} = elixir_utils:erl_fa_to_elixir_fa(ErlName, length(Args)),
 
   case fun_for(Meta, Module, Name, Arity, all, External) of
     false ->
       {current_stacktrace, [_ | T]} = erlang:process_info(self(), current_stacktrace),
       erlang:raise(error, undef, [{Module, Name, Arity, []} | T]);
-    Fun ->
+    {Kind, Fun} ->
+      (TrackLocal and (Kind == defp)) andalso track_local(Module, {Name, Arity}),
       apply(Fun, Args)
   end.
 
+track_local(Module, FunArity) ->
+  {_, Bag} = elixir_module:data_tables(Module),
+  ets:insert(Bag, {macro_private_calls, FunArity}).
+
 invoke_external(Meta, Mod, Name, Args, E) ->
   is_map(E) andalso elixir_env:trace({require, Meta, Mod, []}, E),
   apply(Mod, Name, Args).

lib/elixir/src/elixir_dispatch.erl

@@ -171,23 +171,23 @@ expand_import(Meta, Name, Arity, E, Extra, AllowLocals, Trace) ->
     _ ->
       Local = AllowLocals andalso elixir_def:local_for(Meta, Name, Arity, [defmacro, defmacrop], E),
 
-      case Dispatch of
+      case {Dispatch, Local} of
         %% There is a local and an import. This is a conflict unless
         %% the receiver is the same as module (happens on bootstrap).
-        {_, Receiver} when Local /= false, Receiver /= Module ->
+        {{_, Receiver}, {_, _}} when Receiver /= Module ->
           {conflict, Receiver};
 
         %% There is no local. Dispatch the import.
-        _ when Local == false ->
+        {_, false} ->
           do_expand_import(Dispatch, Meta, Name, Arity, Module, E, Trace);
 
         %% Dispatch to the local.
-        _ ->
+        {_, {_Kind, Fun}} ->
           Trace andalso begin
             elixir_env:trace({local_macro, Meta, Name, Arity}, E),
             elixir_locals:record_local(Tuple, Module, ?key(E, function), Meta, true)
           end,
-          {macro, Module, expander_macro_fun(Meta, Local, Module, Name, E)}
+          {macro, Module, expander_macro_fun(Meta, Fun, Module, Name, E)}
       end
   end.
 

lib/elixir/src/elixir_map.erl

@@ -192,7 +192,7 @@ maybe_load_struct(Meta, Name, Assocs, E) ->
       false ->
         Name:'__struct__'(Assocs);
 
-      ExternalFun ->
+      {_, ExternalFun} ->
         %% There is an inherent race condition when using external_for.
         %% By the time we got to execute the function, the ETS table
         %% with temporary definitions for the given module may no longer

lib/elixir/src/elixir_module.erl

@@ -540,12 +540,10 @@ spawn_parallel_checker(CheckerInfo, ModuleMap, E) ->
       _ -> true
     end,
 
-  Infer = elixir_config:get(infer_signatures),
-
   if
     %% We need this clause for bootstrap reasons
-    CheckerInfo /= nil; Infer ->
-      'Elixir.Module.ParallelChecker':spawn(CheckerInfo, ModuleMap, Log, Infer, E);
+    CheckerInfo /= nil ->
+      'Elixir.Module.ParallelChecker':spawn(CheckerInfo, ModuleMap, Log, E);
     true ->
       ModuleMap
   end.

lib/mix/lib/mix/compilers/test.ex

@@ -23,7 +23,7 @@ defmodule Mix.Compilers.Test do
   """
   def require_and_run(matched_test_files, test_paths, elixirc_opts, opts) do
     elixirc_opts =
-      Keyword.merge([docs: false, debug_info: false, infer_signatures: false], elixirc_opts)
+      Keyword.merge([docs: false, debug_info: false], elixirc_opts)
 
     previous_opts = Code.compiler_options(elixirc_opts)