Infer types from length, map_size, tuple_size comparison checks

Author: josevalim

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

@@ -374,35 +374,43 @@ defmodule Module.Types.Apply do
     end
   end
 
-  defp do_remote(:erlang, name, [left, right], _expected, expr, stack, context, of_fun)
+  defp do_remote(:erlang, name, [left, right], expected, expr, stack, context, of_fun)
        when name in [:>=, :"=<", :>, :<, :min, :max] do
-    {left_type, context} = of_fun.(left, term(), expr, stack, context)
-    {right_type, context} = of_fun.(right, term(), expr, stack, context)
+    case sized_order(name, left, right, expected) do
+      {arg, expected, return} ->
+        {actual, context} = of_fun.(arg, expected, expr, stack, context)
+        result = if compatible?(actual, expected), do: return, else: boolean()
+        {result, context}
 
-    result =
-      if name in [:min, :max] do
-        union(left_type, right_type)
-      else
-        return(boolean(), [left_type, right_type], stack)
-      end
+      :none ->
+        {left_type, context} = of_fun.(left, term(), expr, stack, context)
+        {right_type, context} = of_fun.(right, term(), expr, stack, context)
 
-    if is_warning(stack) do
-      common = intersection(left_type, right_type)
+        result =
+          if name in [:min, :max] do
+            union(left_type, right_type)
+          else
+            return(boolean(), [left_type, right_type], stack)
+          end
 
-      cond do
-        empty?(common) and not (number_type?(left_type) and number_type?(right_type)) ->
-          error = {:mismatched_comparison, left_type, right_type}
-          remote_error(error, :erlang, name, 2, expr, stack, context)
+        if is_warning(stack) do
+          common = intersection(left_type, right_type)
 
-        match?({false, _}, map_fetch_key(dynamic(common), :__struct__)) ->
-          error = {:struct_comparison, left_type, right_type}
-          remote_error(error, :erlang, name, 2, expr, stack, context)
+          cond do
+            empty?(common) and not (number_type?(left_type) and number_type?(right_type)) ->
+              error = {:mismatched_comparison, left_type, right_type}
+              remote_error(error, :erlang, name, 2, expr, stack, context)
 
-        true ->
+            match?({false, _}, map_fetch_key(dynamic(common), :__struct__)) ->
+              error = {:struct_comparison, left_type, right_type}
+              remote_error(error, :erlang, name, 2, expr, stack, context)
+
+            true ->
+              {result, context}
+          end
+        else
           {result, context}
-      end
-    else
-      {result, context}
+        end
     end
   end
 
@@ -540,6 +548,74 @@ defmodule Module.Types.Apply do
     end
   end
 
+  defp sized_order(name, left, right, expected) do
+    if name in [:>=, :"=<", :>, :<] do
+      case {left, right} do
+        {{{:., _, [:erlang, fun]}, _, [arg]}, size}
+        when is_integer(size) and size >= 0 and fun in [:length, :map_size, :tuple_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
+          end
+
+        {size, {{:., _, [:erlang, fun]}, _, [arg]}}
+        when is_integer(size) and size >= 0 and fun in [:length, :map_size, :tuple_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
+          end
+
+        _ ->
+          :none
+      end
+    else
+      :none
+    end
+  end
+
+  defp sized_order(name, fun, size, arg, return) do
+    case expected_order(fun, name, size) do
+      :none -> :none
+      expected -> {arg, expected, return}
+    end
+  end
+
+  defp expected_order(_, :<, 0), do: :none
+
+  defp expected_order(:tuple_size, :<, size),
+    do: difference(open_tuple([]), open_tuple(List.duplicate(term(), size)))
+
+  defp expected_order(:tuple_size, :"=<", 0),
+    do: tuple([])
+
+  defp expected_order(:tuple_size, :"=<", size),
+    do: difference(open_tuple([]), open_tuple(List.duplicate(term(), size + 1)))
+
+  defp expected_order(:tuple_size, :>, size),
+    do: open_tuple(List.duplicate(term(), size + 1))
+
+  defp expected_order(:tuple_size, :>=, size),
+    do: open_tuple(List.duplicate(term(), size))
+
+  defp expected_order(:map_size, :<, 1), do: @empty_map
+  defp expected_order(:map_size, :"=<", 0), do: @empty_map
+  defp expected_order(:map_size, :>, _), do: @non_empty_map
+  defp expected_order(:map_size, :>=, size) when size > 0, do: @non_empty_map
+
+  defp expected_order(:length, :<, 1), do: @empty_list
+  defp expected_order(:length, :"=<", 0), do: @empty_list
+  defp expected_order(:length, :>, _), do: @non_empty_list
+  defp expected_order(:length, :>=, size) when size > 0, do: @non_empty_list
+
+  defp expected_order(_, _, _), do: :none
+
+  defp invert_order(:>=), do: :<
+  defp invert_order(:"=<"), do: :>
+  defp invert_order(:>), do: :"=<"
+  defp invert_order(:<), do: :>=
+
   @doc """
   Returns the domain of an unknown module.
 

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

@@ -773,18 +773,51 @@ defmodule Module.Types.PatternTest do
     end
   end
 
-  describe "equality in guards" do
-    test "length" do
+  describe "comparison in guards" do
+    test "length equality" 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
 
+    test "length ordered" do
+      assert typecheck!([x], length(x) < 0, x) == dynamic(list(term()))
+      assert typecheck!([x], length(x) >= 0, x) == dynamic(list(term()))
+      assert typecheck!([x], length(x) <= 0, x) == dynamic(empty_list())
+
+      assert typecheck!([x], 0 <= length(x), x) == dynamic(non_empty_list(term()))
+      assert typecheck!([x], 0 >= length(x), x) == dynamic(list(term()))
+      assert typecheck!([x], 0 < length(x), x) == dynamic(list(term()))
+      assert typecheck!([x], 0 > length(x), x) == dynamic(empty_list())
+
+      assert typecheck!([x], not (length(x) > 0), x) == dynamic(empty_list())
+      assert typecheck!([x], not (length(x) < 0), x) == dynamic(list(term()))
+      assert typecheck!([x], not (length(x) >= 0), x) == dynamic(list(term()))
+      assert typecheck!([x], not (length(x) <= 0), x) == dynamic(non_empty_list(term()))
+
+      assert typecheck!([x], length(x) < 1, x) == dynamic(empty_list())
+
+      assert typecheck!([x], length(x) > 2, x) == dynamic(non_empty_list(term()))
+      assert typecheck!([x], length(x) < 2, x) == dynamic(list(term()))
+      assert typecheck!([x], length(x) >= 2, x) == dynamic(non_empty_list(term()))
+      assert typecheck!([x], length(x) <= 2, x) == dynamic(list(term()))
+
+      assert typecheck!([x], 2 <= length(x), x) == dynamic(non_empty_list(term()))
+      assert typecheck!([x], 2 >= length(x), x) == dynamic(list(term()))
+      assert typecheck!([x], 2 < length(x), x) == dynamic(non_empty_list(term()))
+      assert typecheck!([x], 2 > length(x), x) == dynamic(list(term()))
+
+      assert typecheck!([x], not (length(x) > 2), x) == dynamic(list(term()))
+      assert typecheck!([x], not (length(x) < 2), x) == dynamic(non_empty_list(term()))
+      assert typecheck!([x], not (length(x) >= 2), x) == dynamic(list(term()))
+      assert typecheck!([x], not (length(x) <= 2), x) == dynamic(non_empty_list(term()))
+    end
+
     @non_empty_map difference(open_map(), empty_map())
 
-    test "map_size" do
+    test "map_size equality" 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)
@@ -796,10 +829,49 @@ defmodule Module.Types.PatternTest do
       assert typecheck!([x], not (0 != map_size(x)), x) == dynamic(empty_map())
     end
 
+    test "map_size ordered" do
+      assert typecheck!([x], map_size(x) > 0, x) == dynamic(@non_empty_map)
+      assert typecheck!([x], map_size(x) < 0, x) == dynamic(open_map())
+      assert typecheck!([x], map_size(x) >= 0, x) == dynamic(open_map())
+      assert typecheck!([x], map_size(x) <= 0, x) == dynamic(empty_map())
+
+      assert typecheck!([x], 0 <= map_size(x), x) == dynamic(@non_empty_map)
+      assert typecheck!([x], 0 >= map_size(x), x) == dynamic(open_map())
+      assert typecheck!([x], 0 < map_size(x), x) == dynamic(open_map())
+      assert typecheck!([x], 0 > map_size(x), x) == dynamic(empty_map())
+
+      assert typecheck!([x], not (map_size(x) > 0), x) == dynamic(empty_map())
+      assert typecheck!([x], not (map_size(x) < 0), x) == dynamic(open_map())
+      assert typecheck!([x], not (map_size(x) >= 0), x) == dynamic(open_map())
+      assert typecheck!([x], not (map_size(x) <= 0), x) == dynamic(@non_empty_map)
+
+      assert typecheck!([x], map_size(x) < 1, x) == dynamic(empty_map())
+
+      assert typecheck!([x], map_size(x) > 2, x) == dynamic(@non_empty_map)
+      assert typecheck!([x], map_size(x) < 2, x) == dynamic(open_map())
+      assert typecheck!([x], map_size(x) >= 2, x) == dynamic(@non_empty_map)
+      assert typecheck!([x], map_size(x) <= 2, x) == dynamic(open_map())
+
+      assert typecheck!([x], 2 <= map_size(x), x) == dynamic(@non_empty_map)
+      assert typecheck!([x], 2 >= map_size(x), x) == dynamic(open_map())
+      assert typecheck!([x], 2 < map_size(x), x) == dynamic(@non_empty_map)
+      assert typecheck!([x], 2 > map_size(x), x) == dynamic(open_map())
+
+      assert typecheck!([x], not (map_size(x) > 2), x) == dynamic(open_map())
+      assert typecheck!([x], not (map_size(x) < 2), x) == dynamic(@non_empty_map)
+      assert typecheck!([x], not (map_size(x) >= 2), x) == dynamic(open_map())
+      assert typecheck!([x], not (map_size(x) <= 2), x) == dynamic(@non_empty_map)
+    end
+
     @non_empty_tuple difference(open_tuple([]), tuple([]))
-    @non_empty_binary_tuple difference(open_tuple([]), tuple([term(), term()]))
+    @non_binary_tuple difference(open_tuple([]), tuple([term(), term()]))
+
+    @open_binary_tuple open_tuple([term(), term()])
+    @open_ternary_tuple open_tuple([term(), term(), term()])
+    @non_open_binary_tuple difference(open_tuple([]), open_tuple([term(), term()]))
+    @non_open_ternary_tuple difference(open_tuple([]), open_tuple([term(), term(), term()]))
 
-    test "tuple_size" do
+    test "tuple_size equality" 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)
@@ -811,14 +883,46 @@ defmodule Module.Types.PatternTest do
       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], tuple_size(x) != 2, x) == dynamic(@non_binary_tuple)
+      assert typecheck!([x], not (tuple_size(x) == 2), x) == dynamic(@non_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], 2 != tuple_size(x), x) == dynamic(@non_binary_tuple)
+      assert typecheck!([x], not (2 == tuple_size(x)), x) == dynamic(@non_binary_tuple)
       assert typecheck!([x], not (2 != tuple_size(x)), x) == dynamic(tuple([term(), term()]))
     end
+
+    test "tuple_size ordered" do
+      assert typecheck!([x], tuple_size(x) > 0, x) == dynamic(open_tuple([term()]))
+      assert typecheck!([x], tuple_size(x) < 0, x) == dynamic(open_tuple([]))
+      assert typecheck!([x], tuple_size(x) >= 0, x) == dynamic(open_tuple([]))
+      assert typecheck!([x], tuple_size(x) <= 0, x) == dynamic(tuple([]))
+
+      assert typecheck!([x], 0 <= tuple_size(x), x) == dynamic(open_tuple([term()]))
+      assert typecheck!([x], 0 >= tuple_size(x), x) == dynamic(open_tuple([]))
+      assert typecheck!([x], 0 < tuple_size(x), x) == dynamic(open_tuple([]))
+      assert typecheck!([x], 0 > tuple_size(x), x) == dynamic(tuple([]))
+
+      assert typecheck!([x], not (tuple_size(x) > 0), x) == dynamic(tuple([]))
+      assert typecheck!([x], not (tuple_size(x) < 0), x) == dynamic(open_tuple([]))
+      assert typecheck!([x], not (tuple_size(x) >= 0), x) == dynamic(open_tuple([]))
+      assert typecheck!([x], not (tuple_size(x) <= 0), x) == dynamic(open_tuple([term()]))
+
+      assert typecheck!([x], tuple_size(x) > 2, x) == dynamic(@open_ternary_tuple)
+      assert typecheck!([x], tuple_size(x) < 2, x) == dynamic(@non_open_binary_tuple)
+      assert typecheck!([x], tuple_size(x) >= 2, x) == dynamic(@open_binary_tuple)
+      assert typecheck!([x], tuple_size(x) <= 2, x) == dynamic(@non_open_ternary_tuple)
+
+      assert typecheck!([x], 2 <= tuple_size(x), x) == dynamic(@open_ternary_tuple)
+      assert typecheck!([x], 2 >= tuple_size(x), x) == dynamic(@non_open_binary_tuple)
+      assert typecheck!([x], 2 < tuple_size(x), x) == dynamic(@open_binary_tuple)
+      assert typecheck!([x], 2 > tuple_size(x), x) == dynamic(@non_open_ternary_tuple)
+
+      assert typecheck!([x], not (tuple_size(x) > 2), x) == dynamic(@non_open_ternary_tuple)
+      assert typecheck!([x], not (tuple_size(x) < 2), x) == dynamic(@open_binary_tuple)
+      assert typecheck!([x], not (tuple_size(x) >= 2), x) == dynamic(@non_open_binary_tuple)
+      assert typecheck!([x], not (tuple_size(x) <= 2), x) == dynamic(@open_ternary_tuple)
+    end
   end
 end