Improve case error message and improve performance

Author: josevalim

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

@@ -2767,16 +2767,9 @@ defmodule Module.Types.Descr do
     if subtype?(v2, v1), do: :right_subtype_of_left
   end
 
-  defp map_top?(bdd_leaf(:open, fields)) when map_size(fields) == 0, do: true
-  defp map_top?(_), do: false
-
-  defp map_intersection(bdd1, bdd2) do
-    cond do
-      map_top?(bdd1) and is_tuple(bdd2) -> bdd2
-      map_top?(bdd2) and is_tuple(bdd1) -> bdd1
-      true -> map_bdd_intersection(bdd1, bdd2)
-    end
-  end
+  defp map_intersection(bdd_leaf(:open, []), bdd), do: bdd
+  defp map_intersection(bdd, bdd_leaf(:open, [])), do: bdd
+  defp map_intersection(bdd1, bdd2), do: map_bdd_intersection(bdd1, bdd2)
 
   # A variant of bdd_intersection/3 that only continues if the maps are closed
   # or both sides are leafs.
@@ -2853,6 +2846,9 @@ defmodule Module.Types.Descr do
     end
   end
 
+  defp map_difference(bdd_leaf(:open, []), bdd2),
+    do: bdd_negation(bdd2)
+
   defp map_difference(bdd1, bdd2),
     do: bdd_difference(bdd1, bdd2, &map_leaf_disjoint?/2)
 
@@ -4343,6 +4339,9 @@ defmodule Module.Types.Descr do
 
   defp tuple_new(tag, elements), do: bdd_leaf(tag, elements)
 
+  defp tuple_intersection(bdd_leaf(:open, []), bdd), do: bdd
+  defp tuple_intersection(bdd, bdd_leaf(:open, [])), do: bdd
+
   defp tuple_intersection(bdd1, bdd2) do
     bdd_intersection(bdd1, bdd2, &tuple_leaf_intersection/2)
   end
@@ -4401,6 +4400,12 @@ defmodule Module.Types.Descr do
     end
   end
 
+  defp tuple_difference(bdd_leaf(:open, []), bdd_leaf(:open, [])),
+    do: :bdd_bot
+
+  defp tuple_difference(bdd_leaf(:open, []), bdd2),
+    do: bdd_negation(bdd2)
+
   defp tuple_difference(bdd1, bdd2),
     do: bdd_difference(bdd1, bdd2, &tuple_leaf_disjoint?/2)
 

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

@@ -734,11 +734,10 @@ defmodule Module.Types.Expr do
           {failed?, context} = reset_failed(context, failed?)
           {patterns, guards} = extract_head(head)
 
-          clause_domain = difference(domain, previous)
-          info = {:case, case_meta, clause_domain, case_expr, previous}
+          info = {:case, case_meta, domain, case_expr, previous}
 
           {trees, precise?, context} =
-            Pattern.of_head(patterns, guards, [clause_domain], info, meta, stack, context)
+            Pattern.of_head(patterns, guards, [domain], [previous], info, meta, stack, context)
 
           # It failed, let's try to detect if it was due a previous or current clause.
           # The current clause will be easier to understand, so we prefer that

lib/elixir/lib/module/types/pattern.ex

@@ -127,10 +127,11 @@ defmodule Module.Types.Pattern do
   4. Then we propagate all dependencies to refine variables
 
   """
-  def of_head(patterns, guards, expected, tag, meta, stack, %{vars: vars} = context) do
+  def of_head(patterns, guards, expected, previous \\ nil, tag, meta, stack, context) do
+    %{vars: vars} = context
     stack = %{stack | meta: meta}
 
-    case of_pattern_args(patterns, expected, tag, stack, context) do
+    case of_pattern_args(patterns, expected, previous, tag, stack, context) do
       {trees, pattern_precise?, changed, context} ->
         {guard_precise?, context} = of_guards(guards, changed, vars, stack, context)
         {trees, pattern_precise? and guard_precise?, context}
@@ -157,20 +158,23 @@ defmodule Module.Types.Pattern do
     []
   end
 
-  defp of_pattern_args([], [], _tag, _stack, context) do
+  defp of_pattern_args([], [], _previous, _tag, _stack, context) do
     {[], true, [], context}
   end
 
-  defp of_pattern_args(patterns, expected, tag, stack, context) do
+  defp of_pattern_args(patterns, expected, previous, tag, stack, context) do
     context = init_pattern_info(context, [])
 
     {trees, precise?, context} =
       of_pattern_args_zip(patterns, expected, 0, [], true, stack, context)
 
     {pattern_info, context} = pop_pattern_info(context)
 
-    case of_pattern_intersect(trees, 0, [], pattern_info, tag, stack, context) do
-      {_types, changed, context} -> {trees, precise?, changed, context}
+    with {:ok, types} <- of_pattern_intersect(trees, 0, [], pattern_info, tag, stack, context),
+         {_types, changed, context} <-
+           of_pattern_refine(types, previous, pattern_info, tag, stack, context) do
+      {trees, precise?, changed, context}
+    else
       {:error, context} -> {trees, context}
     end
   end
@@ -210,8 +214,11 @@ defmodule Module.Types.Pattern do
     args = [{tree, expected, expr}]
     tag = {:match, expected}
 
-    case of_pattern_intersect(args, 0, [], pattern_info, tag, stack, context) do
-      {[type], changed, context} -> {type, of_changed(changed, stack, context)}
+    with {:ok, types} <- of_pattern_intersect(args, 0, [], pattern_info, tag, stack, context),
+         {[type], changed, context} <-
+           of_pattern_refine(types, nil, pattern_info, tag, stack, context) do
+      {type, of_changed(changed, stack, context)}
+    else
       {:error, context} -> {expected, context}
     end
   end
@@ -228,11 +235,12 @@ defmodule Module.Types.Pattern do
     {pattern_info, context} = pop_pattern_info(context)
     args = [{tree, expected, pattern}]
 
-    case of_pattern_intersect(args, 0, [], pattern_info, tag, stack, context) do
-      {_types, changed, context} ->
-        {_precise?, context} = of_guards(guards, changed, vars, stack, context)
-        context
-
+    with {:ok, types} <- of_pattern_intersect(args, 0, [], pattern_info, tag, stack, context),
+         {_types, changed, context} <-
+           of_pattern_refine(types, nil, pattern_info, tag, stack, context) do
+      {_precise?, context} = of_guards(guards, changed, vars, stack, context)
+      context
+    else
       {:error, context} ->
         context
     end
@@ -251,8 +259,20 @@ defmodule Module.Types.Pattern do
     end
   end
 
-  defp of_pattern_intersect([], _index, acc, pattern_info, tag, stack, context) do
-    types = Enum.reverse(acc)
+  defp of_pattern_intersect([], _index, acc, _pattern_info, _tag, _stack, _context) do
+    {:ok, Enum.reverse(acc)}
+  end
+
+  defp of_pattern_refine(types, previous, pattern_info, tag, stack, context) do
+    types =
+      case previous do
+        nil ->
+          types
+
+        [previous] ->
+          [type] = types
+          [difference(type, previous)]
+      end
 
     try do
       pattern_info
@@ -1381,11 +1401,11 @@ defmodule Module.Types.Pattern do
       true ->
         {pattern,
          """
-         the following clause cannot match because previous clauses already matched this pattern:
+         the following clause is redundant:
 
              #{expr_to_string(pattern) |> indent(4)} ->
 
-         the following types have already been matched:
+         the following types are expected (and have already been matched):
 
              #{to_quoted_string(previous_type) |> indent(4)}
          """}

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

@@ -1713,11 +1713,11 @@ defmodule Module.Types.ExprTest do
                  :ok -> 2
                end
              ) == ~l"""
-             the following clause cannot match because previous clauses already matched this pattern:
+             the following clause is redundant:
 
                  :ok ->
 
-             the following types have already been matched:
+             the following types are expected (and have already been matched):
 
                  :ok
              """
@@ -1729,11 +1729,11 @@ defmodule Module.Types.ExprTest do
                  {x, y} when is_integer(x) and is_integer(y) -> 2
                end
              ) =~ ~l"""
-             the following clause cannot match because previous clauses already matched this pattern:
+             the following clause is redundant:
 
                  {x, y} when is_integer(x) and is_integer(y) ->
 
-             the following types have already been matched:
+             the following types are expected (and have already been matched):
 
                  {integer(), integer()}
              """