Compute negated types from precise none() branches

Author: josevalim

lib/elixir/lib/module/types.ex

@@ -329,7 +329,7 @@ defmodule Module.Types do
           info = {base_info, args, guards}
 
           try do
-            {trees, head_no_previous_args_types, previous, head_context} =
+            {trees, _precise?, head_no_previous_args_types, previous, head_context} =
               Pattern.of_head(args, guards, expected, previous, info, meta, stack, fresh_context)
 
             {return_type, context} =

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

@@ -369,19 +369,41 @@ defmodule Module.Types.Expr do
       of_expr(body, expected, body, stack, reset_warnings(refined_context, context))
     end
 
-    result_context =
-      cache_arrows(meta, stack, fn ->
-        of_clauses_fun(clauses, [case_type], info, stack, context, of_body, [], fn
-          trees, body_type, context, acc ->
-            [arg_type] = Pattern.of_domain(trees, stack, context)
-            [{arg_type, body_type} | acc]
-        end)
-      end) ||
-        of_clauses_fun(clauses, [case_type], info, stack, context, of_body, none(), fn
-          _trees, body_type, _context, acc -> union(acc, body_type)
-        end)
+    {{head_type, body_type}, _, context} =
+      cache_arrows(meta, stack, fn cache? ->
+        acc = {none(), 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}
+              end
+          end)
+
+        {{head_acc, body_acc}, clauses_acc, context}
+      end)
+
+    context =
+      if head_type == none() do
+        context
+      else
+        {_, refined_context} =
+          of_expr(case_expr, head_type, case_expr, %{stack | reverse_arrow: :use}, context)
 
-    dynamic_unless_static(result_context, stack)
+        reset_warnings(refined_context, context)
+      end
+
+    dynamic_unless_static({body_type, context}, stack)
   end
 
   # fn pat -> expr end
@@ -395,7 +417,7 @@ defmodule Module.Types.Expr do
 
       {acc, context} =
         of_clauses_fun(clauses, domain, :fn, stack, context, of_body, [], fn
-          trees, body_type, context, acc ->
+          trees, _precise?, body_type, context, acc ->
             args_types = Pattern.of_domain(trees, stack, context)
             add_inferred(acc, args_types, body_type)
         end)
@@ -828,19 +850,18 @@ defmodule Module.Types.Expr do
     end
   end
 
-  defp cache_arrows(_meta, %{reverse_arrow: nil}, _fun), do: nil
+  defp cache_arrows(_meta, %{reverse_arrow: nil}, fun), do: fun.(false)
 
   defp cache_arrows(meta, %{reverse_arrow: :cache}, fun) do
-    {clauses, context} = fun.()
+    {result, cache, context} = fun.(true)
     version = Keyword.fetch!(meta, :version)
-    context = put_in(context.reverse_arrows[version], clauses)
-    result = Enum.reduce(clauses, none(), &union(elem(&1, 1), &2))
-    {result, context}
+    context = put_in(context.reverse_arrows[version], cache)
+    {result, cache, context}
   end
 
   defp of_clauses(clauses, domain, expected, base_info, stack, context, acc) do
     of_body = fn _args_types, body, context -> of_expr(body, expected, body, stack, context) end
-    of_acc = fn _args_types, body_type, _context, acc -> union(acc, body_type) end
+    of_acc = fn _args_types, _precise?, body_type, _context, acc -> union(acc, body_type) end
     of_clauses_fun(clauses, domain, base_info, stack, context, of_body, acc, of_acc)
   end
 
@@ -854,12 +875,12 @@ defmodule Module.Types.Expr do
           {patterns, guards} = extract_head(head)
           info = {base_info, head}
 
-          {trees, _, previous, context} =
+          {trees, precise?, _, previous, context} =
             Pattern.of_head(patterns, guards, domain, previous, info, meta, stack, context)
 
           {result, context} = of_body.(trees, body, context)
 
-          {of_acc.(trees, result, context, acc), previous,
+          {of_acc.(trees, precise?, result, context, acc), previous,
            context |> set_failed(failed?) |> Of.reset_vars(original)}
       end)
 

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

@@ -192,28 +192,28 @@ defmodule Module.Types.Pattern do
       # First we check if it fails without previous, if it doesn't, check if it is redundant.
       case of_precise_head(patterns, guards, expected, init_previous(), tag, stack, original) do
         {other_trees, _, _, _, %{failed: true} = other_context} ->
-          {other_trees, args_types, previous, other_context}
+          {other_trees, false, args_types, previous, other_context}
 
         {other_trees, _, _, args_types, other_context} ->
           if previous_subtype?(args_types, previous) do
             warning = {:redundant, tag, expected, args_types, previous, other_context}
             context = warn(__MODULE__, warning, meta, stack, other_context)
-            {other_trees, args_types, previous, context}
+            {other_trees, false, args_types, previous, context}
           else
-            {trees, args_types, previous, context}
+            {trees, false, args_types, previous, context}
           end
       end
     else
       cond do
         check_previous? and previous_subtype?(args_types, previous) ->
           warning = {:redundant, tag, expected, args_types, previous, context}
-          {trees, args_types, previous, warn(__MODULE__, warning, meta, stack, context)}
+          {trees, false, args_types, previous, warn(__MODULE__, warning, meta, stack, context)}
 
         precise? ->
-          {trees, args_types, concat_previous(args_types, previous), context}
+          {trees, true, args_types, concat_previous(args_types, previous), context}
 
         true ->
-          {trees, args_types, previous, context}
+          {trees, false, args_types, previous, context}
       end
     end
   end

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

@@ -1812,6 +1812,42 @@ defmodule Module.Types.ExprTest do
                atom([:non_empty_map, :maybe_empty_map])
     end
 
+    test "computes types from dead branches" do
+      assert typecheck!(
+               [x],
+               (
+                 if is_integer(x) do
+                   raise "bad"
+                 end
+
+                 x
+               )
+             ) == dynamic(negation(integer()))
+
+      assert typecheck!(
+               [x],
+               (
+                 if x == :foo do
+                   raise "bad"
+                 end
+
+                 x
+               )
+             ) == dynamic(negation(atom([:foo])))
+
+      # When it is not precise enough, we don't filter
+      assert typecheck!(
+               [x],
+               (
+                 if x == "foo" do
+                   raise "bad"
+                 end
+
+                 x
+               )
+             ) == dynamic()
+    end
+
     test "warns on redundant clauses" do
       assert typewarn!(
                [x],

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

@@ -156,10 +156,10 @@ defmodule TypeHelper do
     init_previous = Pattern.init_previous()
     tag = {:fn, patterns}
 
-    {_trees, _, previous, _context} =
+    {_trees, precise?, _args_types, _previous, _context} =
       Pattern.of_head(patterns, guards, expected, init_previous, tag, [], stack, new_context())
 
-    previous != init_previous
+    precise?
   end
 
   def __typecheck__(mode, patterns, guards, body) do
@@ -168,7 +168,7 @@ defmodule TypeHelper do
     previous = Pattern.init_previous()
     tag = {:fn, patterns}
 
-    {_trees, _, _, context} =
+    {_trees, _, _, _, context} =
       Pattern.of_head(patterns, guards, expected, previous, tag, [], stack, new_context())
 
     Expr.of_expr(body, Descr.term(), :ok, stack, context)