Overlapping function clauses

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: Deal with :infer types
     if stack.mode == :traversal or modules == [] do
       {dynamic(fun(arity)), context}
     else
@@ -482,6 +481,9 @@ defmodule Module.Types.Apply do
             {{:strong, _, clauses}, context} ->
               {union(type, fun_from_non_overlapping_clauses(clauses)), fallback?, context}
 
+            {{:infer, _, clauses}, context} when length(clauses) <= @max_clauses ->
+              {union(type, fun_from_overlapping_clauses(clauses)), fallback?, context}
+
             {_, context} ->
               {type, true, context}
           end
@@ -694,13 +696,25 @@ defmodule Module.Types.Apply do
       {_kind, _info, context} when stack.mode == :traversal ->
         {dynamic(fun(arity)), context}
 
-      {kind, _info, context} ->
-        if stack.mode != :infer and kind == :defp do
-          # Mark all clauses as used, as the function is being exported.
-          {dynamic(fun(arity)), put_in(context.local_used[fun_arity], [])}
-        else
-          {dynamic(fun(arity)), context}
-        end
+      {kind, info, context} ->
+        result =
+          case info do
+            {:infer, _, clauses} when length(clauses) <= @max_clauses ->
+              fun_from_overlapping_clauses(clauses)
+
+            _ ->
+              dynamic(fun(arity))
+          end
+
+        context =
+          if stack.mode != :infer and kind == :defp do
+            # Mark all clauses as used, as the function is being exported.
+            put_in(context.local_used[fun_arity], [])
+          else
+            context
+          end
+
+        {result, context}
     end
   end
 

lib/elixir/lib/module/types/descr.ex

@@ -132,6 +132,43 @@ defmodule Module.Types.Descr do
     end)
   end
 
+  @doc """
+  Creates a function from overlapping function clauses.
+  """
+  def fun_from_overlapping_clauses(args_clauses) do
+    domain_clauses =
+      Enum.reduce(args_clauses, [], fn {args, return}, acc ->
+        pivot_overlapping_clause(args_to_domain(args), return, acc)
+      end)
+
+    funs =
+      for {domain, return} <- domain_clauses,
+          args <- domain_to_args(domain),
+          do: fun(args, return)
+
+    Enum.reduce(funs, &intersection/2)
+  end
+
+  defp pivot_overlapping_clause(domain, return, [{acc_domain, acc_return} | acc]) do
+    common = intersection(domain, acc_domain)
+
+    if empty?(common) do
+      [{acc_domain, acc_return} | pivot_overlapping_clause(domain, return, acc)]
+    else
+      [{common, union(return, acc_return)} | acc]
+      |> prepend_to_unless_empty(difference(domain, common), return)
+      |> prepend_to_unless_empty(difference(acc_domain, common), acc_return)
+    end
+  end
+
+  defp pivot_overlapping_clause(domain, return, []) do
+    [{domain, return}]
+  end
+
+  defp prepend_to_unless_empty(acc, domain, return) do
+    if empty?(domain), do: acc, else: [{domain, return} | acc]
+  end
+
   @doc """
   Converts a list of arguments into a domain.
 

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

@@ -751,6 +751,64 @@ defmodule Module.Types.DescrTest do
     end
   end
 
+  describe "function creation" do
+    test "fun_from_non_overlapping_clauses" do
+      assert fun_from_non_overlapping_clauses([{[integer()], atom()}, {[float()], binary()}]) ==
+               intersection(fun([integer()], atom()), fun([float()], binary()))
+    end
+
+    test "fun_from_overlapping_clauses" do
+      # No overlap
+      assert fun_from_overlapping_clauses([{[integer()], atom()}, {[float()], binary()}])
+             |> equal?(
+               fun_from_non_overlapping_clauses([{[integer()], atom()}, {[float()], binary()}])
+             )
+
+      # Subsets
+      assert fun_from_overlapping_clauses([{[integer()], atom()}, {[number()], binary()}])
+             |> equal?(
+               fun_from_non_overlapping_clauses([
+                 {[integer()], union(atom(), binary())},
+                 {[float()], binary()}
+               ])
+             )
+
+      assert fun_from_overlapping_clauses([{[number()], binary()}, {[integer()], atom()}])
+             |> equal?(
+               fun_from_non_overlapping_clauses([
+                 {[integer()], union(atom(), binary())},
+                 {[float()], binary()}
+               ])
+             )
+
+      # Partial
+      assert fun_from_overlapping_clauses([
+               {[union(integer(), pid())], atom()},
+               {[union(float(), pid())], binary()}
+             ])
+             |> equal?(
+               fun_from_non_overlapping_clauses([
+                 {[integer()], atom()},
+                 {[float()], binary()},
+                 {[pid()], union(atom(), binary())}
+               ])
+             )
+
+      # Difference
+      assert fun_from_overlapping_clauses([
+               {[integer(), union(pid(), atom())], atom()},
+               {[number(), pid()], binary()}
+             ])
+             |> equal?(
+               fun_from_non_overlapping_clauses([
+                 {[float(), pid()], binary()},
+                 {[integer(), atom()], atom()},
+                 {[integer(), pid()], union(atom(), binary())}
+               ])
+             )
+    end
+  end
+
   describe "function application" do
     defp none_fun(arity), do: fun(List.duplicate(none(), arity), term())
 

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

@@ -449,6 +449,7 @@ defmodule Module.Types.ExprTest do
   describe "remote capture" do
     test "strong" do
       assert typecheck!(&String.to_atom/1) == fun([binary()], atom())
+      assert typecheck!(&:erlang.element/2) == fun([integer(), open_tuple([])], dynamic())
     end
 
     test "unknown" do