Revert "Surface dynamic up in function creation"

This reverts commit f253a73.

Author: josevalim

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

@@ -944,19 +944,31 @@ defmodule Module.Types.Descr do
   # Creates a function type from a list of inputs and an output
   # where the inputs and/or output may be dynamic.
   #
-  # One approach is, for function (t → s) with dynamic components:
+  # For function (t → s) with dynamic components:
   # - Static part: (upper_bound(t) → lower_bound(s))
   # - Dynamic part: dynamic(lower_bound(t) → upper_bound(s))
   #
-  # However, this comes with the downside that `dynamic(integer()) -> binary()`
-  # cannot receive integers as arguments. So instead we surface the dynamic up,
-  # as we do for other data types, converting it to `dynamic((integer() -> binary()))`.
-  # One could obtain the other type if desired by explicitly defining it.
+  # When handling dynamic types:
+  # - `upper_bound(t)` extracts the upper bound (most general type) of a gradual type.
+  #   For `dynamic(integer())`, it is `integer()`.
+  # - `lower_bound(t)` extracts the lower bound (most specific type) of a gradual type.
   defp fun_descr(args, output) when is_list(args) do
-    if any_dynamic?([output | args]) do
-      [output | args] = Enum.map([output | args], &upper_bound/1)
-      %{dynamic: %{fun: fun_new(args, output)}}
+    dynamic_arguments? = any_dynamic?(args)
+    dynamic_output? = match?(%{dynamic: _}, output)
+
+    if dynamic_arguments? or dynamic_output? do
+      input_static = if dynamic_arguments?, do: Enum.map(args, &upper_bound/1), else: args
+      input_dynamic = if dynamic_arguments?, do: Enum.map(args, &lower_bound/1), else: args
+
+      output_static = if dynamic_output?, do: lower_bound(output), else: output
+      output_dynamic = if dynamic_output?, do: upper_bound(output), else: output
+
+      %{
+        fun: fun_new(input_static, output_static),
+        dynamic: %{fun: fun_new(input_dynamic, output_dynamic)}
+      }
     else
+      # No dynamic components, use standard function type
       %{fun: fun_new(args, output)}
     end
   end

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

@@ -777,7 +777,7 @@ defmodule Module.Types.DescrTest do
       assert fun_apply(fun1, [integer()]) == {:ok, atom()}
       assert fun_apply(fun1, [float()]) == {:ok, term()}
 
-      # Function intersection with unions and dynamic return
+      # Function intersection with unions
       fun2 =
         intersection(
           fun([union(integer(), atom())], term()),
@@ -798,6 +798,25 @@ defmodule Module.Types.DescrTest do
       assert fun_apply(fun3, [atom([:ok])]) == {:ok, none()}
     end
 
+    test "static with dynamic signature" do
+      assert fun_apply(fun([dynamic()], term()), [dynamic()]) == {:ok, term()}
+      assert fun_apply(fun([integer()], dynamic()), [integer()]) == {:ok, dynamic()}
+
+      assert fun_apply(fun([dynamic()], integer()), [dynamic()])
+             |> elem(1)
+             |> equal?(integer())
+
+      assert fun_apply(fun([dynamic(), atom()], float()), [dynamic(), atom()])
+             |> elem(1)
+             |> equal?(float())
+
+      fun = fun([dynamic(integer())], atom())
+      assert fun_apply(fun, [dynamic(integer())]) |> elem(1) |> equal?(atom())
+      assert fun_apply(fun, [dynamic(number())]) == :badarg
+      assert fun_apply(fun, [integer()]) == :badarg
+      assert fun_apply(fun, [float()]) == :badarg
+    end
+
     defp dynamic_fun(args, return), do: dynamic(fun(args, return))
 
     test "dynamic" do
@@ -1689,11 +1708,14 @@ defmodule Module.Types.DescrTest do
       assert fun() |> to_quoted_string() == "fun()"
       assert fun(1) |> to_quoted_string() == "(none() -> term())"
 
-      assert fun([integer(), float()], boolean()) |> to_quoted_string() ==
-               "(integer(), float() -> boolean())"
+      assert fun([dynamic(integer())], float()) |> to_quoted_string() ==
+               "dynamic((none() -> float())) or (integer() -> float())"
 
       assert fun([integer(), float()], dynamic()) |> to_quoted_string() ==
-               "dynamic((integer(), float() -> term()))"
+               "dynamic((integer(), float() -> term())) or (integer(), float() -> none())"
+
+      assert fun([integer(), float()], boolean()) |> to_quoted_string() ==
+               "(integer(), float() -> boolean())"
 
       assert fun([integer()], boolean())
              |> union(fun([float()], boolean()))