Typing of comparison operator

Author: josevalim

CHANGELOG.md

@@ -10,6 +10,8 @@ TODO.
 
 * Type checking of all built-in conversion functions, such as `List.to_integer/1` and `Atom.to_string/1`
 
+* Type checking of all functions in `Kernel` which are inlined by the compiler
+
 * Type checking of all functions in the `Tuple` module
 
 ## ExUnit improvements
@@ -80,6 +82,7 @@ You may also prever to write using guards:
   * [Kernel] Track the type of tuples in patterns and inside `elem/2`
   * [List] Add `List.ends_with?/2`
   * [Macro] Improve `dbg` handling of `if/2`, `with/1` and of code blocks
+  * [Macro] Add `Macro.struct_info!/2` to return struct information mirroring `mod.__info__(:struct)`
   * [Process] Handle arbitrarily high integer values in `Process.sleep/1`
   * [String] Inspect special whitespace and zero-width characters using their Unicode representation
 

lib/elixir/lib/module/types/of.ex

@@ -333,6 +333,14 @@ defmodule Module.Types.Of do
         {:binary, :copy, [{[binary(), integer()], binary()}]},
 
         # :erlang
+        {:erlang, :"/=", [{[term(), term()], boolean()}]},
+        {:erlang, :"=/=", [{[term(), term()], boolean()}]},
+        {:erlang, :<, [{[term(), term()], boolean()}]},
+        {:erlang, :"=<", [{[term(), term()], boolean()}]},
+        {:erlang, :==, [{[term(), term()], boolean()}]},
+        {:erlang, :"=:=", [{[term(), term()], boolean()}]},
+        {:erlang, :>, [{[term(), term()], boolean()}]},
+        {:erlang, :>=, [{[term(), term()], boolean()}]},
         {:erlang, :atom_to_binary, [{[atom()], binary()}]},
         {:erlang, :atom_to_list, [{[atom()], list(integer())}]},
         {:erlang, :band, [{[integer(), integer()], integer()}]},
@@ -492,38 +500,55 @@ defmodule Module.Types.Of do
 
   def apply(:erlang, name, [left, right], expr, stack, context)
       when name in [:>=, :"=<", :>, :<, :min, :max] do
-    result = if name in [:min, :max], do: union(left, right), else: boolean()
+    context =
+      cond do
+        match?({false, _}, map_fetch(left, :__struct__)) or
+            match?({false, _}, map_fetch(right, :__struct__)) ->
+          warning = {:struct_comparison, expr, context}
+          warn(__MODULE__, warning, elem(expr, 1), stack, context)
+
+        number_type?(left) and number_type?(right) ->
+          context
 
-    cond do
-      match?({false, _}, map_fetch(left, :__struct__)) or
-          match?({false, _}, map_fetch(right, :__struct__)) ->
-        warning = {:struct_comparison, expr, context}
-        {result, warn(__MODULE__, warning, elem(expr, 1), stack, context)}
+        disjoint?(left, right) ->
+          warning = {:mismatched_comparison, expr, context}
+          warn(__MODULE__, warning, elem(expr, 1), stack, context)
+
+        true ->
+          context
+      end
 
-      number_type?(left) and number_type?(right) ->
-        {result, context}
+    cond do
+      name in [:min, :max] ->
+        {union(left, right), context}
 
-      disjoint?(left, right) ->
-        warning = {:mismatched_comparison, expr, context}
-        {result, warn(__MODULE__, warning, elem(expr, 1), stack, context)}
+      gradual?(left) or gradual?(right) ->
+        {dynamic(boolean()), context}
 
       true ->
-        {result, context}
+        {boolean(), context}
     end
   end
 
   def apply(:erlang, name, [left, right], expr, stack, context)
       when name in [:==, :"/=", :"=:=", :"=/="] do
-    cond do
-      name in [:==, :"/="] and number_type?(left) and number_type?(right) ->
-        {boolean(), context}
+    context =
+      cond do
+        name in [:==, :"/="] and number_type?(left) and number_type?(right) ->
+          context
 
-      disjoint?(left, right) ->
-        warning = {:mismatched_comparison, expr, context}
-        {boolean(), warn(__MODULE__, warning, elem(expr, 1), stack, context)}
+        disjoint?(left, right) ->
+          warning = {:mismatched_comparison, expr, context}
+          warn(__MODULE__, warning, elem(expr, 1), stack, context)
 
-      true ->
-        {boolean(), context}
+        true ->
+          context
+      end
+
+    if gradual?(left) or gradual?(right) do
+      {dynamic(boolean()), context}
+    else
+      {boolean(), context}
     end
   end
 

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

@@ -577,8 +577,8 @@ defmodule Module.Types.ExprTest do
   describe "comparison" do
     test "works across numbers" do
       assert typecheck!([x = 123, y = 456.0], min(x, y)) == dynamic(union(integer(), float()))
-      assert typecheck!([x = 123, y = 456.0], x < y) == boolean()
-      assert typecheck!([x = 123, y = 456.0], x == y) == boolean()
+      assert typecheck!([x = 123, y = 456.0], x < y) == dynamic(boolean())
+      assert typecheck!([x = 123, y = 456.0], x == y) == dynamic(boolean())
     end
 
     test "warns when comparison is constant" do
@@ -606,7 +606,7 @@ defmodule Module.Types.ExprTest do
                 """}
 
       assert typewarn!([x = 123, y = 456.0], x === y) ==
-               {boolean(),
+               {dynamic(boolean()),
                 ~l"""
                 comparison between incompatible types found:
 
@@ -631,7 +631,7 @@ defmodule Module.Types.ExprTest do
 
     test "warns on comparison with struct across dynamic call" do
       assert typewarn!([x = :foo, y = %Point{}, mod = Kernel], mod.<=(x, y)) ==
-               {boolean(),
+               {dynamic(boolean()),
                 ~l"""
                 comparison with structs found: