Properly implement static and dynamic modes

Author: josevalim

lib/elixir/lib/module/types.ex

@@ -8,7 +8,8 @@ defmodule Module.Types do
     context = context()
 
     Enum.flat_map(defs, fn {{fun, arity} = function, kind, meta, clauses} ->
-      stack = stack(with_file_meta(meta, file), module, function, no_warn_undefined, cache)
+      stack =
+        stack(:dynamic, with_file_meta(meta, file), module, function, no_warn_undefined, cache)
 
       Enum.flat_map(clauses, fn {meta, args, guards, body} ->
         try do
@@ -58,7 +59,8 @@ defmodule Module.Types do
   end
 
   @doc false
-  def stack(file, module, function, no_warn_undefined, cache) do
+  def stack(mode, file, module, function, no_warn_undefined, cache)
+      when mode in [:static, :dynamic, :infer] do
     %{
       # The fallback meta used for literals in patterns and guards
       meta: [],
@@ -71,7 +73,29 @@ defmodule Module.Types do
       # List of calls to not warn on as undefined
       no_warn_undefined: no_warn_undefined,
       # A list of cached modules received from the parallel compiler
-      cache: cache
+      cache: cache,
+      # The mode control what happens on function application when
+      # there are gradual arguments. Non-gradual arguments always
+      # perform subtyping and return its output (OUT).
+      #
+      # The mode may also control exhaustiveness checks in the future
+      # (to be decided).
+      #
+      #   * :strict - Requires types signatures (not implemented).
+      #     * Strong arrows with gradual performs subtyping and returns OUT
+      #     * Weak arrows with gradual performs subtyping and returns OUT
+      #
+      #   * :static - Type signatures have been given.
+      #     * Strong arrows with gradual performs compatibility and returns OUT
+      #     * Weak arrows with gradual performs compatibility and returns OUT
+      #
+      #   * :dynamic - Type signatures have not been given.
+      #     * Strong arrows with gradual performs compatibility and returns dynamic(OUT)
+      #     * Weak arrows with gradual performs compatibility and returns dynamic()
+      #
+      #   * :infer - Same as :dynamic but skips remote calls.
+      #
+      mode: mode
     }
   end
 

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

@@ -422,8 +422,6 @@ defmodule Module.Types.Of do
     end
   end
 
-  # TODO: Implement element without a literal index
-
   def apply(:erlang, :element, [_, tuple], {_, meta, [index, _]} = expr, stack, context)
       when is_integer(index) do
     case tuple_fetch(tuple, index - 1) do
@@ -498,7 +496,7 @@ defmodule Module.Types.Of do
     end
   end
 
-  def apply(:erlang, name, [left, right], expr, stack, context)
+  def apply(:erlang, name, [left, right] = args_types, expr, stack, context)
       when name in [:>=, :"=<", :>, :<, :min, :max] do
     context =
       cond do
@@ -518,19 +516,14 @@ defmodule Module.Types.Of do
           context
       end
 
-    cond do
-      name in [:min, :max] ->
-        {union(left, right), context}
-
-      gradual?(left) or gradual?(right) ->
-        {dynamic(boolean()), context}
-
-      true ->
-        {boolean(), context}
+    if name in [:min, :max] do
+      {union(left, right), context}
+    else
+      {comparison_return(boolean(), args_types, stack), context}
     end
   end
 
-  def apply(:erlang, name, [left, right], expr, stack, context)
+  def apply(:erlang, name, [left, right] = args_types, expr, stack, context)
       when name in [:==, :"/=", :"=:=", :"=/="] do
     context =
       cond do
@@ -545,11 +538,7 @@ defmodule Module.Types.Of do
           context
       end
 
-    if gradual?(left) or gradual?(right) do
-      {dynamic(boolean()), context}
-    else
-      {boolean(), context}
-    end
+    {comparison_return(boolean(), args_types, stack), context}
   end
 
   def apply(mod, name, args_types, expr, stack, context) do
@@ -562,7 +551,7 @@ defmodule Module.Types.Of do
       false ->
         {info, context} = remote(mod, name, arity, elem(expr, 1), stack, context)
 
-        case apply_remote(info, args_types) do
+        case apply_remote(info, args_types, stack) do
           {:ok, type} ->
             {type, context}
 
@@ -573,18 +562,43 @@ defmodule Module.Types.Of do
     end
   end
 
-  defp apply_remote(:none, _args_types) do
+  defp comparison_return(type, args_types, stack) do
+    cond do
+      stack.mode == :static -> type
+      Enum.any?(args_types, &gradual?/1) -> dynamic(type)
+      true -> type
+    end
+  end
+
+  defp apply_remote(:none, _args_types, _stack) do
     {:ok, dynamic()}
   end
 
-  defp apply_remote({:strong, clauses}, args_types) do
-    Enum.find_value(clauses, {:error, clauses}, fn {expected, return} ->
-      if zip_compatible?(args_types, expected) do
-        {:ok, return}
+  defp apply_remote({:strong, clauses}, args_types, stack) do
+    if Enum.any?(args_types) do
+      returns =
+        for({expected, return} <- clauses, zip_compatible?(args_types, expected), do: return)
+
+      cond do
+        returns == [] -> {:error, clauses}
+        stack.mode == :static -> {:ok, Enum.reduce(returns, &union/2)}
+        true -> {:ok, dynamic(Enum.reduce(returns, &union/2))}
       end
-    end)
+    else
+      Enum.find_value(clauses, {:error, clauses}, fn {expected, return} ->
+        if zip_subtype?(args_types, expected) do
+          {:ok, return}
+        end
+      end)
+    end
   end
 
+  defp zip_subtype?([actual | actuals], [expected | expecteds]) do
+    subtype?(actual, expected) and zip_subtype?(actuals, expecteds)
+  end
+
+  defp zip_subtype?([], []), do: true
+
   defp zip_compatible?([actual | actuals], [expected | expecteds]) do
     compatible?(actual, expected) and zip_compatible?(actuals, expecteds)
   end

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

@@ -575,10 +575,22 @@ defmodule Module.Types.ExprTest do
   end
 
   describe "comparison" do
-    test "works across numbers" do
+    test "in static mode" do
+      assert typecheck!([x = 123, y = 456.0], x < y) == boolean()
+      assert typecheck!([x = 123, y = 456.0], x == y) == boolean()
+    end
+
+    test "in dynamic mode" do
+      assert typedyn!([x = 123, y = 456.0], x < y) == dynamic(boolean())
+      assert typedyn!([x = 123, y = 456.0], x == y) == dynamic(boolean())
+      assert typedyn!(123 == 456) == boolean()
+    end
+
+    test "min/max" do
+      assert typecheck!(min(123, 456.0)) == union(integer(), float())
+      # min/max uses parametric types, which will carry dynamic regardless of being a strong arrow
       assert typecheck!([x = 123, y = 456.0], min(x, y)) == dynamic(union(integer(), float()))
-      assert typecheck!([x = 123, y = 456.0], x < y) == dynamic(boolean())
-      assert typecheck!([x = 123, y = 456.0], x == y) == dynamic(boolean())
+      assert typedyn!([x = 123, y = 456.0], min(x, y)) == dynamic(union(integer(), float()))
     end
 
     test "warns when comparison is constant" do
@@ -606,7 +618,7 @@ defmodule Module.Types.ExprTest do
                 """}
 
       assert typewarn!([x = 123, y = 456.0], x === y) ==
-               {dynamic(boolean()),
+               {boolean(),
                 ~l"""
                 comparison between incompatible types found:
 
@@ -631,7 +643,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)) ==
-               {dynamic(boolean()),
+               {boolean(),
                 ~l"""
                 comparison with structs found:
 
@@ -662,6 +674,9 @@ defmodule Module.Types.ExprTest do
 
   describe ":erlang rewrites" do
     test "Integer.to_string/1" do
+      assert typecheck!([x = 123], Integer.to_string(x)) == binary()
+      assert typedyn!([x = 123], Integer.to_string(x)) == dynamic(binary())
+
       assert typeerror!([x = :foo], Integer.to_string(x)) |> strip_ansi() ==
                ~l"""
                incompatible types given to Integer.to_string/1:
@@ -685,6 +700,9 @@ defmodule Module.Types.ExprTest do
     end
 
     test "Bitwise.bnot/1" do
+      assert typecheck!([x = 123], Bitwise.bnot(x)) == integer()
+      assert typedyn!([x = 123], Bitwise.bnot(x)) == dynamic(integer())
+
       assert typeerror!([x = :foo], Bitwise.bnot(x)) |> strip_ansi() ==
                ~l"""
                incompatible types given to Bitwise.bnot/1:

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

@@ -18,12 +18,22 @@ defmodule TypeHelper do
     end
   end
 
+  @doc """
+  Main helper for checking the given AST type checks without warnings.
+  """
+  defmacro typedyn!(patterns \\ [], guards \\ true, body) do
+    quote do
+      unquote(typecheck(:dynamic, patterns, guards, body, __CALLER__))
+      |> TypeHelper.__typecheck__!()
+    end
+  end
+
   @doc """
   Main helper for checking the given AST type checks without warnings.
   """
   defmacro typecheck!(patterns \\ [], guards \\ true, body) do
     quote do
-      unquote(typecheck(patterns, guards, body, __CALLER__))
+      unquote(typecheck(:static, patterns, guards, body, __CALLER__))
       |> TypeHelper.__typecheck__!()
     end
   end
@@ -35,7 +45,7 @@ defmodule TypeHelper do
     [patterns, guards, body] = prune_columns([patterns, guards, body])
 
     quote do
-      unquote(typecheck(patterns, guards, body, __CALLER__))
+      unquote(typecheck(:static, patterns, guards, body, __CALLER__))
       |> TypeHelper.__typeerror__!()
     end
   end
@@ -47,7 +57,7 @@ defmodule TypeHelper do
     [patterns, guards, body] = prune_columns([patterns, guards, body])
 
     quote do
-      unquote(typecheck(patterns, guards, body, __CALLER__))
+      unquote(typecheck(:static, patterns, guards, body, __CALLER__))
       |> TypeHelper.__typewarn__!()
     end
   end
@@ -57,7 +67,7 @@ defmodule TypeHelper do
   """
   defmacro typediag!(patterns \\ [], guards \\ true, body) do
     quote do
-      unquote(typecheck(patterns, guards, body, __CALLER__))
+      unquote(typecheck(:static, patterns, guards, body, __CALLER__))
       |> TypeHelper.__typediag__!()
     end
   end
@@ -104,10 +114,7 @@ defmodule TypeHelper do
   def __typewarn__!({_type, %{warnings: warnings, failed: true}}),
     do: raise("type checking errored with warnings: #{inspect(warnings)}")
 
-  @doc """
-  Building block for typeinferring a given AST.
-  """
-  def typeinfer(patterns, guards, env) do
+  defp typeinfer(patterns, guards, env) do
     {patterns, guards, :ok} = expand_and_unpack(patterns, guards, :ok, env)
 
     quote do
@@ -119,26 +126,24 @@ defmodule TypeHelper do
   end
 
   def __typeinfer__(patterns, guards) do
-    Pattern.of_head(patterns, guards, [], new_stack(), new_context())
+    Pattern.of_head(patterns, guards, [], new_stack(:infer), new_context())
   end
 
-  @doc """
-  Building block for typechecking a given AST.
-  """
-  def typecheck(patterns, guards, body, env) do
+  defp typecheck(mode, patterns, guards, body, env) do
     {patterns, guards, body} = expand_and_unpack(patterns, guards, body, env)
 
     quote do
       TypeHelper.__typecheck__(
+        unquote(mode),
         unquote(Macro.escape(patterns)),
         unquote(Macro.escape(guards)),
         unquote(Macro.escape(body))
       )
     end
   end
 
-  def __typecheck__(patterns, guards, body) do
-    stack = new_stack()
+  def __typecheck__(mode, patterns, guards, body) do
+    stack = new_stack(mode)
     {_types, context} = Pattern.of_head(patterns, guards, [], stack, new_context())
     Expr.of_expr(body, stack, context)
   end
@@ -155,8 +160,9 @@ defmodule TypeHelper do
     {patterns, guards, body}
   end
 
-  defp new_stack() do
-    Types.stack("types_test.ex", TypesTest, {:test, 0}, [], Module.ParallelChecker.test_cache())
+  defp new_stack(mode) do
+    cache = Module.ParallelChecker.test_cache()
+    Types.stack(mode, "types_test.ex", TypesTest, {:test, 0}, [], cache)
   end
 
   defp new_context() do