Rely on more consistent return types for fun descr

Author: josevalim

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

@@ -973,7 +973,7 @@ defmodule Module.Types.Descr do
   For a function type, the domain is the set of valid input types.
 
   Returns:
-  - `:badfunction` if the type is not a function type
+  - `:badfun` if the type is not a function type
   - A tuple type representing the domain for valid function types
 
   Handles both static and dynamic function types:
@@ -990,7 +990,7 @@ defmodule Module.Types.Descr do
       iex> fun_domain(fun([integer(), float()], boolean()))
       domain_repr([integer(), float()])
   """
-  def fun_domain(:term), do: :badfunction
+  def fun_domain(:term), do: :badfun
 
   def fun_domain(type) do
     result =
@@ -1000,7 +1000,7 @@ defmodule Module.Types.Descr do
           with true <- fun_only?(type), {:ok, domain} <- fun_domain_static(type) do
             domain
           else
-            _ -> :badfunction
+            _ -> :badfun
           end
 
         {dynamic, static} when static == @none ->
@@ -1012,34 +1012,33 @@ defmodule Module.Types.Descr do
                {:ok, dynamic_domain} <- fun_domain_static(dynamic) do
             union(dynamic_domain, dynamic(static_domain))
           else
-            _ -> :badfunction
+            _ -> :badfun
           end
       end
 
     case result do
-      :badfunction -> :badfunction
-      result -> if empty?(result), do: :badfunction, else: result
+      :badfun -> :badfun
+      result -> if empty?(result), do: :badfun, else: result
     end
   end
 
   # Returns {:ok, domain} if the domain of the static type is well-defined.
   # For that, it has to contain a non-empty function type.
-  # Otherwise, returns :badfunction.
+  # Otherwise, returns :badfun.
   defp fun_domain_static(%{fun: bdd}) do
     case fun_normalize(bdd) do
       {domain, _, _} -> {:ok, domain}
       _ -> {:ok, none()}
     end
   end
 
-  defp fun_domain_static(:term), do: :badfunction
+  defp fun_domain_static(:term), do: :badfun
   defp fun_domain_static(%{}), do: {:ok, none()}
-  defp fun_domain_static(:empty_function), do: {:ok, none()}
 
   @doc """
   Applies a function type to a list of argument types.
 
-  Returns the result type if the application is valid, or `:badarguments` if not.
+  Returns the result type if the application is valid, or `:badarg` if not.
 
   Handles both static and dynamic function types:
   1. For static functions: checks exact argument types
@@ -1061,14 +1060,14 @@ defmodule Module.Types.Descr do
       atom()
 
       iex> fun_apply(fun([integer()], atom()), [float()])
-      :badarguments
+      :badarg
 
       iex> fun_apply(fun([dynamic()], atom()), [dynamic()])
       atom()
   """
   def fun_apply(fun, arguments) do
     if empty?(domain_descr(arguments)) do
-      :badarguments
+      :badarg
     else
       case :maps.take(:dynamic, fun) do
         :error -> fun_apply_with_strategy(fun, nil, arguments)
@@ -1096,7 +1095,7 @@ defmodule Module.Types.Descr do
            {:ok, res2} <- fun_apply_static(dynamic_fun, dynamic_args) do
         union(res1, dynamic(res2))
       else
-        _ -> :badarguments
+        _ -> :badarg
       end
     end
   end
@@ -1110,40 +1109,42 @@ defmodule Module.Types.Descr do
   defp fun_apply_static(%{fun: fun_bdd}, arguments) do
     type_args = domain_descr(arguments)
 
-    if empty?(type_args) do
-      # At this stage we do not check that the function can be applied to the arguments (using domain)
-      with {_domain, arrows, arity} <- fun_normalize(fun_bdd),
-           true <- arity == length(arguments) do
-        # Opti: short-circuits when inner loop is none() or outer loop is term()
-        result =
-          Enum.reduce_while(arrows, none(), fn intersection_of_arrows, acc ->
-            Enum.reduce_while(intersection_of_arrows, term(), fn
-              {_dom, _ret}, acc when acc == @none -> {:halt, acc}
-              {_dom, ret}, acc -> {:cont, intersection(acc, ret)}
-            end)
-            |> case do
-              :term -> {:halt, :term}
-              inner -> {:cont, union(inner, acc)}
-            end
-          end)
+    case fun_normalize(fun_bdd) do
+      {domain, arrows, arity} when arity == length(arguments) ->
+        cond do
+          empty?(type_args) ->
+            # Opti: short-circuits when inner loop is none() or outer loop is term()
+            result =
+              Enum.reduce_while(arrows, none(), fn intersection_of_arrows, acc ->
+                Enum.reduce_while(intersection_of_arrows, term(), fn
+                  {_dom, _ret}, acc when acc == @none -> {:halt, acc}
+                  {_dom, ret}, acc -> {:cont, intersection(acc, ret)}
+                end)
+                |> case do
+                  :term -> {:halt, :term}
+                  inner -> {:cont, union(inner, acc)}
+                end
+              end)
 
-        {:ok, result}
-      else
-        false -> :badarity
-      end
-    else
-      with {domain, arrows, arity} <- fun_normalize(fun_bdd),
-           true <- arity == length(arguments),
-           true <- subtype?(type_args, domain) do
-        result =
-          Enum.reduce(arrows, none(), fn intersection_of_arrows, acc ->
-            aux_apply(acc, type_args, term(), intersection_of_arrows)
-          end)
+            {:ok, result}
 
-        {:ok, result}
-      else
-        _ -> :badarguments
-      end
+          subtype?(type_args, domain) ->
+            result =
+              Enum.reduce(arrows, none(), fn intersection_of_arrows, acc ->
+                aux_apply(acc, type_args, term(), intersection_of_arrows)
+              end)
+
+            {:ok, result}
+
+          true ->
+            :badarg
+        end
+
+      {_, _, arity} ->
+        {:badarity, arity}
+
+      :badfun ->
+        :badfun
     end
   end
 
@@ -1218,7 +1219,7 @@ defmodule Module.Types.Descr do
   ## Return Values
   #
   # - `{domain, arrows, arity}` for valid function BDDs
-  # - `:empty_function` if the BDD represents an empty function type
+  # - `:badfun` if the BDD represents an empty function type
   #
   # ## Internal Use
   #
@@ -1245,7 +1246,7 @@ defmodule Module.Types.Descr do
         end
       end)
 
-    if arrows == [], do: :empty_function, else: {domain, arrows, arity}
+    if arrows == [], do: :badfun, else: {domain, arrows, arity}
   end
 
   # Checks if a function type is empty.

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

@@ -764,19 +764,19 @@ defmodule Module.Types.DescrTest do
       # For function domain:
       # 1. The domain of an intersection of functions is the union of the domains of the functions
       # 2. The domain of a union of functions is the intersection of the domains of the functions
-      # 3. If a type is not a function or its domain is empty, return :badfunction
+      # 3. If a type is not a function or its domain is empty, return :badfun
 
       # For gradual domain of a function type t:
       # It is dom(t) = dom(up(t)) ∪ dynamic(dom(down(t)))
       # where dom is the static domain, up is the upcast, and down is the downcast.
 
       ## Basic domain tests
-      assert fun_domain(term()) == :badfunction
-      assert fun_domain(none()) == :badfunction
-      assert fun_domain(intersection(fun(1), fun(2))) == :badfunction
-      assert union(atom(), intersection(fun(1), fun(2))) |> fun_domain() == :badfunction
-      assert fun_domain(fun([none()], term())) == :badfunction
-      assert fun_domain(difference(fun([pid()], pid()), fun([pid()], term()))) == :badfunction
+      assert fun_domain(term()) == :badfun
+      assert fun_domain(none()) == :badfun
+      assert fun_domain(intersection(fun(1), fun(2))) == :badfun
+      assert union(atom(), intersection(fun(1), fun(2))) |> fun_domain() == :badfun
+      assert fun_domain(fun([none()], term())) == :badfun
+      assert fun_domain(difference(fun([pid()], pid()), fun([pid()], term()))) == :badfun
 
       assert_domain(fun([], term()), [])
       assert_domain(fun([term()], atom()), [term()])
@@ -787,8 +787,8 @@ defmodule Module.Types.DescrTest do
       assert_domain(union(fun([number()], term()), fun([float()], term())), [float()])
 
       ## Gradual domain tests
-      assert fun_domain(dynamic()) == :badfunction
-      assert fun_domain(intersection(dynamic(), fun([none()], term()))) == :badfunction
+      assert fun_domain(dynamic()) == :badfun
+      assert fun_domain(intersection(dynamic(), fun([none()], term()))) == :badfun
       assert_domain(fun([dynamic()], dynamic()), [dynamic()])
       assert_domain(fun([dynamic(), dynamic()], dynamic()), [dynamic(), dynamic()])
       assert_domain(intersection(fun([integer()], atom()), dynamic()), [integer()])
@@ -817,7 +817,7 @@ defmodule Module.Types.DescrTest do
 
       # Intersection of domains int and float is empty
       assert union(fun([integer()], atom()), fun([float()], boolean())) |> fun_domain() ==
-               :badfunction
+               :badfun
     end
 
     test "function application" do
@@ -826,14 +826,14 @@ defmodule Module.Types.DescrTest do
 
       # Basic function application scenarios
       assert fun_apply(fun([integer()], atom()), [integer()]) == atom()
-      assert fun_apply(fun([integer()], atom()), [float()]) == :badarguments
-      assert fun_apply(fun([integer()], atom()), [term()]) == :badarguments
+      assert fun_apply(fun([integer()], atom()), [float()]) == :badarg
+      assert fun_apply(fun([integer()], atom()), [term()]) == :badarg
       assert fun_apply(fun([integer()], none()), [integer()]) == none()
       assert fun_apply(fun([integer()], term()), [integer()]) == term()
 
       # Arity mismatches
-      assert fun_apply(fun([dynamic()], integer()), [dynamic(), dynamic()]) == :badarguments
-      assert fun_apply(fun([integer(), atom()], boolean()), [integer()]) == :badarguments
+      assert fun_apply(fun([dynamic()], integer()), [dynamic(), dynamic()]) == :badarg
+      assert fun_apply(fun([integer(), atom()], boolean()), [integer()]) == {:badarity, 2}
 
       # Dynamic type handling
       assert fun_apply(fun([dynamic()], term()), [dynamic()]) == term()
@@ -866,9 +866,9 @@ defmodule Module.Types.DescrTest do
 
       fun9 = fun([intersection(dynamic(), integer())], atom())
       assert fun_apply(fun9, [dynamic(integer())]) |> equal?(atom())
-      assert fun_apply(fun9, [dynamic()]) == :badarguments
+      assert fun_apply(fun9, [dynamic()]) == :badarg
       # TODO: discuss this case
-      assert fun_apply(fun9, [integer()]) == :badarguments
+      assert fun_apply(fun9, [integer()]) == :badarg
 
       # Dynamic with function type combinations
       fun12 =