Compute redundant clauses for receive

Author: josevalim

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

@@ -306,8 +306,9 @@ defmodule Module.Types.Expr do
     |> dynamic_unless_static(stack)
   end
 
-  def of_expr({:case, meta, [case_expr, [{:do, clauses}]]}, expected, expr, stack, context) do
+  def of_expr({:case, meta, [case_expr, [{:do, clauses}]]}, expected, _expr, stack, context) do
     {case_type, context} = of_expr(case_expr, @pending, case_expr, stack, context)
+    info = {:case, meta, case_expr}
 
     added_meta =
       if Macro.quoted_literal?(case_expr) do
@@ -324,7 +325,7 @@ defmodule Module.Types.Expr do
     else
       clauses
     end
-    |> of_case_clauses(case_type, expected, meta, case_expr, expr, stack, context)
+    |> of_redundant_clauses(case_type, expected, info, stack, context, none())
     |> dynamic_unless_static(stack)
   end
 
@@ -398,7 +399,7 @@ defmodule Module.Types.Expr do
         acc_context
 
       {:do, clauses}, {acc, context} ->
-        of_clauses(clauses, [dynamic()], expected, expr, :receive, stack, context, acc)
+        of_redundant_clauses(clauses, dynamic(), expected, :receive, stack, context, acc)
 
       {:after, [{:->, meta, [[timeout], body]}] = after_expr}, {acc, context} ->
         {timeout_type, context} = of_expr(timeout, @timeout_type, after_expr, stack, context)
@@ -737,16 +738,16 @@ defmodule Module.Types.Expr do
     end)
   end
 
-  defp of_case_clauses(clauses, domain, expected, case_meta, case_expr, expr, stack, original) do
+  defp of_redundant_clauses(clauses, domain, expected, clause_info, stack, original, acc) do
     %{failed: failed?} = original
 
     {result, _previous, context} =
-      Enum.reduce(clauses, {none(), none(), original}, fn
+      Enum.reduce(clauses, {acc, none(), original}, fn
         {:->, meta, [[clause] = head, body]}, {acc, previous, context} ->
           {failed?, context} = reset_failed(context, failed?)
           {patterns, guards} = extract_head(head)
 
-          info = {:case, case_meta, domain, case_expr, previous}
+          info = {clause_info, [domain], [previous]}
 
           {trees, precise?, context} =
             Pattern.of_head(patterns, guards, [domain], [previous], info, meta, stack, context)
@@ -755,7 +756,7 @@ defmodule Module.Types.Expr do
           # The current clause will be easier to understand, so we prefer that
           {[{clause_tree, _, _}], precise?, context} =
             if context.failed and previous != none() do
-              info = {:case, case_meta, domain, case_expr, nil}
+              info = {clause_info, [domain], [none()]}
 
               case Pattern.of_head(patterns, guards, [domain], info, meta, stack, context) do
                 {_, _, %{failed: true}} = result -> result
@@ -784,7 +785,7 @@ defmodule Module.Types.Expr do
               end
             end
 
-          {result, context} = of_expr(body, expected, expr || body, stack, context)
+          {result, context} = of_expr(body, expected, body, stack, context)
 
           {union(result, acc), previous,
            context |> set_failed(failed?) |> Of.reset_vars(original)}

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

@@ -1347,7 +1347,7 @@ defmodule Module.Types.Pattern do
   #
   # $ typep head_pattern =
   #     :for_reduce or :with_else or :receive or :try_catch or :fn or :default or
-  #       {:try_else, type} or {:case, meta, type, expr, previous_type}
+  #       {:try_else, type} or {{:case, meta, expr}, [domain], [previous_type]}
   #
   # $ typep match_pattern =
   #     :with or :for or {:match, type}
@@ -1383,7 +1383,7 @@ defmodule Module.Types.Pattern do
      """}
   end
 
-  defp badpattern({:case, meta, type, expr, previous_type}, pattern, _) do
+  defp badpattern({{:case, meta, expr}, [type], [previous_type]}, pattern, _) do
     cond do
       meta[:type_check] == :expr ->
         error_type = if previous_type == none(), do: type, else: previous_type
@@ -1445,6 +1445,19 @@ defmodule Module.Types.Pattern do
     end
   end
 
+  defp badpattern({:receive, [_type], [previous_type]}, pattern, _) do
+    {pattern,
+     """
+     the following clause is redundant:
+
+         #{expr_to_string(pattern) |> indent(4)} ->
+
+     previous clauses have already matched on the following types:
+
+         #{to_quoted_string(previous_type) |> indent(4)}
+     """}
+  end
+
   defp badpattern({:match, type}, expr, _) do
     {expr,
      """

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

@@ -1956,6 +1956,32 @@ defmodule Module.Types.ExprTest do
              ) == dynamic()
     end
 
+    test "computess difference across clauses" do
+      assert typecheck!(
+               receive do
+                 x when is_binary(x) -> :ok
+                 y -> {:other, y}
+               end
+             ) == union(atom([:ok]), dynamic(tuple([atom([:other]), negation(binary())])))
+    end
+
+    test "errors on redundant clauses" do
+      assert typeerror!(
+               receive do
+                 x when is_binary(x) -> x
+                 "foo" -> "bar"
+               end
+             ) == """
+             the following clause is redundant:
+
+                 "foo" ->
+
+             previous clauses have already matched on the following types:
+
+                 binary()
+             """
+    end
+
     test "errors on bad timeout" do
       assert typeerror!(
                [x = :timeout],