Track types across case clauses (#15080)

Author: josevalim

lib/elixir/lib/kernel.ex

@@ -2069,15 +2069,20 @@ defmodule Kernel do
   end
 
   defp build_boolean_check(operator, check, true_clause, false_clause) do
-    annotate_case(
-      [optimize_boolean: true, type_check: :expr],
+    bools =
       quote do
-        case unquote(check) do
-          false -> unquote(false_clause)
-          true -> unquote(true_clause)
-          other -> :erlang.error({:badbool, unquote(operator), other})
-        end
+        false -> unquote(false_clause)
+        true -> unquote(true_clause)
       end
+
+    error =
+      quote generated: true do
+        other -> :erlang.error({:badbool, unquote(operator), other})
+      end
+
+    annotate_case(
+      [optimize_boolean: true, type_check: :expr],
+      {:case, [], [check, [do: bools ++ error]]}
     )
   end
 

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

@@ -478,6 +478,7 @@ defmodule Module.Types.Descr do
   Computes the difference between two types.
   """
   def difference(left, :term), do: keep_optional(left)
+  def difference(left, none) when none == @none, do: left
 
   def difference(left, right) do
     if gradual?(left) or gradual?(right) do

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

@@ -295,7 +295,6 @@ defmodule Module.Types.Expr 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_type, case_expr}
 
     added_meta =
       if Macro.quoted_literal?(case_expr) do
@@ -312,7 +311,7 @@ defmodule Module.Types.Expr do
     else
       clauses
     end
-    |> of_clauses([case_type], expected, expr, info, stack, context, none())
+    |> of_case_clauses(case_type, expected, meta, case_expr, expr, stack, context)
     |> dynamic_unless_static(stack)
   end
 
@@ -726,6 +725,63 @@ defmodule Module.Types.Expr do
     end)
   end
 
+  defp of_case_clauses(clauses, domain, expected, case_meta, case_expr, expr, stack, original) do
+    %{failed: failed?} = original
+
+    {result, _previous, context} =
+      Enum.reduce(clauses, {none(), none(), original}, fn
+        {:->, meta, [[clause] = head, body]}, {acc, previous, context} ->
+          {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}
+
+          {trees, precise?, context} =
+            Pattern.of_head(patterns, guards, [clause_domain], 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
+          {[{clause_tree, _, _}], precise?, context} =
+            if context.failed and previous != none() do
+              info = {:case, case_meta, domain, case_expr, nil}
+
+              case Pattern.of_head(patterns, guards, [domain], info, meta, stack, context) do
+                {_, _, %{failed: true}} = result -> result
+                _ -> {trees, precise?, context}
+              end
+            else
+              {trees, precise?, context}
+            end
+
+          {previous, context} =
+            if context.failed do
+              {previous, context}
+            else
+              clause_type = Pattern.of_pattern_tree(clause_tree, stack, context) |> upper_bound()
+
+              cond do
+                stack.mode != :infer and previous != none() and subtype?(clause_type, previous) ->
+                  stack = %{stack | meta: meta}
+                  {previous, Pattern.badpattern_error(clause, 0, info, stack, context)}
+
+                precise? ->
+                  {union(previous, clause_type), context}
+
+                true ->
+                  {previous, context}
+              end
+            end
+
+          {result, context} = of_expr(body, expected, expr || body, stack, context)
+
+          {union(result, acc), previous,
+           context |> set_failed(failed?) |> Of.reset_vars(original)}
+      end)
+
+    {result, context}
+  end
+
   defp reset_failed(%{failed: true} = context, false), do: {true, %{context | failed: false}}
   defp reset_failed(context, _), do: {false, context}
 
@@ -773,6 +829,25 @@ defmodule Module.Types.Expr do
 
   ## Warning formatting
 
+  def format_diagnostic({:badclause, {:case, meta, type, expr}, [head], context}) do
+    {expr, message} =
+      if meta[:type_check] == :expr do
+        {expr,
+         """
+         the following conditional expression will always evaluate to #{to_quoted_string(type)}:
+
+             #{expr_to_string(expr) |> indent(4)}
+         """}
+      else
+        {head, "the following clause has no effect because a previous clause will always match\n"}
+      end
+
+    %{
+      details: %{typing_traces: collect_traces(expr, context)},
+      message: message
+    }
+  end
+
   def format_diagnostic({:badupdate, type, expr, context}) do
     {:%, _, [module, {:%{}, _, [{:|, _, [map, _]}]}]} = expr
     traces = collect_traces(map, context)

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

@@ -143,8 +143,9 @@ defmodule Module.Types.Helpers do
   """
   def collect_traces(expr, %{vars: vars}) do
     {_, versions} =
-      Macro.prewalk(expr, %{}, fn
-        {var_name, meta, var_context}, versions when is_atom(var_name) and is_atom(var_context) ->
+      Macro.prewalk(expr, %{}, fn node, versions ->
+        with {var_name, meta, var_context} when is_atom(var_name) and is_atom(var_context) <- node,
+             false <- String.starts_with?(Atom.to_string(var_name), "_") do
           version = meta[:version]
 
           case vars do
@@ -160,9 +161,9 @@ defmodule Module.Types.Helpers do
             _ ->
               {:ok, versions}
           end
-
-        node, versions ->
-          {node, versions}
+        else
+          _ -> {node, versions}
+        end
       end)
 
     versions

lib/elixir/lib/module/types/of.ex

@@ -86,11 +86,13 @@ defmodule Module.Types.Of do
   or if we are doing a guard analysis or occurrence typing.
   Returns `true` if there was a refinement, `false` otherwise.
   """
-  def refine_body_var({_, meta, _}, type, expr, stack, context) do
-    refine_body_var(Keyword.fetch!(meta, :version), type, expr, stack, context)
+  def refine_body_var(var_or_version, type, expr, stack, context, allow_empty? \\ false)
+
+  def refine_body_var({_, meta, _}, type, expr, stack, context, allow_empty?) do
+    refine_body_var(Keyword.fetch!(meta, :version), type, expr, stack, context, allow_empty?)
   end
 
-  def refine_body_var(version, type, expr, stack, context)
+  def refine_body_var(version, type, expr, stack, context, allow_empty?)
       when is_integer(version) or is_reference(version) do
     %{vars: %{^version => %{type: old_type, off_traces: off_traces} = data} = vars} = context
 
@@ -105,6 +107,15 @@ defmodule Module.Types.Of do
 
     if gradual?(old_type) and type not in [term(), dynamic()] and not is_map_key(data, :errored) do
       case compatible_intersection(old_type, type) do
+        {:error, _} when allow_empty? ->
+          data = %{
+            data
+            | type: none(),
+              off_traces: new_trace(expr, none(), stack, off_traces)
+          }
+
+          {none(), %{context | vars: %{vars | version => data}}}
+
         {:ok, new_type} when new_type != old_type ->
           data = %{
             data