Add compatibility relation for gradual typechecking (#13407)

Author: gldubc

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

@@ -291,6 +291,38 @@ defmodule Module.Types.Descr do
   """
   def equal?(left, right), do: subtype?(left, right) and subtype?(right, left)
 
+  @doc """
+  Check if two types have a non-empty intersection.
+  """
+  def intersect?(left, right), do: not empty?(intersection(left, right))
+
+  @doc """
+  Checks if a type is a compatible subtype of another.
+
+  If `input_type` has a static part (i.e., values that are known to appear and
+  need to be handled), then to be compatible it should be a subtype of the
+  the dynamic part of `expected_type` (that is, the largest allowed type at
+  runtime).
+
+  If `input_type` is a dynamic type, then we check that the two can intersect
+  at runtime, i.e. it is possible to get valid inputs at runtime.
+
+  The function is used, in gradual mode, to type an operator that expects a given
+  type. For instance, `+` expects `integer() or float()` inputs. Compatible inputs
+  include `dynamic()`, `integer()`, but also `dynamic() and (integer() or atom())`.
+  Incompatible subtypes include `integer() or list()`, `dynamic() and atom()`.
+  """
+  def compatible?(input_type, expected_type) do
+    {input_dynamic, input_static} = Map.pop(input_type, :dynamic, input_type)
+    expected_dynamic = Map.get(expected_type, :dynamic, expected_type)
+
+    if not empty?(input_static) do
+      subtype_static(input_static, expected_dynamic)
+    else
+      intersect?(input_dynamic, expected_dynamic)
+    end
+  end
+
   ## Bitmaps
 
   defp bitmap_union(v1, v2), do: v1 ||| v2

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

@@ -114,9 +114,7 @@ defmodule Module.Types.Of do
       # will already have checked the type, so we skip the check here
       # as an optimization.
       # TODO: properly handle dynamic. Do we need materialization?
-      if actual_type == dynamic() or
-           (kind == :pattern and is_var(left)) or
-           empty?(difference(actual_type, expected_type)) do
+      if (kind == :pattern and is_var(left)) or compatible?(actual_type, expected_type) do
         {:ok, context}
       else
         hints = if meta[:inferred_bitstring_spec], do: [:inferred_bitstring_spec], else: []

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

@@ -147,6 +147,31 @@ defmodule Module.Types.DescrTest do
     end
   end
 
+  describe "compatible" do
+    test "intersection" do
+      assert compatible?(integer(), intersection(dynamic(), integer()))
+      refute compatible?(intersection(dynamic(), integer()), atom())
+      refute compatible?(atom(), intersection(dynamic(), integer()))
+      refute compatible?(atom(), intersection(dynamic(), atom([:foo, :bar])))
+      assert compatible?(intersection(dynamic(), atom()), atom([:foo, :bar]))
+      assert compatible?(atom([:foo, :bar]), intersection(dynamic(), atom()))
+    end
+
+    test "static" do
+      refute compatible?(atom(), atom([:foo, :bar]))
+      refute compatible?(union(integer(), atom()), integer())
+      refute compatible?(none(), integer())
+      refute compatible?(union(atom(), dynamic()), integer())
+    end
+
+    test "dynamic" do
+      assert compatible?(dynamic(), term())
+      assert compatible?(term(), dynamic())
+      assert compatible?(dynamic(), integer())
+      assert compatible?(integer(), dynamic())
+    end
+  end
+
   describe "to_quoted" do
     test "bitmap" do
       assert union(integer(), union(float(), binary())) |> to_quoted_string() ==