Track variables across equality in guards

Author: josevalim

lib/elixir/lib/module/types.ex

@@ -332,7 +332,7 @@ defmodule Module.Types do
             {return_type, context} =
               Expr.of_expr(body, Descr.term(), body, stack, context)
 
-            args_types = Pattern.of_domain(trees, context)
+            args_types = Pattern.of_domain(trees, stack, context)
 
             {type_index, inferred} =
               add_inferred(inferred, args_types, return_type, total - 1, [])

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

@@ -396,6 +396,10 @@ defmodule Module.Types.Apply do
           common = intersection(left_type, right_type)
 
           cond do
+            # This check is incomplete. After all, we could have the number type nested
+            # inside a tuple or a list and the comparison would still be valid.
+            # However, nested comparison between distinct numbers is very uncommon,
+            # so we only check the direct value here.
             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)
@@ -479,7 +483,6 @@ defmodule Module.Types.Apply do
     remote_domain(mod, fun, args, expected, elem(expr, 1), stack, context)
   end
 
-  @number union(integer(), float())
   @empty_list empty_list()
   @non_empty_list non_empty_list(term())
   @empty_map empty_map()
@@ -546,6 +549,7 @@ defmodule Module.Types.Apply do
             :maybe_false -> {name in [:"/=", :"=/="], @atom_false}
           end
 
+        # This logic mirrors the code in `Pattern.of_pattern_tree`
         # If it is a singleton, we can always be precise
         if singleton?(literal_type) do
           expected = if polarity, do: literal_type, else: negation(literal_type)
@@ -562,7 +566,7 @@ defmodule Module.Types.Apply do
               # We are checking for `not x == 1` or similar, we can't say anything about x
               polarity == false -> term()
               # We are checking for `x == 1`, make sure x is integer or float
-              number_type?(literal_type) and name in [:==, :"/="] -> union(literal_type, @number)
+              name in [:==, :"/="] -> numberize(literal_type)
               # Otherwise we have the literal type as is
               true -> literal_type
             end
@@ -579,7 +583,10 @@ defmodule Module.Types.Apply do
     return_compare(name, left_type, right_type, boolean(), both_literal?, expr, stack, context)
   end
 
-  defp return_compare(name, left_type, right_type, result, skip_check?, expr, stack, context) do
+  @doc """
+  Computes the return type of the comparison application.
+  """
+  def return_compare(name, left_type, right_type, result, skip_check?, expr, stack, context) do
     result = return(result, [left_type, right_type], stack)
 
     cond do
@@ -589,6 +596,10 @@ defmodule Module.Types.Apply do
       name in [:==, :"/="] and number_type?(left_type) and number_type?(right_type) ->
         {result, context}
 
+      # This check is incomplete. After all, we could have the number type nested
+      # inside a tuple or a list and the comparison would still be valid.
+      # However, nested comparison between distinct numbers is very uncommon,
+      # so we only check the direct value here.
       disjoint?(left_type, right_type) ->
         error = {:mismatched_comparison, left_type, right_type}
         remote_error(error, :erlang, name, 2, expr, stack, context)

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

@@ -381,6 +381,10 @@ defmodule Module.Types.Descr do
     end
   end
 
+  @compile {:inline, pop_dynamic: 1}
+  defp pop_dynamic(:term), do: {:term, :term}
+  defp pop_dynamic(descr), do: Map.pop(descr, :dynamic, descr)
+
   @compile {:inline, maybe_union: 2}
   defp maybe_union(nil, _fun), do: nil
   defp maybe_union(descr, fun), do: union(descr, fun.())
@@ -394,18 +398,16 @@ defmodule Module.Types.Descr do
   def union(other, none) when none == @none, do: other
 
   def union(left, right) do
-    left = unfold(left)
-    right = unfold(right)
     is_gradual_left = gradual?(left)
     is_gradual_right = gradual?(right)
 
     cond do
       is_gradual_left and not is_gradual_right ->
-        right_with_dynamic = Map.put(right, :dynamic, right)
+        right_with_dynamic = Map.put(unfold(right), :dynamic, right)
         union_static(left, right_with_dynamic)
 
       is_gradual_right and not is_gradual_left ->
-        left_with_dynamic = Map.put(left, :dynamic, left)
+        left_with_dynamic = Map.put(unfold(left), :dynamic, left)
         union_static(left_with_dynamic, right)
 
       true ->
@@ -436,18 +438,16 @@ defmodule Module.Types.Descr do
   def intersection(other, %{dynamic: :term}), do: dynamic(remove_optional(other))
 
   def intersection(left, right) do
-    left = unfold(left)
-    right = unfold(right)
     is_gradual_left = gradual?(left)
     is_gradual_right = gradual?(right)
 
     cond do
       is_gradual_left and not is_gradual_right ->
-        right_with_dynamic = Map.put(right, :dynamic, right)
+        right_with_dynamic = Map.put(unfold(right), :dynamic, right)
         intersection_static(left, right_with_dynamic)
 
       is_gradual_right and not is_gradual_left ->
-        left_with_dynamic = Map.put(left, :dynamic, left)
+        left_with_dynamic = Map.put(unfold(left), :dynamic, left)
         intersection_static(left_with_dynamic, right)
 
       true ->
@@ -480,12 +480,9 @@ defmodule Module.Types.Descr do
   def difference(left, :term), do: keep_optional(left)
 
   def difference(left, right) do
-    left = unfold(left)
-    right = unfold(right)
-
     if gradual?(left) or gradual?(right) do
-      {left_dynamic, left_static} = Map.pop(left, :dynamic, left)
-      {right_dynamic, right_static} = Map.pop(right, :dynamic, right)
+      {left_dynamic, left_static} = pop_dynamic(left)
+      {right_dynamic, right_static} = pop_dynamic(right)
       dynamic_part = difference_static(left_dynamic, right_static)
 
       Map.put(difference_static(left_static, right_dynamic), :dynamic, dynamic_part)
@@ -494,7 +491,8 @@ defmodule Module.Types.Descr do
     end
   end
 
-  # For static types, the difference is component-wise.
+  # For static types, the difference is component-wise
+  defp difference_static(left, descr) when descr == %{}, do: left
   defp difference_static(left, :term), do: keep_optional(left)
 
   defp difference_static(left, right) do
@@ -563,7 +561,7 @@ defmodule Module.Types.Descr do
   Compute the negation of a type.
   """
   def negation(:term), do: none()
-  def negation(%{} = descr), do: difference(unfolded_term(), descr)
+  def negation(%{} = descr), do: difference(term(), descr)
 
   @doc """
   Check if a type is empty.
@@ -604,6 +602,42 @@ defmodule Module.Types.Descr do
   defp empty_key?(:tuple, value), do: tuple_empty?(value)
   defp empty_key?(_, _value), do: false
 
+  @doc """
+  Converts all floats or integers into numbers.
+  """
+  def numberize(:term), do: :term
+  def numberize(descr), do: numberize_each(descr, [:bitmap, :tuple, :map, :list, :dynamic])
+
+  defp numberize_each(descr, [key | keys]) do
+    case descr do
+      %{^key => val} -> %{descr | key => numberize(key, val)}
+      %{} -> descr
+    end
+    |> numberize_each(keys)
+  end
+
+  defp numberize_each(descr, []) do
+    descr
+  end
+
+  defp numberize(:dynamic, descr), do: numberize(descr)
+  defp numberize(:bitmap, bitmap) when (bitmap &&& @bit_number) != 0, do: bitmap ||| @bit_number
+  defp numberize(:bitmap, bitmap), do: bitmap
+
+  defp numberize(:map, bdd) do
+    bdd_map(bdd, fn {tag, fields} ->
+      {tag, fields |> Map.to_list() |> Map.new(fn {key, value} -> {key, numberize(value)} end)}
+    end)
+  end
+
+  defp numberize(:tuple, bdd) do
+    bdd_map(bdd, fn {tag, fields} -> {tag, Enum.map(fields, &numberize/1)} end)
+  end
+
+  defp numberize(:list, bdd) do
+    bdd_map(bdd, fn {head, tail} -> {numberize(head), numberize(tail)} end)
+  end
+
   @doc """
   Returns if the type is a singleton.
   """
@@ -834,11 +868,7 @@ defmodule Module.Types.Descr do
   Incompatible subtypes include `integer() or list()`, `dynamic() and atom()`.
   """
   def compatible?(left, right) do
-    {left_dynamic, left_static} =
-      case left do
-        :term -> {:term, :term}
-        _ -> Map.pop(left, :dynamic, left)
-      end
+    {left_dynamic, left_static} = pop_dynamic(left)
 
     right_dynamic =
       case right do
@@ -862,11 +892,7 @@ defmodule Module.Types.Descr do
   as we traverse the program.
   """
   def compatible_intersection(left, right) do
-    {left_dynamic, left_static} =
-      case left do
-        :term -> {:term, :term}
-        _ -> Map.pop(left, :dynamic, left)
-      end
+    {left_dynamic, left_static} = pop_dynamic(left)
 
     right_dynamic =
       case right do
@@ -1068,7 +1094,7 @@ defmodule Module.Types.Descr do
   def atom_fetch(:term), do: :error
 
   def atom_fetch(%{} = descr) do
-    {static_or_dynamic, static} = Map.pop(descr, :dynamic, descr)
+    {static_or_dynamic, static} = pop_dynamic(descr)
 
     if atom_only?(static) do
       case static_or_dynamic do

lib/elixir/lib/module/types/expr.ex

@@ -325,7 +325,7 @@ defmodule Module.Types.Expr do
     {acc, context} =
       of_clauses_fun(clauses, domain, @pending, nil, :fn, stack, context, [], fn
         trees, body, context, acc ->
-          args = Pattern.of_domain(trees, context)
+          args = Pattern.of_domain(trees, stack, context)
           add_inferred(acc, args, body)
       end)