Fix optimized map difference with open key

Closes #15507.
Closes #15508.

Author: josevalim

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

@@ -6390,7 +6390,30 @@ defmodule Module.Types.Descr do
   defp opt_map_difference(bdd1, bdd2),
     do: bdd_difference(bdd1, bdd2, &opt_map_leaf_difference/3)
 
-  defp opt_map_leaf_difference(bdd_leaf(tag, fields), bdd_leaf(:open, [{key, v2}]), type) do
+  # This clause optimizes differences with an open single-key right side:
+  #
+  #     %{b: atom(), c: pid()} \ %{..., c: if_set(pid() | binary())}
+  #
+  # Depending on the surrounding BDD shape, the difference formulas ask the
+  # leaf comparison for a direct difference plus an optional intersection
+  # or optional union.
+  #
+  # Because the right-hand side is an open map with a single key, this branch
+  # assumes the result can be represented by updating the matching key
+  # on the left-hand side. For this pair, the direct difference is empty and
+  # the intersection is `%{b: atom(), c: pid()}`, which are both correct.
+  #
+  # However, when the formula needs the union, this shortcut would produce
+  # `%{b: atom(), c: if_set(pid() or binary())}` by preserving the left shape.
+  # This is not the semantic union, because the right side also includes maps
+  # without `:b`. In other words, we cannot always union them by updating only
+  # the matching key.
+  #
+  # Therefore, this clause is only used when `type` is `:intersection` or `:none`.
+  # `:union` falls through to the general clause below. The reason we have
+  # this long comment is because this was a regression in the past.
+  defp opt_map_leaf_difference(bdd_leaf(tag, fields), bdd_leaf(:open, [{key, v2}]), type)
+       when type != :union do
     {found?, v1} =
       case fields_find(key, fields) do
         {:ok, value} -> {true, value}

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

@@ -728,6 +728,31 @@ defmodule Module.Types.DescrTest do
       assert opt_difference(closed_map(a: integer()), open_map(b: if_set(integer()))) == none()
     end
 
+    test "map difference of subtype" do
+      for {k1, k2} <- [{:a, :b}, {:b, :a}, {:b, :c}, {:c, :a}, {:c, :b}, {:b, :d}] do
+        a = closed_map([{k1, atom([:x, :y])}, {k2, pid()}])
+
+        b =
+          closed_map([
+            {k1, if_set(opt_union(atom([:y]), float()))},
+            {k2, opt_union(pid(), opt_union(binary(), integer()))}
+          ])
+
+        c = open_map([{k2, if_set(opt_union(pid(), binary()))}])
+
+        # a <= c, while b is unrelated to both a and c.
+        # Therefore (a \ b) <= a <= c and (a \ b) \ c is empty.
+        # The optimized difference should match the bare difference for this shape.
+        ab = opt_difference(a, b)
+
+        assert empty?(bare_difference(ab, c)),
+               "bare difference failed for keys #{inspect({k1, k2})}"
+
+        assert empty?(opt_difference(ab, c)),
+               "opt difference failed for keys #{inspect({k1, k2})}"
+      end
+    end
+
     test "map double negation with redundant empty map" do
       type =
         closed_map(a: atom())