Infer types from length, map_size, tuple_size equality checks

Author: josevalim

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

@@ -15,6 +15,9 @@ defmodule Module.Types.Apply do
   # reduce the computation cost of inferred code.
   @max_clauses 16
 
+  @atom_true atom([true])
+  @atom_false atom([false])
+
   ## Signatures
 
   # Define strong arrows found in the standard library.
@@ -359,25 +362,15 @@ defmodule Module.Types.Apply do
 
   # The functions implemented with custom do_remote functions work on values,
   # rather on types, hence the custom behaviour.
-  defp do_remote(:erlang, name, [left, right] = args, _expected, expr, stack, context, of_fun)
+  defp do_remote(:erlang, name, [left, right], expected, expr, stack, context, of_fun)
        when name in [:==, :"/=", :"=:=", :"=/="] do
-    {left_type, context} = of_fun.(left, term(), expr, stack, context)
-    {right_type, context} = of_fun.(right, term(), expr, stack, context)
-    result = return(boolean(), [left_type, right_type], stack)
-
-    cond do
-      not is_warning(stack) or Macro.quoted_literal?(args) ->
-        {result, context}
-
-      name in [:==, :"/="] and number_type?(left_type) and number_type?(right_type) ->
-        {result, context}
+    left_literal? = Macro.quoted_literal?(left)
+    right_literal? = Macro.quoted_literal?(right)
 
-      disjoint?(left_type, right_type) ->
-        error = {:mismatched_comparison, left_type, right_type}
-        remote_error(error, :erlang, name, 2, expr, stack, context)
-
-      true ->
-        {result, context}
+    case {left_literal?, right_literal?} do
+      {true, false} -> custom_compare(name, right, left, expected, expr, stack, context, of_fun)
+      {false, true} -> custom_compare(name, left, right, expected, expr, stack, context, of_fun)
+      {literal?, _} -> compare(name, left, right, literal?, expr, stack, context, of_fun)
     end
   end
 
@@ -479,6 +472,74 @@ defmodule Module.Types.Apply do
     remote_domain(mod, fun, args, expected, elem(expr, 1), stack, context)
   end
 
+  @empty_list empty_list()
+  @non_empty_list non_empty_list(term())
+  @empty_map empty_map()
+  @non_empty_map difference(open_map(), empty_map())
+
+  defp custom_compare(
+         name,
+         {{:., _, [:erlang, fun]}, _, [arg]} = left,
+         literal,
+         expected,
+         expr,
+         stack,
+         context,
+         of_fun
+       )
+       when fun in [:length, :map_size, :tuple_size] and is_integer(literal) and literal >= 0 do
+    case booleaness(expected) do
+      :undefined ->
+        compare(name, left, literal, false, expr, stack, context, of_fun)
+
+      boolean ->
+        {polarity, return} =
+          case boolean do
+            :always_true -> {name in [:==, :"=:="], @atom_true}
+            :always_false -> {name in [:"/=", :"=/="], @atom_false}
+          end
+
+        expected =
+          case fun do
+            :length when :erlang.xor(polarity, literal > 0) -> @empty_list
+            :length -> @non_empty_list
+            :map_size when :erlang.xor(polarity, literal > 0) -> @empty_map
+            :map_size -> @non_empty_map
+            :tuple_size when polarity -> tuple(List.duplicate(term(), literal))
+            :tuple_size -> difference(open_tuple([]), tuple(List.duplicate(term(), literal)))
+          end
+
+        {actual, context} = of_fun.(arg, expected, expr, stack, context)
+        result = if compatible?(actual, expected), do: return, else: boolean()
+        {result, context}
+    end
+  end
+
+  defp custom_compare(name, left, right, _expected, expr, stack, context, of_fun) do
+    compare(name, left, right, false, expr, stack, context, of_fun)
+  end
+
+  defp compare(name, left, right, literal?, expr, stack, context, of_fun) do
+    {left_type, context} = of_fun.(left, term(), expr, stack, context)
+    {right_type, context} = of_fun.(right, term(), expr, stack, context)
+    result = return(boolean(), [left_type, right_type], stack)
+
+    cond do
+      literal? or not is_warning(stack) ->
+        {result, context}
+
+      name in [:==, :"/="] and number_type?(left_type) and number_type?(right_type) ->
+        {result, context}
+
+      disjoint?(left_type, right_type) ->
+        error = {:mismatched_comparison, left_type, right_type}
+        remote_error(error, :erlang, name, 2, expr, stack, context)
+
+      true ->
+        {result, context}
+    end
+  end
+
   @doc """
   Returns the domain of an unknown module.
 

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

@@ -919,6 +919,9 @@ defmodule Module.Types.Descr do
     :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.
   """
@@ -937,6 +940,30 @@ defmodule Module.Types.Descr do
     end
   end
 
+  @doc """
+  Compute the booleaness of an element.
+
+  It is either :undefined, :always_true, or :always_false.
+  """
+  def booleaness(:term), do: :undefined
+
+  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
+    end
+  end
+
   @doc """
   Compute the truthiness of an element.
 

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

@@ -723,34 +723,34 @@ defmodule Module.Types.PatternTest do
 
     test "domain checks" do
       # Regular domain check
-      assert typecheck!([x], length(x) == 3, x) == dynamic(list(term()))
+      assert typecheck!([x, z], length(x) == z, x) == dynamic(list(term()))
 
       # erlang-or propagates
-      assert typecheck!([x, y], :erlang.or(length(x) == 3, map_size(y) == 1), {x, y}) ==
+      assert typecheck!([x, y, z], :erlang.or(length(x) == z, map_size(y) == z), {x, y}) ==
                dynamic(tuple([list(term()), open_map()]))
 
       # erlang-and propagates
-      assert typecheck!([x, y], :erlang.and(length(x) == 3, map_size(y) == 1), {x, y}) ==
+      assert typecheck!([x, y, z], :erlang.and(length(x) == z, map_size(y) == z), {x, y}) ==
                dynamic(tuple([list(term()), open_map()]))
 
       # or with mixed checks
-      assert typecheck!([x], length(x) == 3 or is_map(x), x) ==
+      assert typecheck!([x, z], length(x) == z or is_map(x), x) ==
                dynamic(list(term()))
 
       # or does not propagate
-      assert typecheck!([x, y], length(x) == 3 or map_size(y) == 1, {x, y}) ==
+      assert typecheck!([x, y, z], length(x) == z or map_size(y) == z, {x, y}) ==
                dynamic(tuple([list(term()), term()]))
 
       # and propagates
-      assert typecheck!([x, y], length(x) == 3 and map_size(y) == 1, {x, y}) ==
+      assert typecheck!([x, y, z], length(x) == z and map_size(y) == z, {x, y}) ==
                dynamic(tuple([list(term()), open_map()]))
 
       # not or does propagate
-      assert typecheck!([x, y], not (length(x) == 3 or map_size(y) == 1), {x, y}) ==
+      assert typecheck!([x, y, z], not (length(x) == z or map_size(y) == z), {x, y}) ==
                dynamic(tuple([list(term()), open_map()]))
 
       # not and does not propagate
-      assert typecheck!([x, y], not (length(x) == 3 and map_size(y) == 1), {x, y}) ==
+      assert typecheck!([x, y, z], not (length(x) == z and map_size(y) == z), {x, y}) ==
                dynamic(tuple([list(term()), term()]))
     end
 
@@ -772,4 +772,53 @@ defmodule Module.Types.PatternTest do
              """
     end
   end
+
+  describe "equality in guards" do
+    test "length" do
+      assert typecheck!([x], length(x) != 0, x) == dynamic(non_empty_list(term()))
+      assert typecheck!([x], not (length(x) != 0), x) == dynamic(empty_list())
+
+      assert typecheck!([x], 0 != length(x), x) == dynamic(non_empty_list(term()))
+      assert typecheck!([x], not (0 != length(x)), x) == dynamic(empty_list())
+    end
+
+    @non_empty_map difference(open_map(), empty_map())
+
+    test "map_size" do
+      assert typecheck!([x], map_size(x) == 0, x) == dynamic(empty_map())
+      assert typecheck!([x], map_size(x) != 0, x) == dynamic(@non_empty_map)
+      assert typecheck!([x], not (map_size(x) == 0), x) == dynamic(@non_empty_map)
+      assert typecheck!([x], not (map_size(x) != 0), x) == dynamic(empty_map())
+
+      assert typecheck!([x], 0 == map_size(x), x) == dynamic(empty_map())
+      assert typecheck!([x], 0 != map_size(x), x) == dynamic(@non_empty_map)
+      assert typecheck!([x], not (0 == map_size(x)), x) == dynamic(@non_empty_map)
+      assert typecheck!([x], not (0 != map_size(x)), x) == dynamic(empty_map())
+    end
+
+    @non_empty_tuple difference(open_tuple([]), tuple([]))
+    @non_empty_binary_tuple difference(open_tuple([]), tuple([term(), term()]))
+
+    test "tuple_size" do
+      assert typecheck!([x], tuple_size(x) == 0, x) == dynamic(tuple([]))
+      assert typecheck!([x], tuple_size(x) != 0, x) == dynamic(@non_empty_tuple)
+      assert typecheck!([x], not (tuple_size(x) == 0), x) == dynamic(@non_empty_tuple)
+      assert typecheck!([x], not (tuple_size(x) != 0), x) == dynamic(tuple([]))
+
+      assert typecheck!([x], 0 == tuple_size(x), x) == dynamic(tuple([]))
+      assert typecheck!([x], 0 != tuple_size(x), x) == dynamic(@non_empty_tuple)
+      assert typecheck!([x], not (0 == tuple_size(x)), x) == dynamic(@non_empty_tuple)
+      assert typecheck!([x], not (0 != tuple_size(x)), x) == dynamic(tuple([]))
+
+      assert typecheck!([x], tuple_size(x) == 2, x) == dynamic(tuple([term(), term()]))
+      assert typecheck!([x], tuple_size(x) != 2, x) == dynamic(@non_empty_binary_tuple)
+      assert typecheck!([x], not (tuple_size(x) == 2), x) == dynamic(@non_empty_binary_tuple)
+      assert typecheck!([x], not (tuple_size(x) != 2), x) == dynamic(tuple([term(), term()]))
+
+      assert typecheck!([x], 2 == tuple_size(x), x) == dynamic(tuple([term(), term()]))
+      assert typecheck!([x], 2 != tuple_size(x), x) == dynamic(@non_empty_binary_tuple)
+      assert typecheck!([x], not (2 == tuple_size(x)), x) == dynamic(@non_empty_binary_tuple)
+      assert typecheck!([x], not (2 != tuple_size(x)), x) == dynamic(tuple([term(), term()]))
+    end
+  end
 end