Progress?

Author: josevalim

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

@@ -1000,15 +1000,21 @@ defmodule Module.Types.Descr do
           end
 
         # Optimize the cases where dynamic closes over all function types
-        {:term, fun_static} when fun_static == %{} ->
-          {:ok, dynamic()}
+        # {:term, fun_static} when fun_static == %{} ->
+        #   {:ok, dynamic()}
 
-        {%{fun: @fun_top}, 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)
+            with :badarg <- fun_apply_with_strategy(fun_static, fun_dynamic, arguments) do
+              if compatible?(fun, fun(arguments, term())) do
+                {:ok, dynamic()}
+              else
+                :badarg
+              end
+            end
           else
             :badfun
           end
@@ -1106,11 +1112,19 @@ defmodule Module.Types.Descr do
   #
   # This function is used internally by `fun_apply_*`, and others to
   # ensure consistent handling of function types in all operations.
+  defp fun_normalize(:term, arity, mode) do
+    fun_normalize(%{fun: @fun_top}, arity, mode)
+  end
+
   defp fun_normalize(%{fun: bdd}, arity, mode) do
     {domain, arrows, bad_arities} =
       Enum.reduce(fun_get(bdd), {term(), [], []}, fn
-        {[{args, _} | _] = pos_funs, neg_funs}, {domain, arrows, bad_arities} ->
-          arrow_arity = length(args)
+        {pos_funs, neg_funs}, {domain, arrows, bad_arities} ->
+          arrow_arity =
+            case pos_funs do
+              [{args, _} | _] -> length(args)
+              _ -> arity
+            end
 
           cond do
             arrow_arity != arity ->
@@ -1393,8 +1407,6 @@ defmodule Module.Types.Descr do
   end
 
   # Converts a function BDD (Binary Decision Diagram) to its quoted representation.
-  defp fun_to_quoted(:fun, _opts), do: [{:fun, [], []}]
-
   defp fun_to_quoted(bdd, opts) do
     arrows = fun_get(bdd)
 

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

@@ -51,7 +51,7 @@ defmodule Module.Types.Expr do
   @stacktrace list(
                 union(
                   tuple([atom(), atom(), args_or_arity, extra_info]),
-                  tuple([fun(), args_or_arity, extra_info])
+                  tuple([dynamic(fun()), args_or_arity, extra_info])
                 )
               )
 

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

@@ -10,7 +10,7 @@ end
 defmodule Module.Types.DescrTest do
   use ExUnit.Case, async: true
 
-  import Module.Types.Descr
+  import Module.Types.Descr, except: [fun: 1]
 
   describe "union" do
     test "bitmap" do
@@ -111,7 +111,7 @@ defmodule Module.Types.DescrTest do
 
     test "fun" do
       assert equal?(union(fun(), fun()), fun())
-      assert equal?(union(fun(), fun(1)), fun())
+      assert equal?(union(fun(), none_fun(1)), fun())
 
       dynamic_fun = intersection(fun(), dynamic())
       assert equal?(union(dynamic_fun, fun()), fun())
@@ -335,7 +335,7 @@ defmodule Module.Types.DescrTest do
     end
 
     test "function" do
-      assert not empty?(intersection(negation(fun(2)), negation(fun(3))))
+      assert not empty?(intersection(negation(none_fun(2)), negation(none_fun(3))))
     end
   end
 
@@ -528,19 +528,19 @@ defmodule Module.Types.DescrTest do
 
     test "fun" do
       for arity <- [0, 1, 2, 3] do
-        assert empty?(difference(fun(arity), fun(arity)))
+        assert empty?(difference(none_fun(arity), none_fun(arity)))
       end
 
       assert empty?(difference(fun(), fun()))
-      assert empty?(difference(fun(3), fun()))
-      refute empty?(difference(fun(), fun(1)))
-      refute empty?(difference(fun(2), fun(3)))
-      assert empty?(intersection(fun(2), fun(3)))
+      assert empty?(difference(none_fun(3), fun()))
+      refute empty?(difference(fun(), none_fun(1)))
+      refute empty?(difference(none_fun(2), none_fun(3)))
+      assert empty?(intersection(none_fun(2), none_fun(3)))
 
-      f1f2 = union(fun(1), fun(2))
-      assert f1f2 |> difference(fun(1)) |> difference(fun(2)) |> empty?()
-      assert fun(1) |> difference(difference(f1f2, fun(2))) |> empty?()
-      assert f1f2 |> difference(fun(1)) |> equal?(fun(2))
+      f1f2 = union(none_fun(1), none_fun(2))
+      assert f1f2 |> difference(none_fun(1)) |> difference(none_fun(2)) |> empty?()
+      assert none_fun(1) |> difference(difference(f1f2, none_fun(2))) |> empty?()
+      assert f1f2 |> difference(none_fun(1)) |> equal?(none_fun(2))
 
       assert fun([integer()], term()) |> difference(fun([none()], term())) |> empty?()
     end
@@ -742,25 +742,27 @@ defmodule Module.Types.DescrTest do
 
     test "fun" do
       refute empty?(fun())
-      refute empty?(fun(1))
+      refute empty?(none_fun(1))
       refute empty?(fun([integer()], atom()))
 
-      assert empty?(intersection(fun(1), fun(2)))
-      refute empty?(intersection(fun(), fun(1)))
-      assert empty?(difference(fun(1), union(fun(1), fun(2))))
+      assert empty?(intersection(none_fun(1), none_fun(2)))
+      refute empty?(intersection(fun(), none_fun(1)))
+      assert empty?(difference(none_fun(1), union(none_fun(1), none_fun(2))))
     end
   end
 
   describe "function application" do
+    defp none_fun(arity), do: fun(List.duplicate(none(), arity), term())
+
     test "non funs" do
       assert fun_apply(term(), [integer()]) == :badfun
-      assert fun_apply(union(integer(), fun(1)), [integer()]) == :badfun
+      assert fun_apply(union(integer(), none_fun(1)), [integer()]) == :badfun
     end
 
     test "static" do
       # Full static
-      assert fun_apply(fun(), [integer()]) == {:ok, term()}
-      assert fun_apply(difference(fun(), fun(2)), [integer()]) == {:ok, term()}
+      assert fun_apply(fun(), [integer()]) == :badarg
+      assert fun_apply(difference(fun(), none_fun(2)), [integer()]) == :badarg
 
       # Basic function application scenarios
       assert fun_apply(fun([integer()], atom()), [integer()]) == {:ok, atom()}
@@ -776,7 +778,13 @@ defmodule Module.Types.DescrTest do
       assert fun_apply(fun([integer()], integer()), [term(), term()]) == {:badarity, [1]}
       assert fun_apply(fun([integer(), atom()], boolean()), [integer()]) == {:badarity, [2]}
 
-      # Function intersection tests - basic
+      # Function intersection tests (no overlap)
+      fun0 = intersection(fun([integer()], atom()), fun([float()], binary()))
+      assert fun_apply(fun0, [integer()]) == {:ok, atom()}
+      assert fun_apply(fun0, [float()]) == {:ok, binary()}
+      assert fun_apply(fun0, [union(integer(), float())]) == {:ok, union(atom(), binary())}
+
+      # Function intersection tests (overlap)
       fun1 = intersection(fun([integer()], atom()), fun([number()], term()))
       assert fun_apply(fun1, [integer()]) == {:ok, atom()}
       assert fun_apply(fun1, [float()]) == {:ok, term()}
@@ -816,8 +824,8 @@ defmodule Module.Types.DescrTest do
 
       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, [dynamic(number())]) == {:ok, dynamic()}
+      assert fun_apply(fun, [integer()]) == {:ok, dynamic()}
       assert fun_apply(fun, [float()]) == :badarg
     end
 
@@ -826,12 +834,13 @@ defmodule Module.Types.DescrTest do
     test "dynamic" do
       # Full dynamic
       assert fun_apply(dynamic(), [integer()]) == {:ok, dynamic()}
-      assert fun_apply(difference(dynamic(), integer()), [integer()]) == {:ok, dynamic()}
+      assert fun_apply(dynamic(none_fun(1)), [integer()]) == {:ok, dynamic()}
+      assert fun_apply(difference(dynamic(), none_fun(2)), [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
-      assert fun_apply(dynamic_fun([integer()], atom()), [term()]) == :badarg
+      assert fun_apply(dynamic_fun([integer()], atom()), [float()]) == {:ok, dynamic()}
+      assert fun_apply(dynamic_fun([integer()], atom()), [term()]) == {:ok, dynamic()}
       assert fun_apply(dynamic_fun([integer()], none()), [integer()]) == {:ok, dynamic(none())}
       assert fun_apply(dynamic_fun([integer()], term()), [integer()]) == {:ok, dynamic()}
 
@@ -841,7 +850,7 @@ defmodule Module.Types.DescrTest do
       fun = dynamic_fun([integer()], binary())
       assert fun_apply(fun, [integer()]) == {:ok, dynamic(binary())}
       assert fun_apply(fun, [dynamic(integer())]) == {:ok, dynamic(binary())}
-      assert fun_apply(fun, [dynamic(atom())]) == :badarg
+      assert fun_apply(fun, [dynamic(atom())]) == {:ok, dynamic()}
 
       # Arity mismatches
       assert fun_apply(dynamic_fun([integer()], integer()), [term(), term()]) == {:badarity, [1]}
@@ -916,20 +925,20 @@ defmodule Module.Types.DescrTest do
           dynamic_fun([integer()], binary())
         )
 
-      assert fun_args |> fun_apply([atom()]) == :badarg
+      assert fun_args |> fun_apply([atom()]) == {:ok, dynamic()}
       assert fun_args |> fun_apply([integer()]) == :badarg
 
       # Badfun
       assert union(
                fun([atom()], integer()),
-               dynamic_fun([integer()], binary()) |> intersection(fun(2))
+               dynamic_fun([integer()], binary()) |> intersection(none_fun(2))
              )
              |> fun_apply([atom()])
              |> elem(1)
              |> equal?(integer())
 
       assert union(
-               fun([atom()], integer()) |> intersection(fun(2)),
+               fun([atom()], integer()) |> intersection(none_fun(2)),
                dynamic_fun([integer()], binary())
              )
              |> fun_apply([integer()]) == {:ok, dynamic(binary())}
@@ -1744,7 +1753,7 @@ defmodule Module.Types.DescrTest do
 
     test "function" do
       assert fun() |> to_quoted_string() == "fun()"
-      assert fun(1) |> to_quoted_string() == "(none() -> term())"
+      assert none_fun(1) |> to_quoted_string() == "(none() -> term())"
 
       assert fun([dynamic(integer())], float()) |> to_quoted_string() ==
                "dynamic((none() -> float())) or (integer() -> float())"