Fix regression where we inferred the wrong type in a case branch that raises

Author: josevalim

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

@@ -369,38 +369,34 @@ defmodule Module.Types.Expr do
       of_expr(body, expected, body, stack, reset_warnings(refined_context, context))
     end
 
-    {{head_type, body_type}, _, context} =
-      cache_arrows(meta, stack, fn cache? ->
-        acc = {none(), none(), []}
+    {{none?, body_type}, clauses_acc, context} =
+      cache_arrows(meta, stack, fn _cache? ->
+        acc = {false, none(), []}
 
         {{head_acc, body_acc, clauses_acc}, context} =
           of_clauses_fun(clauses, [case_type], info, stack, context, of_body, acc, fn
-            trees, precise?, body_type, context, {head_acc, body_acc, clauses_acc} ->
-              cond do
-                precise? and empty?(body_type) ->
-                  [arg_type] = Pattern.of_domain(trees, stack, context)
-                  {union(negation(arg_type), head_acc), body_acc, clauses_acc}
-
-                cache? ->
-                  [arg_type] = Pattern.of_domain(trees, stack, context)
-                  {head_acc, union(body_type, body_acc), [{arg_type, body_type} | clauses_acc]}
-
-                true ->
-                  {head_acc, union(body_type, body_acc), clauses_acc}
+            trees, precise?, body_type, context, {none?, body_acc, clauses_acc} ->
+              if precise? and empty?(body_type) do
+                {true, body_acc, clauses_acc}
+              else
+                [arg_type] = Pattern.of_domain(trees, stack, context)
+                {none?, union(body_type, body_acc), [{arg_type, body_type} | clauses_acc]}
               end
           end)
 
         {{head_acc, body_acc}, clauses_acc, context}
       end)
 
     context =
-      if head_type == none() do
-        context
-      else
+      if none? do
+        head_type = Enum.reduce(clauses_acc, none(), &union(elem(&1, 0), &2))
+
         {_, refined_context} =
           of_expr(case_expr, head_type, case_expr, %{stack | reverse_arrow: :use}, context)
 
         reset_warnings(refined_context, context)
+      else
+        context
       end
 
     dynamic_unless_static({body_type, context}, stack)

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

@@ -1812,7 +1812,7 @@ defmodule Module.Types.ExprTest do
                atom([:non_empty_map, :maybe_empty_map])
     end
 
-    test "computes types from dead branches" do
+    test "computes types from dead branches (conditional)" do
       assert typecheck!(
                [x],
                (
@@ -1848,6 +1848,45 @@ defmodule Module.Types.ExprTest do
              ) == dynamic()
     end
 
+    test "computes types from dead branches (case)" do
+      assert typecheck!(
+               [x, key],
+               (
+                 case x do
+                   %{^key => value} -> {:ok, value}
+                   %{} -> raise "bad"
+                 end
+
+                 x
+               )
+             ) == dynamic(open_map())
+
+      assert typecheck!(
+               [x],
+               (
+                 case x do
+                   %{foo: _} -> :ok
+                   %{} -> raise "bad"
+                 end
+
+                 x
+               )
+             ) == dynamic(open_map(foo: term()))
+
+      assert typecheck!(
+               [x, key],
+               (
+                 case x do
+                   %{foo: _} -> :ok
+                   %{^key => value} -> {:value, value}
+                   %{} -> raise "bad"
+                 end
+
+                 x
+               )
+             ) == dynamic(open_map())
+    end
+
     test "warns on redundant clauses" do
       assert typewarn!(
                [x],