Add more tests

Author: josevalim

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

@@ -610,6 +610,19 @@ defmodule Module.Types.Apply do
     not Enum.any?(stack.no_warn_undefined, &(&1 == module or &1 == {module, fun, arity}))
   end
 
+  ## Funs
+
+  def fun_apply(fun_type, args_types, call, stack, context) do
+    case fun_apply(fun_type, args_types) do
+      {:ok, res} ->
+        {res, context}
+
+      reason ->
+        error = {{:badapply, reason}, args_types, fun_type, call, context}
+        {error_type(), error(__MODULE__, error, elem(call, 1), stack, context)}
+    end
+  end
+
   ## Local
 
   def local_domain(fun, args, expected, meta, stack, context) do
@@ -805,6 +818,64 @@ defmodule Module.Types.Apply do
 
   ## Diagnostics
 
+  def format_diagnostic({{:badapply, reason}, args_types, fun_type, expr, context}) do
+    traces =
+      if reason == :badarg do
+        collect_traces(expr, context)
+      else
+        # In case there the type itself is invalid,
+        # we limit the trace.
+        collect_traces(elem(expr, 0), context)
+      end
+
+    message =
+      case reason do
+        :badarg ->
+          """
+          expected a #{length(args_types)}-arity function on call:
+
+              #{expr_to_string(expr) |> indent(4)}
+
+          but got type:
+
+              #{to_quoted_string(fun_type) |> indent(4)}
+          """
+
+        {:badarity, arities} ->
+          info =
+            case arities do
+              [arity] -> "function with arity #{arity}"
+              _ -> "function with arities #{Enum.join(arities, ",")}"
+            end
+
+          """
+          expected a #{length(args_types)}-arity function on call:
+
+              #{expr_to_string(expr) |> indent(4)}
+
+          but got #{info}:
+
+              #{to_quoted_string(fun_type) |> indent(4)}
+          """
+
+        :badfun ->
+          """
+          expected a #{length(args_types)}-arity function on call:
+
+              #{expr_to_string(expr) |> indent(4)}
+
+          but got type:
+
+              #{to_quoted_string(fun_type) |> indent(4)}
+          """
+      end
+
+    %{
+      details: %{typing_traces: traces},
+      message: IO.iodata_to_binary([message, format_traces(traces)])
+    }
+  end
+
   def format_diagnostic({:badlocal, {_, domain, clauses}, args_types, expr, context}) do
     domain = domain(domain, clauses)
     traces = collect_traces(expr, context)

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

@@ -717,39 +717,6 @@ defmodule Module.Types.Descr do
         do: {type, [], []}
   end
 
-  ## Funs
-
-  @doc """
-  Checks if a function type with the specified arity exists in the descriptor.
-
-  1. If there is no dynamic component:
-     - The static part must be a non-empty function type of the given arity
-
-  2. If there is a dynamic component:
-     - Either the static part is a non-empty function type of the given arity, or
-     - The static part is empty and the dynamic part contains functions of the given arity
-  """
-  # TODO: REMOVE ME
-  def fun_fetch(:term, _arity), do: :error
-
-  def fun_fetch(%{} = descr, arity) when is_integer(arity) do
-    case :maps.take(:dynamic, descr) do
-      :error ->
-        if not empty?(descr) and fun_only?(descr, arity), do: :ok, else: :error
-
-      {dynamic, static} ->
-        empty_static? = empty?(static)
-
-        cond do
-          not empty_static? -> if fun_only?(static, arity), do: :ok, else: :error
-          empty_static? and not empty?(intersection(dynamic, fun(arity))) -> :ok
-          true -> :error
-        end
-    end
-  end
-
-  defp fun_only?(descr, arity), do: empty?(difference(descr, fun(arity)))
-
   ## Atoms
 
   # The atom component of a type consists of pairs `{tag, set}` where `set` is a
@@ -984,22 +951,26 @@ defmodule Module.Types.Descr do
   @doc """
   Applies a function type to a list of argument types.
 
-  Returns the result type if the application is valid, or `:badarg` if not.
+  Returns `{:ok, result}` if the application is valid
+  or one `:badarg`, `:badfun`, `{:badarity, arities}` if not.
 
   Handles both static and dynamic function types:
+
   1. For static functions: checks exact argument types
   2. For dynamic functions: computes result based on both static and dynamic parts
   3. For mixed static/dynamic: computes all valid combinations
 
-  # Function application formula for dynamic types:
-  #   τ◦τ′ = (lower_bound(τ) ◦ upper_bound(τ′)) ∨ (dynamic(upper_bound(τ) ◦ lower_bound(τ′)))
-  #
-  # Where:
-  # - τ is a dynamic function type
-  # - τ′ are the arguments
-  # - ◦ is function application
-  #
-  # For more details, see Definition 6.15 in https://vlanvin.fr/papers/thesis.pdf
+  ## Function application formula for dynamic types
+
+      τ◦τ′ = (lower_bound(τ) ◦ upper_bound(τ′)) ∨ (dynamic(upper_bound(τ) ◦ lower_bound(τ′)))
+
+  Where:
+
+  - τ is a dynamic function type
+  - τ′ are the arguments
+  - ◦ is function application
+
+  For more details, see Definition 6.15 in https://vlanvin.fr/papers/thesis.pdf
 
   ## Examples
 
@@ -1028,6 +999,13 @@ defmodule Module.Types.Descr do
             :badfun
           end
 
+        # Optimize the cases where dynamic closes over all function types
+        {:term, fun_static} when fun_static == %{} ->
+          {:ok, dynamic()}
+
+        {%{fun: @fun_top}, fun_static} when fun_static == %{} ->
+          {:ok, dynamic()}
+
         {fun_dynamic, fun_static} ->
           if fun_only?(fun_static) do
             fun_apply_with_strategy(fun_static, fun_dynamic, arguments)

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

@@ -450,20 +450,13 @@ defmodule Module.Types.Expr do
   end
 
   # TODO: fun.(args)
-  def of_expr({{:., meta, [fun]}, _meta, args} = call, _expected, _expr, stack, context) do
+  def of_expr({{:., _, [fun]}, _, args} = call, _expected, _expr, stack, context) do
     {fun_type, context} = of_expr(fun, fun(length(args)), call, stack, context)
 
-    {_args_types, context} =
+    {args_types, context} =
       Enum.map_reduce(args, context, &of_expr(&1, @pending, &1, stack, &2))
 
-    case fun_fetch(fun_type, length(args)) do
-      :ok ->
-        {dynamic(), context}
-
-      :error ->
-        error = {:badfun, length(args), fun_type, fun, call, context}
-        {error_type(), error(__MODULE__, error, meta, stack, context)}
-    end
+    Apply.fun_apply(fun_type, args_types, call, stack, context)
   end
 
   def of_expr({{:., _, [callee, key_or_fun]}, meta, []} = call, expected, expr, stack, context)
@@ -863,27 +856,6 @@ defmodule Module.Types.Expr do
     }
   end
 
-  def format_diagnostic({:badfun, arity, type, fun_expr, call_expr, context}) do
-    traces = collect_traces(fun_expr, context)
-
-    %{
-      details: %{typing_traces: traces},
-      message:
-        IO.iodata_to_binary([
-          """
-          expected a #{arity}-arity function on call:
-
-              #{expr_to_string(call_expr) |> indent(4)}
-
-          but got type:
-
-              #{to_quoted_string(type) |> indent(4)}
-          """,
-          format_traces(traces)
-        ])
-    }
-  end
-
   def format_diagnostic({:badcond, explain, type, expr, context}) do
     traces = collect_traces(expr, context)
 

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

@@ -758,6 +758,10 @@ defmodule Module.Types.DescrTest do
     end
 
     test "static" do
+      # Full static
+      assert fun_apply(fun(), [integer()]) == {:ok, term()}
+      assert fun_apply(difference(fun(), fun(2)), [integer()]) == {:ok, term()}
+
       # Basic function application scenarios
       assert fun_apply(fun([integer()], atom()), [integer()]) == {:ok, atom()}
       assert fun_apply(fun([integer()], atom()), [float()]) == :badarg
@@ -820,6 +824,10 @@ defmodule Module.Types.DescrTest do
     defp dynamic_fun(args, return), do: dynamic(fun(args, return))
 
     test "dynamic" do
+      # Full dynamic
+      assert fun_apply(dynamic(), [integer()]) == {:ok, dynamic()}
+      assert fun_apply(difference(dynamic(), integer()), [integer()]) == {:ok, dynamic()}
+
       # Basic function application scenarios
       assert fun_apply(dynamic_fun([integer()], atom()), [integer()]) == {:ok, dynamic(atom())}
       assert fun_apply(dynamic_fun([integer()], atom()), [float()]) == :badarg