Infer with built-ins

Author: josevalim

lib/elixir/lib/module/types.ex

@@ -33,8 +33,8 @@ defmodule Module.Types do
   @no_infer [__protocol__: 1, behaviour_info: 1]
 
   @doc false
-  def infer(module, file, defs, private, used_private, env) do
-    infer_signatures? = :elixir_config.get(:infer_signatures)
+  def infer(module, file, defs, private, used_private, env, {_, cache}) do
+    infer_signatures? = :elixir_config.get(:infer_signatures) and cache != nil
 
     finder =
       fn fun_arity ->
@@ -60,7 +60,7 @@ defmodule Module.Types do
       end
     end
 
-    stack = stack(:infer, file, module, {:__info__, 1}, :all, env, handler)
+    stack = stack(:infer, file, module, {:__info__, 1}, env, cache, handler)
 
     {types, %{local_sigs: reachable_sigs} = context} =
       for {fun_arity, kind, meta, _clauses} = def <- defs,
@@ -316,9 +316,9 @@ defmodule Module.Types do
       module: module,
       # Current function
       function: function,
-      # List of calls to not warn on as undefined or :all
+      # List of calls to not warn on as undefined or :all or Macro.Env indicating limited remotes
       no_warn_undefined: no_warn_undefined,
-      # A tuple with cache information or a Macro.Env struct indicating no remote traversals
+      # A tuple with cache information (may be nil)
       cache: cache,
       # The mode to be used, see the @modes attribute
       mode: mode,

lib/elixir/lib/module/types/apply.ex

@@ -429,6 +429,26 @@ defmodule Module.Types.Apply do
     end
   end
 
+  @doc """
+  Returns the type of a remote capture.
+  """
+  def remote_capture(modules, fun, arity, meta, stack, context) do
+    # TODO: We cannot return the unions of functions. Do we forbid this?
+    # Do we check it is always the same return type? Do we simply say it is a function?
+    if stack.mode == :traversal do
+      {dynamic(fun()), context}
+    else
+      context =
+        Enum.reduce(
+          modules,
+          context,
+          &(signature(&1, fun, arity, meta, stack, &2) |> elem(1))
+        )
+
+      {dynamic(fun()), context}
+    end
+  end
+
   @doc """
   Gets a mfa signature.
 
@@ -461,25 +481,30 @@ defmodule Module.Types.Apply do
     {signature(: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, %{cache: cache} = stack, context) do
+    cond do
+      cache == nil or stack.mode == :traversal ->
+        {:none, context}
 
-  defp export(module, fun, arity, meta, stack, context) do
-    case ParallelChecker.fetch_export(stack.cache, module, fun, arity) do
-      {:ok, mode, reason, info} ->
-        info = if info == :none, do: signature(fun, arity), else: info
-        {info, check_deprecated(mode, module, fun, arity, reason, meta, stack, context)}
+      stack.mode == :infer and not builtin_module?(module) ->
+        {:none, context}
 
-      {:error, type} ->
-        context =
-          if warn_undefined?(module, fun, arity, stack) do
-            warn(__MODULE__, {:undefined, type, module, fun, arity}, meta, stack, context)
-          else
-            context
-          end
+      true ->
+        case ParallelChecker.fetch_export(stack.cache, module, fun, arity) do
+          {:ok, mode, reason, info} ->
+            info = if info == :none, do: signature(fun, arity), else: info
+            {info, check_deprecated(mode, module, fun, arity, reason, meta, stack, context)}
 
-        {:none, context}
+          {:error, type} ->
+            context =
+              if warn_undefined?(module, fun, arity, stack) do
+                warn(__MODULE__, {:undefined, type, module, fun, arity}, meta, stack, context)
+              else
+                context
+              end
+
+            {:none, context}
+        end
     end
   end
 
@@ -507,6 +532,27 @@ defmodule Module.Types.Apply do
     end
   end
 
+  defp builtin_module?(module) do
+    is_map_key(builtin_modules(), module)
+  end
+
+  defp builtin_modules do
+    case :persistent_term.get(__MODULE__, nil) do
+      nil ->
+        {:ok, mods} = :application.get_key(:elixir, :modules)
+        mods = Map.from_keys(mods, [])
+        :persistent_term.put(__MODULE__, mods)
+        mods
+
+      %{} = mods ->
+        mods
+    end
+  end
+
+  defp warn_undefined?(_, _, _, %{no_warn_undefined: %Macro.Env{}}) do
+    false
+  end
+
   defp warn_undefined?(_, _, _, %{no_warn_undefined: :all}) do
     false
   end
@@ -572,14 +618,14 @@ defmodule Module.Types.Apply do
         {dynamic(fun()), context}
 
       {_kind, _info, context} when stack.mode == :traversal ->
-        {fun(), context}
+        {dynamic(fun()), context}
 
       {kind, _info, context} ->
         if stack.mode != :infer and kind == :defp do
           # Mark all clauses as used, as the function is being exported.
-          {fun(), put_in(context.local_used[fun_arity], [])}
+          {dynamic(fun()), put_in(context.local_used[fun_arity], [])}
         else
-          {fun(), context}
+          {dynamic(fun()), context}
         end
     end
   end

lib/elixir/lib/module/types/expr.ex

@@ -401,19 +401,8 @@ defmodule Module.Types.Expr do
       )
       when is_atom(name) and is_integer(arity) do
     {remote_type, context} = of_expr(remote, stack, context)
-
-    # TODO: We cannot return the unions of functions. Do we forbid this?
-    # Do we check it is always the same return type? Do we simply say it is a function?
     {mods, context} = Of.modules(remote_type, name, arity, expr, meta, stack, context)
-
-    context =
-      Enum.reduce(
-        mods,
-        context,
-        &(Apply.signature(&1, name, arity, meta, stack, &2) |> elem(1))
-      )
-
-    {dynamic(fun()), context}
+    Apply.remote_capture(mods, name, arity, meta, stack, context)
   end
 
   # TODO: &foo/1

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

@@ -216,7 +216,7 @@ defmodule Module.Types.Of do
   Returns `__info__(:struct)` information about a struct.
   """
   def struct_info(struct, meta, stack, context) do
-    case stack.cache do
+    case stack.no_warn_undefined do
       %Macro.Env{} = env ->
         case :elixir_map.maybe_load_struct_info(meta, struct, [], false, env) do
           {:ok, info} -> {info, context}

lib/elixir/src/elixir_module.erl

@@ -188,7 +188,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, AllDefinitions, Private, UsedPrivate, E)
+              'Elixir.Module.Types':infer(Module, File, AllDefinitions, Private, UsedPrivate, E, CheckerInfo)
           end,
 
         RawCompileOpts = bag_lookup_element(DataBag, {accumulate, compile}, 2),
@@ -225,7 +225,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
+    (element(2, CheckerInfo) == nil) andalso
       [VerifyMod:VerifyFun(Module) ||
        {VerifyMod, VerifyFun} <- bag_lookup_element(DataBag, {accumulate, after_verify}, 2)],
     {module, Module, Binary, Result}
@@ -553,11 +553,11 @@ beam_location(ModuleAsCharlist) ->
 
 checker_info() ->
   case get(elixir_checker_info) of
-    undefined -> undefined;
+    undefined -> {self(), nil};
     _ -> 'Elixir.Module.ParallelChecker':get()
   end.
 
-spawn_parallel_checker(undefined, _Module, _ModuleMap) ->
+spawn_parallel_checker({_, nil}, _Module, _ModuleMap) ->
   ok;
 spawn_parallel_checker(CheckerInfo, Module, ModuleMap) ->
   Log =

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

@@ -7,14 +7,19 @@ defmodule Module.Types.InferTest do
 
   defmacro infer(config, do: block) do
     quote do
-      defmodule unquote(config).test do
-        unquote(block)
-      end
-      |> runtime_infer()
+      runtime_infer(unquote(config).test, unquote(Macro.escape(block)))
     end
   end
 
-  defp runtime_infer({:module, module, binary, _result}) do
+  defp runtime_infer(module, block) do
+    {{:module, _, binary, _}, []} =
+      Code.eval_quoted(
+        quote do
+          defmodule unquote(module), do: unquote(block)
+        end,
+        []
+      )
+
     {: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, [])
@@ -43,6 +48,16 @@ defmodule Module.Types.InferTest do
     assert types[{:fun4, 4}] == {:infer, [{args, atom([:ok])}]}
   end
 
+  test "infer with Elixir built-in", config do
+    types =
+      infer config do
+        def parse(string), do: Integer.parse(string)
+      end
+
+    assert types[{:parse, 1}] ==
+             {:infer, [{[dynamic()], dynamic(union(atom([:error]), tuple([integer(), term()])))}]}
+  end
+
   test "merges patterns", config do
     types =
       infer config do