More progress

Author: josevalim

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

@@ -472,7 +472,6 @@ defmodule Module.Types.Apply do
   Returns the type of a remote capture.
   """
   def remote_capture(modules, fun, arity, meta, stack, context) do
-    # TODO: Do we check when the union of functions is invalid?
     # TODO: Deal with :infer types
     if stack.mode == :traversal or modules == [] do
       {dynamic(fun(arity)), context}
@@ -829,14 +828,17 @@ defmodule Module.Types.Apply do
 
     message =
       case reason do
-        # TODO: Return the domain here
-        {:badarg, _} ->
+        {:badarg, domain} ->
           """
-          expected a #{length(args_types)}-arity function on call:
+          incompatible types given on function application:
 
               #{expr_to_string(expr) |> indent(4)}
 
-          but got type:
+          given types:
+
+              #{args_to_quoted_string(args_types, domain, &Function.identity/1) |> indent(4)}
+
+          but function has type:
 
               #{to_quoted_string(fun_type) |> indent(4)}
           """

lib/elixir/lib/module/types/helpers.ex

@@ -324,6 +324,15 @@ defmodule Module.Types.Helpers do
       {{:., _, [mod, fun]}, meta, args} ->
         erl_to_ex(mod, fun, args, meta)
 
+      {:&, amp_meta, [{:/, slash_meta, [{{:., dot_meta, [mod, fun]}, call_meta, []}, arity]}]} ->
+        {mod, fun} =
+          case :elixir_rewrite.erl_to_ex(mod, fun, arity) do
+            {mod, fun} -> {mod, fun}
+            false -> {mod, fun}
+          end
+
+        {:&, amp_meta, [{:/, slash_meta, [{{:., dot_meta, [mod, fun]}, call_meta, []}, arity]}]}
+
       {:case, meta, [expr, [do: clauses]]} = case ->
         if meta[:type_check] == :expr do
           case clauses do

lib/elixir/src/elixir_rewrite.erl

@@ -44,13 +44,16 @@
   inner_rewrite(erl_to_ex, _Meta, ErlMod, ErlFun, ErlArgs) -> {ExMod, ExFun, ExArgs, fun(ErlArgs) -> ExArgs end}
 ).
 
-erl_to_ex(Mod, Fun, Args) ->
+erl_to_ex(Mod, Fun, Args) when is_list(Args) ->
   case inner_inline(erl_to_ex, Mod, Fun, length(Args)) of
     false -> inner_rewrite(erl_to_ex, [], Mod, Fun, Args);
     {ExMod, ExFun} -> {ExMod, ExFun, Args, fun identity/1}
-  end.
+  end;
+
+erl_to_ex(Mod, Fun, Arity) when is_integer(Arity) ->
+  inner_inline(erl_to_ex, Mod, Fun, Arity).
 
-%% Inline  rules
+%% Inline rules
 %%
 %% Inline rules are straightforward, they keep the same
 %% number and order of arguments and show up on captures.

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

@@ -139,7 +139,7 @@ defmodule Module.Types.ExprTest do
              ) == dynamic(fun(2))
     end
 
-    test "incompatible" do
+    test "bad function" do
       assert typeerror!([%x{}, a1, a2], x.(a1, a2)) == ~l"""
              expected a 2-arity function on call:
 
@@ -156,6 +156,30 @@ defmodule Module.Types.ExprTest do
                  %x{}
              """
     end
+
+    test "bad arity" do
+      assert typeerror!([a1, a2], (&String.to_integer/1).(a1, a2)) == ~l"""
+             expected a 2-arity function on call:
+
+                 (&String.to_integer/1).(a1, a2)
+
+             but got function with arity 1:
+
+                 (binary() -> integer())
+             """
+    end
+
+    test "bad argument" do
+      assert typeerror!([%a{}], (&String.to_integer/1).(a)) == ~l"""
+             expected a 2-arity function on call:
+
+                 (&String.to_integer/1).(a1, a2)
+
+             but got function with arity 1:
+
+                 (binary() -> integer())
+             """
+    end
   end
 
   describe "remotes" do