Analyze conditional on :erlang.or/2 and :erlang.and/2

Author: josevalim

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

@@ -874,11 +874,13 @@ defmodule Module.Types.Pattern do
   end
 
   defp of_remote(fun, _meta, [left, right], call, expected, stack, context)
-       when fun in [:andalso, :orelse] do
-    {both_domain, abort_domain} =
+       when fun in [:and, :or, :andalso, :orelse] do
+    {both_domain, abort_domain, always_rhs?} =
       case fun do
-        :andalso -> {@atom_true, @atom_false}
-        :orelse -> {@atom_false, @atom_true}
+        :andalso -> {@atom_true, @atom_false, false}
+        :orelse -> {@atom_false, @atom_true, false}
+        :and -> {@atom_true, @atom_false, true}
+        :or -> {@atom_false, @atom_true, true}
       end
 
     # For example, if the expected type is true for andalso, then it can
@@ -887,7 +889,23 @@ defmodule Module.Types.Pattern do
     if subtype?(expected, both_domain) do
       of_logical_both(left, both_domain, right, expected, abort_domain, call, stack, context)
     else
-      of_logical_cond(left, right, expected, abort_domain, call, stack, context)
+      cond_context = %{context | conditional_vars: %{}}
+
+      # Compute the sure types, which are stored directly in the context
+      {_type, context} = of_guard(left, boolean(), call, stack, context)
+
+      # andalso/orelse may not execute the rhs, so we cannot get sure types from it
+      context =
+        case always_rhs? do
+          true ->
+            {_, context} = of_guard(right, boolean(), call, stack, context)
+            context
+
+          false ->
+            context
+        end
+
+      of_logical_cond(left, right, expected, abort_domain, call, stack, context, cond_context)
     end
   end
 
@@ -912,13 +930,7 @@ defmodule Module.Types.Pattern do
     end
   end
 
-  defp of_logical_cond(left, right, expected, to_abort, call, stack, context) do
-    cond_context = %{context | conditional_vars: %{}}
-
-    # First we do pass to find the surely types, which are stored directly in the context
-    {_left_type, context} = of_guard(left, boolean(), call, stack, context)
-
-    # Now we find the conditional ones
+  defp of_logical_cond(left, right, expected, to_abort, call, stack, context, cond_context) do
     {left_type, left_context} = of_guard(left, expected, call, stack, cond_context)
     {right_type, right_context} = of_guard(right, expected, call, stack, cond_context)
 

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

@@ -486,7 +486,7 @@ defmodule Module.Types.PatternTest do
                dynamic(tuple([term(), term()]))
     end
 
-    test "conditional checks" do
+    test "conditional checks (andalso/orelse)" do
       assert typecheck!([x], is_binary(x) or is_atom(x), x) == dynamic(union(binary(), atom()))
 
       assert typecheck!([x], is_binary(x) or map_size(x) >= 0, x) ==
@@ -495,6 +495,9 @@ defmodule Module.Types.PatternTest do
       assert typecheck!([x, y], is_binary(x) or is_atom(y), {x, y}) ==
                dynamic(tuple([term(), term()]))
 
+      assert typecheck!([x, y], is_binary(x) or map_size(y) >= 0, {x, y}) ==
+               dynamic(tuple([term(), term()]))
+
       assert typecheck!([x], not (is_pid(x) and is_atom(x)), x) |> equal?(dynamic(term()))
 
       assert typecheck!([x, y], not (is_pid(x) and is_atom(y)), {x, y}) ==
@@ -534,6 +537,59 @@ defmodule Module.Types.PatternTest do
              """
     end
 
+    test "conditional checks (and/or)" do
+      assert typecheck!([x], :erlang.or(is_binary(x), is_atom(x)), x) ==
+               dynamic(union(binary(), atom()))
+
+      assert typecheck!([x], :erlang.or(is_binary(x), map_size(x) >= 0), x) ==
+               dynamic(open_map())
+
+      assert typecheck!([x, y], :erlang.or(is_binary(x), is_atom(y)), {x, y}) ==
+               dynamic(tuple([term(), term()]))
+
+      assert typecheck!([x, y], :erlang.or(is_binary(x), map_size(y) >= 0), {x, y}) ==
+               dynamic(tuple([term(), open_map()]))
+
+      assert typecheck!([x], not :erlang.and(is_pid(x), is_atom(x)), x) |> equal?(dynamic(term()))
+
+      assert typecheck!([x, y], not :erlang.and(is_pid(x), is_atom(y)), {x, y}) ==
+               dynamic(tuple([term(), term()]))
+
+      # Error
+      assert typeerror!([x], :erlang.and(is_pid(x), is_atom(x)), x) == ~l"""
+             this guard will never succeed:
+
+                 :erlang.and(is_pid(x), is_atom(x))
+
+             because it returns type:
+
+                 false
+
+             where "x" was given the type:
+
+                 # type: pid()
+                 # from: types_test.ex:LINE
+                 is_pid(x)
+             """
+
+      assert typeerror!([x], :erlang.and(:erlang.or(is_binary(x), is_atom(x)), is_pid(x)), x) ==
+               ~l"""
+               this guard will never succeed:
+
+                   :erlang.and(:erlang.or(is_binary(x), is_atom(x)), is_pid(x))
+
+               because it returns type:
+
+                   false
+
+               where "x" was given the type:
+
+                   # type: dynamic(atom() or binary())
+                   # from: types_test.ex:LINE-1
+                   :erlang.or(is_binary(x), is_atom(x))
+               """
+    end
+
     test "domain checks" do
       # Regular domain check
       assert typecheck!([x], length(x) == 3, x) == dynamic(list(term()))