Check for compatibility, not subtyping

Author: josevalim

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

@@ -637,15 +637,6 @@ defmodule Module.Types.Descr do
   def number_type?(%{bitmap: bitmap}) when (bitmap &&& @bit_number) != 0, do: true
   def number_type?(_), do: false
 
-  @doc """
-  Optimized version of `not empty?(intersection(atom(), type))`.
-  """
-  def atom_type?(:term), do: true
-  def atom_type?(%{dynamic: :term}), do: true
-  def atom_type?(%{dynamic: %{atom: _}}), do: true
-  def atom_type?(%{atom: _}), do: true
-  def atom_type?(_), do: false
-
   ## Bitmaps
 
   defp bitmap_to_quoted(val) do
@@ -749,20 +740,6 @@ defmodule Module.Types.Descr do
     end
   end
 
-  @doc """
-  Optimized version of `not empty?(intersection(atom([atom]), type))`.
-  """
-  def atom_type?(:term, _atom), do: true
-
-  def atom_type?(%{} = descr, atom) do
-    case Map.get(descr, :dynamic, descr) do
-      :term -> true
-      %{atom: {:union, set}} -> :sets.is_element(atom, set)
-      %{atom: {:negation, set}} -> not :sets.is_element(atom, set)
-      %{} -> false
-    end
-  end
-
   @doc """
   Returns a set of all known atoms.
 

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

@@ -360,7 +360,7 @@ defmodule Module.Types.Expr do
         {timeout_type, context} = of_expr(timeout, {@timeout_type, after_expr}, stack, context)
         {body_type, context} = of_expr(body, expected_expr, stack, context)
 
-        if integer_type?(timeout_type) or atom_type?(timeout_type, :infinity) do
+        if compatible?(timeout_type, @timeout_type) do
           {union(body_type, acc), reset_vars(context, original)}
         else
           error = {:badtimeout, timeout_type, timeout, context}
@@ -592,10 +592,9 @@ defmodule Module.Types.Expr do
 
   defp for_clause({:<<>>, _, [{:<-, meta, [left, right]}]} = expr, stack, context) do
     {right_type, context} = of_expr(right, {binary(), expr}, stack, context)
-
     context = Pattern.of_match(left, binary(), expr, :for, stack, context)
 
-    if binary_type?(right_type) do
+    if compatible?(right_type, binary()) do
       context
     else
       error = {:badbinary, right_type, right, context}

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

@@ -618,48 +618,28 @@ defmodule Module.Types.Pattern do
   # This function is public as it is invoked from Of.binary/4.
 
   # :atom
-  def of_guard(atom, expected, expr, stack, context) when is_atom(atom) do
-    if atom_type?(expected, atom) do
-      {atom([atom]), context}
-    else
-      {error_type(), Of.incompatible_error(expr, expected, atom([atom]), stack, context)}
-    end
+  def of_guard(atom, _expected, _expr, _stack, context) when is_atom(atom) do
+    {atom([atom]), context}
   end
 
   # 12
-  def of_guard(literal, expected, expr, stack, context) when is_integer(literal) do
-    if integer_type?(expected) do
-      {integer(), context}
-    else
-      {error_type(), Of.incompatible_error(expr, expected, integer(), stack, context)}
-    end
+  def of_guard(literal, _expected, _expr, _stack, context) when is_integer(literal) do
+    {integer(), context}
   end
 
   # 1.2
-  def of_guard(literal, expected, expr, stack, context) when is_float(literal) do
-    if float_type?(expected) do
-      {float(), context}
-    else
-      {error_type(), Of.incompatible_error(expr, expected, float(), stack, context)}
-    end
+  def of_guard(literal, _expected, _expr, _stack, context) when is_float(literal) do
+    {float(), context}
   end
 
   # "..."
-  def of_guard(literal, expected, expr, stack, context) when is_binary(literal) do
-    if binary_type?(expected) do
-      {binary(), context}
-    else
-      {error_type(), Of.incompatible_error(expr, expected, binary(), stack, context)}
-    end
+  def of_guard(literal, _expected, _expr, _stack, context) when is_binary(literal) do
+    {binary(), context}
   end
 
   # []
-  def of_guard([], expected, expr, stack, context) do
-    if empty_list_type?(expected) do
-      {empty_list(), context}
-    else
-      {error_type(), Of.incompatible_error(expr, expected, empty_list(), stack, context)}
-    end
+  def of_guard([], _expected, _expr, _stack, context) do
+    {empty_list(), context}
   end
 
   # [expr, ...]
@@ -691,13 +671,9 @@ defmodule Module.Types.Pattern do
   end
 
   # <<>>
-  def of_guard({:<<>>, _meta, args}, expected, expr, stack, context) do
-    if binary_type?(expected) do
-      context = Of.binary(args, :guard, stack, context)
-      {binary(), context}
-    else
-      {error_type(), Of.incompatible_error(expr, expected, binary(), stack, context)}
-    end
+  def of_guard({:<<>>, _meta, args}, _expected, _expr, stack, context) do
+    context = Of.binary(args, :guard, stack, context)
+    {binary(), context}
   end
 
   # ^var

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

@@ -579,20 +579,6 @@ defmodule Module.Types.DescrTest do
     end
   end
 
-  describe "queries" do
-    test "atom_type?" do
-      assert atom_type?(term(), :foo)
-      assert atom_type?(dynamic(), :foo)
-
-      assert atom_type?(atom([:foo, :bar]), :foo)
-      refute atom_type?(atom([:foo, :bar]), :baz)
-      assert atom_type?(negation(atom([:foo, :bar])), :baz)
-
-      refute atom_type?(union(atom([:foo, :bar]), integer()), :baz)
-      refute atom_type?(dynamic(union(atom([:foo, :bar]), integer())), :baz)
-    end
-  end
-
   describe "projections" do
     test "fun_fetch" do
       assert fun_fetch(term(), 1) == :error

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

@@ -1279,6 +1279,17 @@ defmodule Module.Types.ExprTest do
                  # from: types_test.ex:LINE-5
                  x = :timeout
              """
+
+      # Check for compatibility, not subtyping
+      assert typeerror!(
+               [<<x::integer, y::float>>],
+               receive do
+               after
+                 if(:rand.uniform(), do: x, else: y) -> :ok
+               end
+             ) =~ "expected "
+    after
+      " timeout given to receive to be an integer"
     end
   end
 
@@ -1551,6 +1562,13 @@ defmodule Module.Types.ExprTest do
 
                #{hints(:inferred_bitstring_spec)}
                """
+
+      # Check for compatibility, not subtyping
+      assert typeerror!(
+               [<<x::integer, y::binary>>],
+               for(<<i <- if(:rand.uniform() > 0.5, do: x, else: y)>>, do: i)
+             ) =~
+               "expected the right side of <- in a binary generator to be a binary"
     end
 
     test "infers binary generators" do