Type checking of apply/2 and apply/3

Author: josevalim

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

@@ -145,6 +145,8 @@ defmodule Module.Types.Apply do
         {:erlang, :>, [{[term(), term()], boolean()}]},
         {:erlang, :>=, [{[term(), term()], boolean()}]},
         {:erlang, :abs, [{[integer()], integer()}, {[float()], float()}]},
+        {:erlang, :apply, [{[fun(), list(term())], dynamic()}]},
+        {:erlang, :apply, [{[atom(), atom(), list(term())], dynamic()}]},
         {:erlang, :and, and_signature},
         {:erlang, :atom_to_binary, [{[atom()], binary()}]},
         {:erlang, :atom_to_list, [{[atom()], list(integer())}]},

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

@@ -404,6 +404,36 @@ defmodule Module.Types.Expr do
     end
   end
 
+  def of_expr({{:., _, [remote, :apply]}, _meta, [mod, fun, args]} = expr, stack, context)
+      when remote in [Kernel, :erlang] and is_list(args) do
+    {mod_type, context} = of_expr(mod, stack, context)
+    {fun_type, context} = of_expr(fun, stack, context)
+    improper_list? = Enum.any?(args, &match?({:|, _, [_, _]}, &1))
+
+    case atom_fetch(fun_type) do
+      {_, [_ | _] = funs} when not improper_list? ->
+        mods =
+          case atom_fetch(mod_type) do
+            {_, mods} -> mods
+            _ -> []
+          end
+
+        {args_types, context} = Enum.map_reduce(args, context, &of_expr(&1, stack, &2))
+
+        {types, context} =
+          Enum.map_reduce(funs, context, fn fun, context ->
+            apply_many(mods, fun, args, args_types, expr, stack, context)
+          end)
+
+        {Enum.reduce(types, &union/2), context}
+
+      _ ->
+        {args_type, context} = of_expr(args, stack, context)
+        args_types = [mod_type, fun_type, args_type]
+        Apply.remote(:erlang, :apply, [mod, fun, args], args_types, expr, stack, context)
+    end
+  end
+
   def of_expr({{:., _, [remote, name]}, meta, args} = expr, stack, context) do
     {remote_type, context} = of_expr(remote, stack, context)
     {args_types, context} = Enum.map_reduce(args, context, &of_expr(&1, stack, &2))

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

@@ -1472,6 +1472,44 @@ defmodule Module.Types.ExprTest do
     end
   end
 
+  describe "apply" do
+    test "handles conditional modules and functions" do
+      assert typecheck!([fun], apply(String, fun, ["foo", "bar", "baz"])) == dynamic()
+
+      assert typecheck!(
+               [condition, string],
+               (
+                 fun = if condition, do: :to_integer, else: :to_float
+                 apply(String, fun, [string])
+               )
+             ) == union(integer(), float())
+
+      assert typecheck!(
+               [condition, string],
+               (
+                 mod = if condition, do: String, else: List
+                 fun = if condition, do: :to_integer, else: :to_float
+                 apply(mod, fun, [string])
+               )
+             ) == union(integer(), float())
+
+      assert typeerror!(
+               [condition, string],
+               (
+                 mod = if condition, do: String, else: List
+                 fun = if condition, do: :to_integer, else: :to_float
+                 :erlang.apply(mod, fun, [string | "tail"])
+               )
+             ) =~
+               """
+               incompatible types given to Kernel.apply/3:
+
+                   apply(mod, fun, [string | "tail"])
+
+               """
+    end
+  end
+
   describe "info" do
     test "__info__/1" do
       assert typecheck!(GenServer.__info__(:functions)) == list(tuple([atom(), integer()]))

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

@@ -138,7 +138,7 @@ defmodule TypeHelper do
 
   defp new_stack(mode) do
     cache = if mode == :infer, do: :none, else: Module.ParallelChecker.test_cache()
-    handler = fn _, _, _, _ -> raise "no local lookup" 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