Simplify inference entry point

Author: josevalim

lib/elixir/lib/code.ex

@@ -1741,10 +1741,10 @@ defmodule Code do
       module. Type checking will be executed regardless of the value of this option.
       Defaults to `true`, which is equivalent to setting it to `[:elixir]` only.
 
-      When setting this option, we recommend running `mix clean` so the current module
-      may be compiled from scratch. `mix test` automatically disables this option via
-      the `:test_elixirc_options` project configuration, as there is typically no need
-      to infer signatures for test files.
+      When setting this option, we recommend running `mix clean` so the modules can be
+      recompiled with the new behaviour. `mix test` automatically disables this option
+      via the `:test_elixirc_options` project configuration, as there is typically no
+      need to 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

lib/elixir/lib/module/parallel_checker.ex

@@ -220,14 +220,6 @@ defmodule Module.ParallelChecker do
     end
   end
 
-  @doc """
-  Test cache.
-  """
-  def test_cache do
-    {:ok, cache} = start_link()
-    cache
-  end
-
   @doc """
   Returns the export kind and deprecation reason for the given MFA from
   the cache. If the module does not exist return `:badmodule`,

lib/elixir/lib/module/types.ex

@@ -34,7 +34,7 @@ defmodule Module.Types do
   @no_infer [behaviour_info: 1]
 
   @doc false
-  def infer(module, file, attrs, defs, private, used_private, env, {_, cache}) do
+  def infer(module, file, attrs, defs, used_private, env, {_, cache}) do
     # We don't care about inferring signatures for protocols,
     # those will be replaced anyway. There is also nothing to
     # infer if there is no cache system, we only do traversals.
@@ -72,11 +72,10 @@ defmodule Module.Types do
 
     stack = stack(:infer, file, module, {:__info__, 1}, env, cache, handler)
 
-    {types, %{local_sigs: reachable_sigs} = context} =
+    {types, private, %{local_sigs: reachable_sigs} = context} =
       for {fun_arity, kind, meta, _clauses} = def <- defs,
-          kind in [:def, :defmacro],
-          reduce: {[], context()} do
-        {types, context} ->
+          reduce: {[], [], context()} do
+        {types, private, context} when kind in [:def, :defmacro] ->
           # Optimized version of finder, since we already have the definition
           finder = fn _ ->
             default_domain(infer_mode(kind, infer_signatures?), def, fun_arity, impl)
@@ -85,10 +84,13 @@ defmodule Module.Types do
           {_kind, inferred, context} = local_handler(meta, fun_arity, stack, context, finder)
 
           if infer_signatures? and kind == :def and fun_arity not in @no_infer do
-            {[{fun_arity, inferred} | types], context}
+            {[{fun_arity, inferred} | types], private, context}
           else
-            {types, context}
+            {types, private, context}
           end
+
+        {types, private, context} ->
+          {types, [def | private], context}
       end
 
     # Now traverse all used privates to find any other private that have been used by them.
@@ -102,8 +104,8 @@ defmodule Module.Types do
 
     {unreachable, _context} =
       Enum.reduce(private, {[], context}, fn
-        {fun_arity, kind, _meta, _defaults} = info, {unreachable, context} ->
-          warn_unused_def(info, used_sigs, env)
+        {fun_arity, kind, meta, _clauses}, {unreachable, context} ->
+          warn_unused_def(fun_arity, kind, meta, used_sigs, env)
 
           # Find anything undefined within unused functions
           {_kind, _inferred, context} = local_handler([], fun_arity, stack, context, finder)
@@ -170,29 +172,30 @@ defmodule Module.Types do
     :elixir_errors.module_error(Helpers.with_span(meta, fun), env, __MODULE__, tuple)
   end
 
-  defp warn_unused_def({_fun_arity, _kind, false, _}, _used, _env) do
-    :ok
-  end
+  defp warn_unused_def(fun_arity, kind, meta, used, env) do
+    default = Keyword.get(meta, :defaults, 0)
 
-  defp warn_unused_def({fun_arity, kind, meta, 0}, used, env) do
-    case is_map_key(used, fun_arity) do
-      true -> :ok
-      false -> :elixir_errors.file_warn(meta, env, __MODULE__, {:unused_def, fun_arity, kind})
-    end
+    cond do
+      Keyword.get(meta, :context) != nil ->
+        :ok
 
-    :ok
-  end
+      default == 0 ->
+        case is_map_key(used, fun_arity) do
+          true -> :ok
+          false -> :elixir_errors.file_warn(meta, env, __MODULE__, {:unused_def, fun_arity, kind})
+        end
 
-  defp warn_unused_def({tuple, kind, meta, default}, used, env) when default > 0 do
-    {name, arity} = tuple
-    min = arity - default
-    max = arity
+      default > 0 ->
+        {name, arity} = fun_arity
+        min = arity - default
+        max = arity
 
-    case min_reachable_default(max, min, :none, name, 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})
+        case min_reachable_default(max, min, :none, name, used) do
+          :none -> :elixir_errors.file_warn(meta, env, __MODULE__, {:unused_def, fun_arity, kind})
+          ^min -> :ok
+          ^max -> :elixir_errors.file_warn(meta, env, __MODULE__, {:unused_args, fun_arity})
+          diff -> :elixir_errors.file_warn(meta, env, __MODULE__, {:unused_args, fun_arity, diff})
+        end
     end
 
     :ok

lib/elixir/src/elixir_def.erl

@@ -97,43 +97,27 @@ fetch_definitions(Module, E) ->
     error:badarg -> []
   end,
 
-  fetch_definition(Entries, E, Module, Set, Bag, [], []).
+  fetch_definition(Entries, E, Module, Set, Bag, []).
 
-fetch_definition([Tuple | T], E, Module, Set, Bag, All, Private) ->
-  [{_, Kind, Meta, _, Check, {MaxDefaults, _, Defaults}}] = ets:lookup(Set, {def, Tuple}),
+fetch_definition([Tuple | T], E, Module, Set, Bag, All) ->
+  [{_, Kind, Meta, _, _, {MaxDefaults, _, _}}] = ets:lookup(Set, {def, Tuple}),
 
   try ets:lookup_element(Bag, {clauses, Tuple}, 2) of
     Clauses ->
-      NewAll =
-        [{Tuple, Kind, add_defaults_to_meta(MaxDefaults, Meta), Clauses} | All],
-      NewPrivate =
-        case (Kind == defp) orelse (Kind == defmacrop) of
-          true ->
-            Metas = head_and_definition_meta(Check, Meta, MaxDefaults - Defaults, All),
-            [{Tuple, Kind, Metas, MaxDefaults} | Private];
-          false ->
-            Private
-        end,
-      fetch_definition(T, E, Module, Set, Bag, NewAll, NewPrivate)
+      NewAll = [{Tuple, Kind, add_defaults_to_meta(MaxDefaults, Meta), Clauses} | All],
+      fetch_definition(T, E, Module, Set, Bag, NewAll)
   catch
     error:badarg ->
       elixir_errors:module_error(Meta, E, ?MODULE, {function_head, Kind, Tuple}),
-      fetch_definition(T, E, Module, Set, Bag, All, Private)
+      fetch_definition(T, E, Module, Set, Bag, All)
   end;
 
-fetch_definition([], _E, _Module, _Set, _Bag, All, Private) ->
-  {All, Private}.
+fetch_definition([], _E, _Module, _Set, _Bag, All) ->
+  All.
 
 add_defaults_to_meta(0, Meta) -> Meta;
 add_defaults_to_meta(Defaults, Meta) -> [{defaults, Defaults} | Meta].
 
-head_and_definition_meta(none, _Meta, _HeadDefaults, _All) ->
-  false;
-head_and_definition_meta(_, Meta, 0, _All) ->
-  Meta;
-head_and_definition_meta(_, _Meta, _HeadDefaults, [{_, _, HeadMeta, _} | _]) ->
-  HeadMeta.
-
 %% Section for storing definitions
 
 store_definition(Kind, {Call, Body}, Pos) ->
@@ -168,11 +152,7 @@ store_definition(Kind, HasNoUnquote, Call, Body, #{line := Line} = E) ->
     _ -> Column
   end,
 
-  CheckClauses = if
-    Context /= [] -> none;
-    HasNoUnquote -> all;
-    true -> unused_only
-  end,
+  CheckClauses = (Context == []) andalso HasNoUnquote,
 
   %% Check if there is a file information in the definition.
   %% If so, we assume this come from another source and
@@ -223,7 +203,7 @@ store_definition(Meta, Kind, CheckClauses, Name, Arity, DefaultsArgs, Guards, Bo
 
   store_definition(CheckClauses, Kind, Meta, Name, Arity, File,
                    Module, DefaultsLength, Clauses),
-  [store_definition(none, Kind, Meta, Name, length(DefaultArgs), File,
+  [store_definition(false, Kind, [{context, ?MODULE} | Meta], Name, length(DefaultArgs), File,
                     Module, 0, [Default]) || {_, DefaultArgs, _, _} = Default <- Defaults],
 
   run_on_definition_callbacks(Meta, Kind, Module, Name, DefaultsArgs, Guards, Body, E),
@@ -281,11 +261,10 @@ run_on_definition_callbacks(Meta, Kind, Module, Name, Args, Guards, Body, E) ->
   ok.
 
 store_definition(CheckClauses, Kind, Meta, Name, Arity, File, Module, Defaults, Clauses)
-    when CheckClauses == all; CheckClauses == none; CheckClauses == unused_only ->
+    when is_boolean(CheckClauses) ->
   {Set, Bag} = elixir_module:data_tables(Module),
   Tuple = {Name, Arity},
   HasBody = Clauses =/= [],
-  CheckAll = CheckClauses == all,
 
   if
     Defaults > 0 ->
@@ -299,7 +278,7 @@ store_definition(CheckClauses, Kind, Meta, Name, Arity, File, Module, Defaults,
       [{_, StoredKind, StoredMeta, StoredFile, StoredCheck, {StoredDefaults, LastHasBody, LastDefaults}}] ->
         check_valid_kind(Meta, File, Name, Arity, Kind, StoredKind, StoredFile, StoredMeta),
         check_valid_defaults(Meta, File, Name, Arity, Kind, Defaults, StoredMeta, StoredDefaults, LastDefaults, HasBody, LastHasBody),
-        (CheckAll and (StoredCheck == all)) andalso
+        (CheckClauses and StoredCheck) andalso
           check_valid_clause(Meta, File, Name, Arity, Kind, Set, StoredMeta, StoredFile, Clauses),
 
         {max(Defaults, StoredDefaults), StoredMeta};
@@ -308,7 +287,7 @@ store_definition(CheckClauses, Kind, Meta, Name, Arity, File, Module, Defaults,
         {Defaults, Meta}
     end,
 
-  CheckAll andalso ets:insert(Set, {?last_def, Tuple}),
+  CheckClauses andalso ets:insert(Set, {?last_def, Tuple}),
   ets:insert(Bag, [{{clauses, Tuple}, Clause} || Clause <- Clauses]),
   ets:insert(Set, {{def, Tuple}, Kind, FirstMeta, File, CheckClauses, {MaxDefaults, HasBody, Defaults}}).
 

lib/elixir/src/elixir_erl.erl

@@ -6,7 +6,7 @@
 
 -module(elixir_erl).
 -export([elixir_to_erl/1, elixir_to_erl/2, definition_to_anonymous/5, compile/2, consolidate/4,
-         get_ann/1, debug_info/4, scope/2, checker_version/0, format_error/1]).
+         get_ann/1, debug_info/4, scope/2, checker_chunk/2, checker_version/0, format_error/1]).
 -include("elixir.hrl").
 -define(typespecs, 'Elixir.Kernel.Typespec').
 
@@ -140,6 +140,13 @@ consolidate(Map, Checker, TypeSpecs, DocsChunk) ->
   CheckerChunk = checker_chunk(Checker, chunk_opts(Map)),
   load_form(Map, Prefix, Forms, TypeSpecs, DocsChunk ++ CheckerChunk).
 
+%% Used for updating type checking chunks in Elixir
+
+checker_chunk(nil, _ChunkOpts) ->
+  [];
+checker_chunk(Contents, ChunkOpts) ->
+  [{<<"ExCk">>, term_to_binary({checker_version(), Contents}, ChunkOpts)}].
+
 %% Dynamic compilation hook, used in regular compiler
 
 compile(#{module := Module, anno := Anno} = BaseMap, Signatures) ->
@@ -642,11 +649,6 @@ signature_to_binary(_, Name, Signature) ->
   Doc = 'Elixir.Inspect.Algebra':format('Elixir.Code':quoted_to_algebra(Quoted), infinity),
   'Elixir.IO':iodata_to_binary(Doc).
 
-checker_chunk(nil, _ChunkOpts) ->
-  [];
-checker_chunk(Contents, ChunkOpts) ->
-  [{<<"ExCk">>, term_to_binary({checker_version(), Contents}, ChunkOpts)}].
-
 checker_chunk(Map, Def, Signatures, ChunkOpts) ->
   #{deprecated := Deprecated, defines_behaviour := DefinesBehaviour, attributes := Attributes} = Map,
   DeprecatedMap = maps:from_list(Deprecated),

lib/elixir/src/elixir_module.erl

@@ -168,7 +168,7 @@ compile(Meta, Module, ModuleAsCharlist, Block, Vars, Prune, E) ->
       elixir_erl_compiler:spawn(fun() ->
         PersistedAttributes = ets:lookup_element(DataBag, persisted_attributes, 2),
         Attributes = attributes(DataSet, DataBag, PersistedAttributes),
-        {AllDefinitions, Private} = elixir_def:fetch_definitions(Module, E),
+        AllDefinitions = elixir_def:fetch_definitions(Module, E),
 
         OnLoadAttribute = lists:keyfind(on_load, 1, Attributes),
         validate_on_load_attribute(OnLoadAttribute, AllDefinitions, DataBag, Line, E),
@@ -196,7 +196,7 @@ compile(Meta, Module, ModuleAsCharlist, Block, Vars, Prune, E) ->
             true -> {#{}, []};
             false ->
               UsedPrivate = bag_lookup_element(DataBag, used_private, 2),
-              'Elixir.Module.Types':infer(Module, File, Attributes, AllDefinitions, Private, UsedPrivate, E, CheckerInfo)
+              'Elixir.Module.Types':infer(Module, File, Attributes, AllDefinitions, UsedPrivate, E, CheckerInfo)
           end,
 
         RawCompileOpts = bag_lookup_element(DataBag, {accumulate, compile}, 2),

lib/elixir/src/elixir_overridable.erl

@@ -96,7 +96,7 @@ store(Set, Module, Tuple, {_, Count, Def, Overridden}, Hidden) ->
   case Overridden of
     false ->
       ets:update_element(Set, {overridable, Tuple}, {?overridden_pos, true}),
-      elixir_def:store_definition(none, FinalKind, Meta, FinalName, FinalArity,
+      elixir_def:store_definition(false, FinalKind, Meta, FinalName, FinalArity,
                                   File, Module, Defaults, FinalClauses);
     true ->
       ok

lib/elixir/test/elixir/module/types/type_helper.exs

@@ -141,7 +141,14 @@ defmodule TypeHelper do
   end
 
   defp new_stack(mode) do
-    cache = if mode == :infer, do: :none, else: Module.ParallelChecker.test_cache()
+    cache =
+      if mode == :infer do
+        :none
+      else
+        {:ok, cache} = Module.ParallelChecker.start_link()
+        cache
+      end
+
     handler = fn _, fun_arity, _, _ -> raise "no local lookup for: #{inspect(fun_arity)}" end
     Types.stack(mode, "types_test.ex", TypesTest, {:test, 0}, [], cache, handler)
   end