Infer types and use them across remote calls

Author: josevalim

lib/elixir/lib/code.ex

@@ -249,6 +249,7 @@ defmodule Code do
     :debug_info,
     :ignore_already_consolidated,
     :ignore_module_conflict,
+    :infer_signatures,
     :relative_paths,
     :warnings_as_errors
   ]
@@ -1638,6 +1639,10 @@ 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 inference
+      module-local signatures used when type checking remote calls to the compiled
+      module. Type checking it still executed. Defaults to `true`.
+
     * `: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

@@ -191,7 +191,8 @@ defmodule Module.ParallelChecker do
   or if the function does not exist return `{:error, :function}`.
   """
   @spec fetch_export(cache(), module(), atom(), arity()) ::
-          {:ok, mode(), kind(), binary() | nil} | {:error, :function | :module}
+          {:ok, mode(), binary() | nil, {:infer, [term()]} | :none}
+          | {:error, :function | :module}
   def fetch_export({server, ets}, module, fun, arity) do
     case :ets.lookup(ets, module) do
       [] ->
@@ -203,7 +204,7 @@ defmodule Module.ParallelChecker do
 
       [{_key, mode}] ->
         case :ets.lookup(ets, {module, {fun, arity}}) do
-          [{_key, reason}] -> {:ok, mode, reason}
+          [{_key, reason, signature}] -> {:ok, mode, reason, signature}
           [] -> {:error, :function}
         end
     end
@@ -369,13 +370,13 @@ defmodule Module.ParallelChecker do
             true ->
               {mode, exports} = info_exports(module)
               deprecated = info_deprecated(module)
-              cache_info(ets, module, exports, deprecated, mode)
+              cache_info(ets, module, exports, deprecated, %{}, mode)
 
             false ->
               # Or load exports from chunk
               with {^module, binary, _filename} <- object_code,
                    {:ok, {^module, [exports: exports]}} <- :beam_lib.chunks(binary, [:exports]) do
-                cache_info(ets, module, exports, %{}, :erlang)
+                cache_info(ets, module, exports, %{}, %{}, :erlang)
               else
                 _ ->
                   :ets.insert(ets, {module, false})
@@ -417,25 +418,28 @@ defmodule Module.ParallelChecker do
         behaviour_exports(map) ++
         for({function, :def, _meta, _clauses} <- map.definitions, do: function)
 
-    deprecated = Map.new(map.deprecated)
-    cache_info(ets, map.module, exports, deprecated, :elixir)
+    cache_info(ets, map.module, exports, Map.new(map.deprecated), map.signatures, :elixir)
   end
 
-  defp cache_info(ets, module, exports, deprecated, mode) do
-    Enum.each(exports, fn {fun, arity} ->
-      reason = Map.get(deprecated, {fun, arity})
-      :ets.insert(ets, {{module, {fun, arity}}, reason})
+  defp cache_info(ets, module, exports, deprecated, sigs, mode) do
+    Enum.each(exports, fn fa ->
+      reason = Map.get(deprecated, fa)
+      :ets.insert(ets, {{module, fa}, reason, Map.get(sigs, fa, :none)})
     end)
 
     :ets.insert(ets, {module, mode})
   end
 
   defp cache_chunk(ets, module, exports) do
     Enum.each(exports, fn {{fun, arity}, info} ->
-      :ets.insert(ets, {{module, {fun, arity}}, Map.get(info, :deprecated)})
+      # TODO: Match on signature directly in Elixir v1.22+
+      :ets.insert(
+        ets,
+        {{module, {fun, arity}}, Map.get(info, :deprecated), Map.get(info, :sig, :none)}
+      )
     end)
 
-    :ets.insert(ets, {{module, {:__info__, 1}}, nil})
+    :ets.insert(ets, {{module, {:__info__, 1}}, nil, :none})
     :ets.insert(ets, {module, :elixir})
   end
 

lib/elixir/lib/module/types.ex

@@ -1,37 +1,55 @@
 defmodule Module.Types do
   @moduledoc false
 
-  alias Module.Types.{Expr, Pattern}
+  alias Module.Types.{Descr, Expr, Pattern}
+
+  @doc false
+  def infer(module, file, defs, env) do
+    context = context()
+
+    for {{fun, arity}, :def, _meta, clauses} <- defs, into: %{} do
+      stack = stack(:infer, file, module, {fun, arity}, :all, env)
+      expected = List.duplicate(Descr.dynamic(), arity)
+
+      pair_types =
+        Enum.map(clauses, fn {meta, args, guards, body} ->
+          try do
+            {args, context} =
+              Pattern.of_head(args, guards, expected, :default, meta, stack, context)
+
+            {return, _context} = Expr.of_expr(body, stack, context)
+            {args, return}
+          rescue
+            e -> internal_error!(e, __STACKTRACE__, :def, meta, module, fun, args, guards, body)
+          end
+        end)
+
+      # TODO: Reuse context from patterns and guards
+      # TODO: Simplify pair types
+      # TODO: Handle local calls
+      {{fun, arity}, {:infer, pair_types}}
+    end
+  end
 
   @doc false
   def warnings(module, file, defs, no_warn_undefined, cache) do
     context = context()
 
-    Enum.flat_map(defs, fn {{fun, arity} = function, kind, meta, clauses} ->
-      stack =
-        stack(:dynamic, with_file_meta(meta, file), module, function, no_warn_undefined, cache)
+    Enum.flat_map(defs, fn {{fun, arity}, kind, meta, clauses} ->
+      file = with_file_meta(meta, file)
+      stack = stack(:dynamic, file, module, {fun, arity}, no_warn_undefined, cache)
+      expected = List.duplicate(Descr.dynamic(), arity)
 
       Enum.flat_map(clauses, fn {meta, args, guards, body} ->
         try do
-          warnings_from_clause(meta, args, guards, body, stack, context)
+          {_types, context} =
+            Pattern.of_head(args, guards, expected, :default, meta, stack, context)
+
+          {_type, context} = Expr.of_expr(body, stack, context)
+          context.warnings
         rescue
           e ->
-            def_expr = {kind, meta, [guards_to_expr(guards, {fun, [], args}), [do: body]]}
-
-            error =
-              RuntimeError.exception("""
-              found error while checking types for #{Exception.format_mfa(module, fun, arity)}:
-
-              #{Exception.format_banner(:error, e, __STACKTRACE__)}\
-
-              The exception happened while checking this code:
-
-              #{Macro.to_string(def_expr)}
-
-              Please report this bug at: https://github.com/elixir-lang/elixir/issues
-              """)
-
-            reraise error, __STACKTRACE__
+            internal_error!(e, __STACKTRACE__, kind, meta, module, fun, args, guards, body)
         end
       end)
     end)
@@ -44,6 +62,25 @@ defmodule Module.Types do
     end
   end
 
+  defp internal_error!(e, stack, kind, meta, module, fun, args, guards, body) do
+    def_expr = {kind, meta, [guards_to_expr(guards, {fun, [], args}), [do: body]]}
+
+    exception =
+      RuntimeError.exception("""
+      found error while checking types for #{Exception.format_mfa(module, fun, length(args))}:
+
+      #{Exception.format_banner(:error, e, stack)}\
+
+      The exception happened while checking this code:
+
+      #{Macro.to_string(def_expr)}
+
+      Please report this bug at: https://github.com/elixir-lang/elixir/issues
+      """)
+
+    reraise exception, stack
+  end
+
   defp guards_to_expr([], left) do
     left
   end
@@ -52,14 +89,6 @@ defmodule Module.Types do
     guards_to_expr(guards, {:when, [], [left, guard]})
   end
 
-  defp warnings_from_clause(meta, args, guards, body, stack, context) do
-    dynamic = Module.Types.Descr.dynamic()
-    expected = Enum.map(args, fn _ -> dynamic end)
-    {_types, context} = Pattern.of_head(args, guards, expected, :default, meta, stack, context)
-    {_type, context} = Expr.of_expr(body, stack, context)
-    context.warnings
-  end
-
   @doc false
   def stack(mode, file, module, function, no_warn_undefined, cache)
       when mode in [:static, :dynamic, :infer] do
@@ -72,9 +101,9 @@ defmodule Module.Types do
       module: module,
       # Current function
       function: function,
-      # List of calls to not warn on as undefined
+      # List of calls to not warn on as undefined or :all
       no_warn_undefined: no_warn_undefined,
-      # A list of cached modules received from the parallel compiler
+      # A tuple with cache information or a Macro.Env struct indicating no remote traversals
       cache: cache,
       # The mode controls what happens on function application when
       # there are gradual arguments. Non-gradual arguments always

lib/elixir/lib/module/types/of.ex

@@ -207,13 +207,19 @@ defmodule Module.Types.Of do
   Returns `__info__(:struct)` information about a struct.
   """
   def struct_info(struct, meta, stack, context) do
-    {_, context} = remote(struct, :__struct__, 0, meta, stack, context)
+    case stack.cache do
+      %Macro.Env{} = env ->
+        {Macro.struct_info!(struct, env), context}
 
-    info =
-      struct.__info__(:struct) ||
-        raise "expected #{inspect(struct)} to return struct metadata, but got none"
+      _ ->
+        {_, context} = export(struct, :__struct__, 0, meta, stack, context)
+
+        info =
+          struct.__info__(:struct) ||
+            raise "expected #{inspect(struct)} to return struct metadata, but got none"
 
-    {info, context}
+        {info, context}
+    end
   end
 
   @doc """
@@ -803,6 +809,21 @@ defmodule Module.Types.Of do
     end
   end
 
+  defp apply_remote({:infer, clauses}, args_types, _stack) do
+    case for({expected, return} <- clauses, zip_not_disjoint?(args_types, expected), do: return) do
+      [] ->
+        domain =
+          clauses
+          |> Enum.map(fn {args, _} -> args end)
+          |> Enum.zip_with(fn types -> Enum.reduce(types, &union/2) end)
+
+        {:error, domain, clauses}
+
+      returns ->
+        {:ok, returns |> Enum.reduce(&union/2) |> dynamic()}
+    end
+  end
+
   defp zip_compatible_or_only_gradual?([actual | actuals], [expected | expecteds]) do
     (only_gradual?(actual) or compatible?(actual, expected)) and
       zip_compatible_or_only_gradual?(actuals, expecteds)
@@ -826,11 +847,15 @@ defmodule Module.Types.Of do
     {remote(:module_info, arity), context}
   end
 
+  defp export(_module, _fun, _arity, _meta, %{cache: %Macro.Env{}}, context) do
+    {:none, context}
+  end
+
   defp export(module, fun, arity, meta, stack, context) do
     case ParallelChecker.fetch_export(stack.cache, module, fun, arity) do
-      {:ok, mode, reason} ->
-        {remote(fun, arity),
-         check_deprecated(mode, module, fun, arity, reason, meta, stack, context)}
+      {:ok, mode, reason, info} ->
+        info = if info == :none, do: remote(fun, arity), else: info
+        {info, check_deprecated(mode, module, fun, arity, reason, meta, stack, context)}
 
       {:error, type} ->
         context =

lib/elixir/src/elixir.erl

@@ -88,6 +88,7 @@ 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

@@ -143,11 +143,12 @@ bootstrap() ->
   {ok, _} = application:ensure_all_started(elixir),
   elixir_config:static(#{bootstrap => true}),
   elixir_config:put(docs, false),
-  elixir_config:put(relative_paths, false),
   elixir_config:put(ignore_module_conflict, true),
+  elixir_config:put(infer_signatures, false),
   elixir_config:put(on_undefined_variable, raise),
-  elixir_config:put(tracers, []),
   elixir_config:put(parser_options, []),
+  elixir_config:put(relative_paths, false),
+  elixir_config:put(tracers, []),
   {Init, Main} = bootstrap_files(),
   {ok, Cwd} = file:get_cwd(),
   Lib = filename:join(Cwd, "lib/elixir/lib"),

lib/elixir/src/elixir_erl.erl

@@ -612,14 +612,15 @@ 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(Def, #{deprecated := Deprecated, defines_behaviour := DefinesBehaviour}) ->
+checker_chunk(Def, #{deprecated := Deprecated, defines_behaviour := DefinesBehaviour, signatures := Signatures}) ->
   DeprecatedMap = maps:from_list(Deprecated),
 
   Exports =
     [begin
+      Signature = maps:get(FA, Signatures, none),
       Info = case DeprecatedMap of
-        #{FA := Reason} -> #{deprecated => Reason};
-        #{} -> #{}
+        #{FA := Reason} -> #{deprecated => Reason, sig => Signature};
+        #{} -> #{sig => Signature}
       end,
       {FA, Info}
     end || {FA, _Meta} <- prepend_behaviour_info(DefinesBehaviour, Def)],

lib/elixir/src/elixir_module.erl

@@ -167,6 +167,11 @@ compile(Meta, Module, ModuleAsCharlist, Block, Vars, Prune, E) ->
         [elixir_env:trace({remote_function, [], VerifyMod, VerifyFun, 1}, CallbackE) ||
          {VerifyMod, VerifyFun} <- AfterVerify],
 
+        Signatures = case elixir_config:get(infer_signatures) of
+          true -> 'Elixir.Module.Types':infer(Module, File, AllDefinitions, CallbackE);
+          false -> #{}
+        end,
+
         ModuleMap = #{
           struct => get_struct(DataSet),
           module => Module,
@@ -180,7 +185,8 @@ compile(Meta, Module, ModuleAsCharlist, Block, Vars, Prune, E) ->
           compile_opts => CompileOpts,
           deprecated => get_deprecated(DataBag),
           defines_behaviour => defines_behaviour(DataBag),
-          impls => Impls
+          impls => Impls,
+          signatures => Signatures
         },
 
         case ets:member(DataSet, {elixir, taint}) of

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

@@ -0,0 +1,45 @@
+Code.require_file("type_helper.exs", __DIR__)
+
+defmodule Module.Types.InferTest do
+  use ExUnit.Case, async: true
+
+  import Module.Types.Descr
+
+  defmacro infer(config, do: block) do
+    quote do
+      defmodule unquote(config).test do
+        unquote(block)
+      end
+      |> runtime_infer()
+    end
+  end
+
+  defp runtime_infer({:module, module, binary, _result}) do
+    {:ok, {_, [debug_info: chunk]}} = :beam_lib.chunks(binary, [:debug_info])
+    {:debug_info_v1, backend, data} = chunk
+    {:ok, %{signatures: signatures}} = backend.debug_info(:elixir_v1, module, data, [])
+    signatures
+  end
+
+  test "infer types from patterns", config do
+    types =
+      infer config do
+        def fun1(%y{}, %x{}, x = y, x = Point), do: :ok
+        def fun2(%x{}, %y{}, x = y, x = Point), do: :ok
+        def fun3(%y{}, %x{}, x = y, y = Point), do: :ok
+        def fun4(%x{}, %y{}, x = y, y = Point), do: :ok
+      end
+
+    args = [
+      dynamic(open_map(__struct__: atom([Point]))),
+      dynamic(open_map(__struct__: atom([Point]))),
+      dynamic(atom([Point])),
+      dynamic(atom([Point]))
+    ]
+
+    assert types[{:fun1, 4}] == {:infer, [{args, atom([:ok])}]}
+    assert types[{:fun2, 4}] == {:infer, [{args, atom([:ok])}]}
+    assert types[{:fun3, 4}] == {:infer, [{args, atom([:ok])}]}
+    assert types[{:fun4, 4}] == {:infer, [{args, atom([:ok])}]}
+  end
+end