Prepare for local inference

Author: josevalim

lib/elixir/lib/module/parallel_checker.ex

@@ -5,7 +5,6 @@ defmodule Module.ParallelChecker do
 
   @type cache() :: {pid(), :ets.tid()}
   @type warning() :: term()
-  @type kind() :: :def | :defmacro
   @type mode() :: :elixir | :erlang
 
   @doc """
@@ -48,7 +47,25 @@ defmodule Module.ParallelChecker do
   @doc """
   Spawns a process that runs the parallel checker.
   """
-  def spawn({pid, checker}, module, info, log?) do
+  def spawn(pid_checker, module_map, log?, infer_types?, 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
+
+    with {pid, checker} <- pid_checker do
+      ets = :gen_server.call(checker, :ets, :infinity)
+      inner_spawn(pid, checker, module, cache_from_module_map(ets, module_map), log?)
+    end
+
+    module_map
+  end
+
+  defp inner_spawn(pid, checker, module, info, log?) do
     ref = make_ref()
 
     spawned =
@@ -59,17 +76,22 @@ defmodule Module.ParallelChecker do
           {^ref, :cache, ets} ->
             Process.link(pid)
 
-            module_map =
-              if is_map(info) do
-                info
-              else
-                case File.read(info) do
-                  {:ok, binary} -> maybe_module_map(binary, module)
-                  {:error, _} -> nil
-                end
+            module_tuple =
+              cond do
+                is_tuple(info) ->
+                  info
+
+                is_binary(info) ->
+                  with {:ok, binary} <- File.read(info),
+                       {:ok, {_, [debug_info: chunk]}} <- :beam_lib.chunks(binary, [:debug_info]),
+                       {:debug_info_v1, backend, data} = chunk,
+                       {:ok, module_map} <- backend.debug_info(:elixir_v1, module, data, []) do
+                    cache_from_module_map(ets, module_map)
+                  else
+                    _ -> nil
+                  end
               end
 
-            module_map && cache_from_module_map(ets, module_map)
             send(checker, {ref, :cached})
 
             receive do
@@ -78,8 +100,8 @@ defmodule Module.ParallelChecker do
                 :erlang.put(:elixir_compiler_info, {pid, self()})
 
                 warnings =
-                  if module_map do
-                    check_module(module_map, {checker, ets}, log?)
+                  if module_tuple do
+                    check_module(module_tuple, {checker, ets}, log?)
                   else
                     []
                   end
@@ -147,7 +169,7 @@ defmodule Module.ParallelChecker do
     log? = not match?({_, false}, value)
 
     for {module, file} <- runtime_files do
-      spawn({self(), checker}, module, file, log?)
+      inner_spawn(self(), checker, module, file, log?)
     end
 
     count = :gen_server.call(checker, :start, :infinity)
@@ -212,14 +234,43 @@ defmodule Module.ParallelChecker do
 
   ## Module checking
 
-  defp check_module(module_map, cache, log?) do
+  defp check_module(module_tuple, cache, log?) do
+    {module, file, line, definitions, no_warn_undefined, behaviours, impls, after_verify} =
+      module_tuple
+
+    behaviour_warnings =
+      Module.Behaviour.check_behaviours_and_impls(
+        module,
+        file,
+        line,
+        behaviours,
+        impls,
+        definitions
+      )
+
+    diagnostics =
+      module
+      |> Module.Types.warnings(file, definitions, no_warn_undefined, cache)
+      |> Kernel.++(behaviour_warnings)
+      |> group_warnings()
+      |> emit_warnings(log?)
+
+    Enum.each(after_verify, fn {verify_mod, verify_fun} ->
+      apply(verify_mod, verify_fun, [module])
+    end)
+
+    diagnostics
+  end
+
+  defp module_map_to_module_tuple(module_map) do
     %{
       module: module,
       file: file,
       compile_opts: compile_opts,
       definitions: definitions,
       attributes: attributes,
-      impls: impls
+      impls: impls,
+      after_verify: after_verify
     } = module_map
 
     # TODO: Match on anno directly in Elixir v1.22+
@@ -236,28 +287,7 @@ defmodule Module.ParallelChecker do
       |> extract_no_warn_undefined()
       |> merge_compiler_no_warn_undefined()
 
-    behaviour_warnings =
-      Module.Behaviour.check_behaviours_and_impls(
-        module,
-        file,
-        line,
-        behaviours,
-        impls,
-        definitions
-      )
-
-    diagnostics =
-      module
-      |> Module.Types.warnings(file, definitions, no_warn_undefined, cache)
-      |> Kernel.++(behaviour_warnings)
-      |> group_warnings()
-      |> emit_warnings(log?)
-
-    module_map
-    |> Map.get(:after_verify, [])
-    |> Enum.each(fn {verify_mod, verify_fun} -> apply(verify_mod, verify_fun, [module]) end)
-
-    diagnostics
+    {module, file, line, definitions, no_warn_undefined, behaviours, impls, after_verify}
   end
 
   defp extract_no_warn_undefined(compile_opts) do
@@ -400,25 +430,14 @@ defmodule Module.ParallelChecker do
     _ -> %{}
   end
 
-  defp maybe_module_map(binary, module) when is_binary(binary) do
-    # If a module was compiled without debug_info,
-    # then there is no module_map for further verification.
-    with {:ok, {_, [debug_info: chunk]}} <- :beam_lib.chunks(binary, [:debug_info]),
-         {:debug_info_v1, backend, data} = chunk,
-         {:ok, module_map} <- backend.debug_info(:elixir_v1, module, data, []) do
-      module_map
-    else
-      _ -> nil
-    end
-  end
-
   defp cache_from_module_map(ets, map) do
     exports =
       [{:__info__, 1}] ++
         behaviour_exports(map) ++
         for({function, :def, _meta, _clauses} <- map.definitions, do: function)
 
     cache_info(ets, map.module, exports, Map.new(map.deprecated), map.signatures, :elixir)
+    module_map_to_module_tuple(map)
   end
 
   defp cache_info(ets, module, exports, deprecated, sigs, mode) do

lib/elixir/lib/module/types.ex

@@ -29,7 +29,6 @@ defmodule Module.Types do
           end
         end)
 
-      # TODO: Reuse context from patterns and guards
       {{fun, arity}, {:infer, Enum.reverse(pair_types)}}
     end
   end

lib/elixir/src/elixir_module.erl

@@ -173,12 +173,7 @@ compile(Meta, Module, ModuleAsCharlist, Block, Vars, Prune, E) ->
           false -> ok
         end,
 
-        Signatures = case elixir_config:get(infer_signatures) of
-          true -> 'Elixir.Module.Types':infer(Module, File, AllDefinitions, CallbackE);
-          false -> #{}
-        end,
-
-        ModuleMap = #{
+        ModuleMapWithoutSignatures = #{
           struct => get_struct(DataSet),
           module => Module,
           anno => Anno,
@@ -192,12 +187,12 @@ compile(Meta, Module, ModuleAsCharlist, Block, Vars, Prune, E) ->
           deprecated => get_deprecated(DataBag),
           defines_behaviour => defines_behaviour(DataBag),
           impls => Impls,
-          signatures => Signatures
+          signatures => #{}
         },
 
+        ModuleMap = spawn_parallel_checker(CheckerInfo, ModuleMapWithoutSignatures, CallbackE),
         Binary = elixir_erl:compile(ModuleMap),
         Autoload = proplists:get_value(autoload, CompileOpts, true),
-        spawn_parallel_checker(CheckerInfo, Module, ModuleMap),
         {Binary, PersistedAttributes, Autoload}
       end),
 
@@ -207,7 +202,7 @@ compile(Meta, Module, ModuleAsCharlist, Block, Vars, Prune, E) ->
     elixir_env:trace({on_module, Binary, none}, ModuleE),
     warn_unused_attributes(DataSet, DataBag, PersistedAttributes, E),
     make_module_available(Module, Binary),
-    (CheckerInfo == undefined) andalso
+    (CheckerInfo == nil) andalso
       [VerifyMod:VerifyFun(Module) ||
        {VerifyMod, VerifyFun} <- bag_lookup_element(DataBag, {accumulate, after_verify}, 2)],
     {module, Module, Binary, Result}
@@ -534,19 +529,26 @@ beam_location(ModuleAsCharlist) ->
 
 checker_info() ->
   case get(elixir_checker_info) of
-    undefined -> undefined;
+    undefined -> nil;
     _ -> 'Elixir.Module.ParallelChecker':get()
   end.
 
-spawn_parallel_checker(undefined, _Module, _ModuleMap) ->
-  ok;
-spawn_parallel_checker(CheckerInfo, Module, ModuleMap) ->
+spawn_parallel_checker(CheckerInfo, ModuleMap, E) ->
   Log =
     case erlang:get(elixir_code_diagnostics) of
       {_, false} -> false;
       _ -> true
     end,
-  'Elixir.Module.ParallelChecker':spawn(CheckerInfo, Module, ModuleMap, Log).
+
+  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);
+    true ->
+      ModuleMap
+  end.
 
 make_module_available(Module, Binary) ->
   case get(elixir_module_binaries) of