Unify boolean checks into a single operation

Author: josevalim

lib/elixir/lib/module/types/apply.ex

@@ -503,14 +503,14 @@ defmodule Module.Types.Apply do
        )
        when is_data_size(fun, literal) do
     case booleaness(expected) do
-      :undefined ->
+      booleaness when booleaness in [:maybe_both, :none] ->
         compare(name, left, literal, false, expr, stack, context, of_fun)
 
-      boolean ->
+      booleaness ->
         {polarity, return} =
-          case boolean do
-            :always_true -> {name in [:==, :"=:="], @atom_true}
-            :always_false -> {name in [:"/=", :"=/="], @atom_false}
+          case booleaness do
+            :maybe_true -> {name in [:==, :"=:="], @atom_true}
+            :maybe_false -> {name in [:"/=", :"=/="], @atom_false}
           end
 
         expected =
@@ -559,16 +559,16 @@ defmodule Module.Types.Apply do
       case {left, right} do
         {{{:., _, [:erlang, fun]}, _, [arg]}, size} when is_data_size(fun, size) ->
           case booleaness(expected) do
-            :always_true -> sized_order(name, fun, size, arg, @atom_true)
-            :always_false -> sized_order(invert_order(name), fun, size, arg, @atom_false)
-            :undefined -> :none
+            :maybe_true -> sized_order(name, fun, size, arg, @atom_true)
+            :maybe_false -> sized_order(invert_order(name), fun, size, arg, @atom_false)
+            _ -> :none
           end
 
         {size, {{:., _, [:erlang, fun]}, _, [arg]}} when is_data_size(fun, size) ->
           case booleaness(expected) do
-            :always_true -> sized_order(invert_order(name), fun, size, arg, @atom_true)
-            :always_false -> sized_order(name, fun, size, arg, @atom_false)
-            :undefined -> :none
+            :maybe_true -> sized_order(invert_order(name), fun, size, arg, @atom_true)
+            :maybe_false -> sized_order(name, fun, size, arg, @atom_false)
+            _ -> :none
           end
 
         _ ->

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

@@ -913,57 +913,40 @@ defmodule Module.Types.Descr do
   # an empty list of atoms. It is simplified to `0` in set operations, and the key
   # is removed from the map.
 
-  @false_or_nil_atoms [
-    :sets.from_list([false, nil], version: 2),
-    :sets.from_list([nil], version: 2),
-    :sets.from_list([false], version: 2)
-  ]
-
-  @false_atoms :sets.from_list([false], version: 2)
-  @true_atoms :sets.from_list([true], version: 2)
-
-  @doc """
-  Returns true if the type can never be true.
-  """
-  def never_true?(:term), do: false
-
-  def never_true?(%{} = descr) do
-    descr = Map.get(descr, :dynamic, descr)
-
-    case descr do
-      :term -> false
-      %{atom: {:union, %{true => _}}} -> false
-      %{atom: {:union, _}} -> true
-      %{atom: {:negation, %{true => _}}} -> true
-      %{atom: {:negation, _}} -> false
-      _ -> true
-    end
-  end
-
   @doc """
   Compute the booleaness of an element.
 
-  It is either :undefined, :always_true, or :always_false.
+  It is either `:none`, `:maybe_true` (therefore never false),
+  `:maybe_false` (therefore never true), or `:maybe_both`.
+
+  This is an optimization against checking if a term is
+  not disjoint on either true or false.
   """
-  def booleaness(:term), do: :undefined
+  def booleaness(:term), do: :maybe_both
 
   def booleaness(%{} = descr) do
     descr = Map.get(descr, :dynamic, descr)
 
     case descr do
-      %{atom: {:union, set}}
-      when map_size(descr) == 1 and set == @false_atoms ->
-        :always_false
-
-      %{atom: {:union, set}}
-      when map_size(descr) == 1 and set == @true_atoms ->
-        :always_true
-
-      _ ->
-        :undefined
+      :term -> :maybe_both
+      %{atom: {:union, %{true: _, false: _}}} -> :maybe_both
+      %{atom: {:union, %{true: _}}} -> :maybe_true
+      %{atom: {:union, %{false: _}}} -> :maybe_false
+      %{atom: {:union, _}} -> :none
+      %{atom: {:negation, %{true: _, false: _}}} -> :none
+      %{atom: {:negation, %{true: _}}} -> :maybe_false
+      %{atom: {:negation, %{false: _}}} -> :maybe_true
+      %{atom: {:negation, _}} -> :maybe_both
+      _ -> :none
     end
   end
 
+  @false_or_nil_atoms [
+    :sets.from_list([false, nil], version: 2),
+    :sets.from_list([nil], version: 2),
+    :sets.from_list([false], version: 2)
+  ]
+
   @doc """
   Compute the truthiness of an element.
 

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

@@ -786,7 +786,7 @@ defmodule Module.Types.Pattern do
   end
 
   defp maybe_badguard(type, guard, stack, context) do
-    if never_true?(type) do
+    if booleaness(type) in [:maybe_false, :none] do
       error = {:badguard, type, guard, context}
       error(__MODULE__, error, error_meta(guard, stack), stack, context)
     else

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

@@ -1225,21 +1225,25 @@ defmodule Module.Types.DescrTest do
   end
 
   describe "projections" do
-    test "never_true?" do
-      for type <- [
-            none(),
-            integer(),
-            atom([false]),
-            atom([:other, false]),
-            negation(atom([true]))
-          ] do
-        assert never_true?(type)
-        assert never_true?(dynamic(type))
+    test "booleaness" do
+      for type <- [none(), open_map(), negation(boolean()), difference(atom(), boolean())] do
+        assert booleaness(type) == :none
+        assert booleaness(dynamic(type)) == :none
       end
 
-      for type <- [atom([true]), boolean(), atom(), term(), negation(atom([false]))] do
-        refute never_true?(type)
-        refute never_true?(dynamic(type))
+      for type <- [term(), dynamic(), atom(), boolean()] do
+        assert booleaness(type) == :maybe_both
+        assert booleaness(dynamic(type)) == :maybe_both
+      end
+
+      for type <- [atom([false]), negation(atom([true]))] do
+        assert booleaness(type) == :maybe_false
+        assert booleaness(dynamic(type)) == :maybe_false
+      end
+
+      for type <- [atom([true]), negation(atom([false]))] do
+        assert booleaness(type) == :maybe_true
+        assert booleaness(dynamic(type)) == :maybe_true
       end
     end