Clean up typing changes

Author: josevalim

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

@@ -1619,7 +1619,7 @@ defmodule Module.Types.Apply do
 
     {message, to_trace, hints} =
       case reason do
-        {:badarg, domain} ->
+        {:badarg, domain, _empty?} ->
           message = """
           incompatible types given on #{mfa_or_call}:
 

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

@@ -1357,8 +1357,8 @@ defmodule Module.Types.Descr do
   Applies a function type to a list of argument types.
 
   Returns `{:ok, result}` if the application is valid
-  or one `{:badarg, to_succeed_domain}`, `:badfun`,
-  `{:badarity, arities}` if not.
+  or one `{:badarg, to_succeed_domain, empty?}`, `:badfun`,
+  or `{:badarity, arities}`.
 
   Note the domain returned by `:badarg` is not the strong
   domain, but the domain that must be satisfied for the
@@ -1442,63 +1442,63 @@ defmodule Module.Types.Descr do
     static? = fun_dynamic == nil and Enum.all?(arguments, fn arg -> not gradual?(arg) end)
     arity = length(arguments)
 
-    with false <- Enum.any?(arguments, &empty?/1),
-         {:ok, domain, static_arrows, dynamic_arrows} <-
-           fun_normalize_both(fun_static, fun_dynamic, arity) do
-      cond do
-        # The domain here is the extended gradual domain computed by
-        # fun_normalize_both/3. If the argument does not satisfy it, we
-        # check compatibility before rejecting.
-        #
-        # Compatibility has two cases to avoid a degenerate situation.
-        # If the argument is purely dynamic (e.g. dynamic() and bool()),
-        # its static part (lower bound) is none(). We do not want
-        # none() <= domain to trivially succeed, because that would mean
-        # "a diverging argument is accepted by any function", which is true but
-        # useless. So when the static part is empty, we instead check
-        # that the upper bound overlaps with the domain. When the static
-        # part is non-empty, we check it is a subtype of the domain.
-        not subtype?(args_domain, domain) ->
-          if static? or not compatible?(args_domain, domain),
-            do: {:badarg, domain_to_flat_args(domain, arity)},
-            else: {:ok, dynamic()}
-
-        static? ->
-          {:ok, fun_apply_static(arguments, static_arrows)}
-
-        static_arrows == [] ->
-          # Purely dynamic function (e.g. dynamic() and (integer() -> integer())).
-          # There are no static arrows, so the general mixed formula simplifies:
-          # applying none() to anything yields none(), so the static branch
-          # vanishes and only the dynamic branch remains.
-          # The result is wrapped in dynamic(), so it is safe regardless of argument precision.
-          # If the upper-bounded arguments escape the domain, fun_apply_static returns term(),
-          # and dynamic(term()) = dynamic(), which brings back to the compatible case.
-          arguments = Enum.map(arguments, &upper_bound/1)
-          {:ok, dynamic(fun_apply_static(arguments, dynamic_arrows))}
+    if Enum.any?(arguments, &empty?/1) do
+      {:badarg, arguments, true}
+    else
+      with {:ok, domain, static_arrows, dynamic_arrows} <-
+             fun_normalize_both(fun_static, fun_dynamic, arity) do
+        cond do
+          # The domain here is the extended gradual domain computed by
+          # fun_normalize_both/3. If the argument does not satisfy it, we
+          # check compatibility before rejecting.
+          #
+          # Compatibility has two cases to avoid a degenerate situation.
+          # If the argument is purely dynamic (e.g. dynamic() and bool()),
+          # its static part (lower bound) is none(). We do not want
+          # none() <= domain to trivially succeed, because that would mean
+          # "a diverging argument is accepted by any function", which is true but
+          # useless. So when the static part is empty, we instead check
+          # that the upper bound overlaps with the domain. When the static
+          # part is non-empty, we check it is a subtype of the domain.
+          not subtype?(args_domain, domain) ->
+            if static? or not compatible?(args_domain, domain),
+              do: {:badarg, domain_to_flat_args(domain, arity), false},
+              else: {:ok, dynamic()}
+
+          static? ->
+            {:ok, fun_apply_static(arguments, static_arrows)}
+
+          static_arrows == [] ->
+            # Purely dynamic function (e.g. dynamic() and (integer() -> integer())).
+            # There are no static arrows, so the general mixed formula simplifies:
+            # applying none() to anything yields none(), so the static branch
+            # vanishes and only the dynamic branch remains.
+            # The result is wrapped in dynamic(), so it is safe regardless of argument precision.
+            # If the upper-bounded arguments escape the domain, fun_apply_static returns term(),
+            # and dynamic(term()) = dynamic(), which brings back to the compatible case.
+            arguments = Enum.map(arguments, &upper_bound/1)
+            {:ok, dynamic(fun_apply_static(arguments, dynamic_arrows))}
 
-        true ->
-          # Mixed case: union of the static and dynamic results.
-          # static_arrows (lower materialization) contain only arrows that are
-          # guaranteed to exist at runtime. Static guarantees about the result
-          # come from these alone.
-          # dynamic_arrows (upper materialization) include dynamically uncertain
-          # arrows, so their result is wrapped in dynamic().
-          # We use upper_bound on the arguments for both branches. This is sound
-          # because the dynamic branch wraps its result in dynamic().
-          # It is more strict and informative than using lower_bound in the static part,
-          # as it amounts to assuming the worst case of using the statically present arrows.
-          arguments = Enum.map(arguments, &upper_bound/1)
-
-          {:ok,
-           union(
-             fun_apply_static(arguments, static_arrows),
-             dynamic(fun_apply_static(arguments, dynamic_arrows))
-           )}
+          true ->
+            # Mixed case: union of the static and dynamic results.
+            # static_arrows (lower materialization) contain only arrows that are
+            # guaranteed to exist at runtime. Static guarantees about the result
+            # come from these alone.
+            # dynamic_arrows (upper materialization) include dynamically uncertain
+            # arrows, so their result is wrapped in dynamic().
+            # We use upper_bound on the arguments for both branches. This is sound
+            # because the dynamic branch wraps its result in dynamic().
+            # It is more strict and informative than using lower_bound in the static part,
+            # as it amounts to assuming the worst case of using the statically present arrows.
+            arguments = Enum.map(arguments, &upper_bound/1)
+
+            {:ok,
+             union(
+               fun_apply_static(arguments, static_arrows),
+               dynamic(fun_apply_static(arguments, dynamic_arrows))
+             )}
+        end
       end
-    else
-      true -> {:badarg, arguments}
-      error -> error
     end
   end
 

lib/elixir/test/elixir/macro_test.exs

@@ -628,7 +628,7 @@ defmodule MacroTest do
 
     test "boolean expressions that raise" do
       falsy = length([]) != 0
-      x = 0
+      x = Process.get(:unused, 0)
 
       {result, formatted} = dbg_format_no_newline((falsy || x) && 1 / x)
 

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

@@ -1103,26 +1103,26 @@ defmodule Module.Types.DescrTest do
 
     test "static" do
       # Full static
-      assert fun_apply(fun(), [integer()]) == {:badarg, [none()]}
-      assert fun_apply(difference(fun(), none_fun(2)), [integer()]) == {:badarg, [none()]}
+      assert fun_apply(fun(), [integer()]) == {:badarg, [none()], false}
+      assert fun_apply(difference(fun(), none_fun(2)), [integer()]) == {:badarg, [none()], false}
 
       # Basic function application scenarios
       assert fun_apply(fun([integer()], atom()), [integer()]) == {:ok, atom()}
-      assert fun_apply(fun([integer()], atom()), [float()]) == {:badarg, [integer()]}
-      assert fun_apply(fun([integer()], atom()), [term()]) == {:badarg, [integer()]}
+      assert fun_apply(fun([integer()], atom()), [float()]) == {:badarg, [integer()], false}
+      assert fun_apply(fun([integer()], atom()), [term()]) == {:badarg, [integer()], false}
 
       # Union argument type: domain is int | float
       assert fun_apply(fun([union(integer(), float())], atom()), [integer()]) == {:ok, atom()}
       assert fun_apply(fun([union(integer(), float())], atom()), [float()]) == {:ok, atom()}
 
       assert fun_apply(fun([union(integer(), float())], atom()), [atom()]) ==
-               {:badarg, [union(integer(), float())]}
+               {:badarg, [union(integer(), float())], false}
 
       # 2-arity function
       assert fun_apply(fun([integer(), atom()], binary()), [integer(), atom()]) == {:ok, binary()}
 
       assert fun_apply(fun([integer(), atom()], binary()), [boolean(), atom()]) ==
-               {:badarg, [integer(), atom()]}
+               {:badarg, [integer(), atom()], false}
 
       # Return types
       assert fun_apply(fun([integer()], none()), [integer()]) == {:ok, none()}
@@ -1135,7 +1135,9 @@ defmodule Module.Types.DescrTest do
              |> elem(1)
              |> equal?(atom())
 
-      assert fun_apply(fun([integer()], atom()), [dynamic(float())]) == {:badarg, [integer()]}
+      assert fun_apply(fun([integer()], atom()), [dynamic(float())]) ==
+               {:badarg, [integer()], false}
+
       assert fun_apply(fun([integer()], atom()), [dynamic(term())]) == {:ok, dynamic()}
 
       # Arity mismatches
@@ -1198,7 +1200,7 @@ defmodule Module.Types.DescrTest do
       assert fun_apply(fun, [dynamic(integer())]) == {:ok, union(atom(), dynamic())}
       assert fun_apply(fun, [dynamic(number())]) == {:ok, dynamic()}
       assert fun_apply(fun, [integer()]) == {:ok, dynamic()}
-      assert fun_apply(fun, [float()]) == {:badarg, [dynamic(integer())]}
+      assert fun_apply(fun, [float()]) == {:badarg, [dynamic(integer())], false}
     end
 
     defp dynamic_fun(args, return), do: dynamic(fun(args, return))
@@ -1214,7 +1216,10 @@ defmodule Module.Types.DescrTest do
       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()], integer())), [none()]) == {:badarg, [none()]}
+
+      assert fun_apply(dynamic(fun([integer()], integer())), [none()]) ==
+               {:badarg, [none()], true}
+
       assert fun_apply(dynamic_fun([integer()], term()), [integer()]) == {:ok, dynamic()}
 
       # Dynamic return and dynamic args
@@ -1330,15 +1335,17 @@ defmodule Module.Types.DescrTest do
         )
 
       assert fun_args |> fun_apply([atom()]) == {:ok, dynamic()}
-      assert fun_args |> fun_apply([integer()]) == {:badarg, [dynamic(atom())]}
+      assert fun_args |> fun_apply([integer()]) == {:badarg, [dynamic(atom())], false}
 
       # ((bool->bool) or dyn(int->int))
       # booleans work, but not integers
       fun_mixed_gdom = union(fun([boolean()], boolean()), dynamic_fun([integer()], integer()))
       assert fun_apply(fun_mixed_gdom, [boolean()]) == {:ok, dynamic()}
       assert fun_apply(fun_mixed_gdom, [dynamic(boolean())]) == {:ok, union(dynamic(), boolean())}
-      assert fun_apply(fun_mixed_gdom, [integer()]) == {:badarg, [dynamic(boolean())]}
-      assert fun_apply(fun_mixed_gdom, [dynamic(integer())]) == {:badarg, [dynamic(boolean())]}
+      assert fun_apply(fun_mixed_gdom, [integer()]) == {:badarg, [dynamic(boolean())], false}
+
+      assert fun_apply(fun_mixed_gdom, [dynamic(integer())]) ==
+               {:badarg, [dynamic(boolean())], false}
 
       # Badfun
       assert union(
@@ -2280,24 +2287,15 @@ defmodule Module.Types.DescrTest do
       # This is a test of the map_update_fun/5 with forced?: false parameter.
       # We check that it does not call its typed_fun argument with `none()`
       # due to the key being absent in the map.
-
       type = dynamic(difference(open_map(), empty_map()))
-      ref = make_ref()
 
       fun = fn _optional?, value ->
-        send(self(), {ref, value})
+        send(self(), :callback_invoked)
         value
       end
 
-      _ = map_update_fun(type, binary(), fun, false, false)
-
-      messages = Process.info(self(), :messages) |> elem(1)
-
-      # Check that the callback was not invoked with `none()`
-      refute Enum.any?(messages, fn
-               {seen_ref, value} when seen_ref == ref -> empty?(value)
-               _ -> false
-             end)
+      assert map_update_fun(type, binary(), fun, false, false) == {dynamic(none()), type, []}
+      refute_received :callback_invoked
     end
 
     test "with dynamic atom keys" do