Also optimize different between structs

Author: josevalim

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

@@ -2754,13 +2754,29 @@ defmodule Module.Types.Descr do
           bdd_leaf(tag, Map.replace!(fields, diff_key, difference(type1, type2)))
 
         _ ->
-          bdd_difference(map1, map2, &map_leaf_intersection/2, nil)
+          bdd_difference(map1, map2, &map_leaf_intersection/2, &map_leaf_disjoint?/2)
       end
     end
   end
 
   defp map_difference(bdd1, bdd2),
-    do: bdd_difference(bdd1, bdd2, &map_leaf_intersection/2, nil)
+    do: bdd_difference(bdd1, bdd2, &map_leaf_intersection/2, &map_leaf_disjoint?/2)
+
+  defp map_leaf_disjoint?(bdd_leaf(_tag1, fields1), bdd_leaf(_tag2, fields2)) do
+    disjoint_structs?(fields1, fields2)
+  end
+
+  defp disjoint_structs?(%{__struct__: %{atom: atom} = d1}, %{__struct__: d2})
+       when map_size(d1) == 1 do
+    disjoint_atom_descr?(atom, d2)
+  end
+
+  defp disjoint_structs?(%{__struct__: d1}, %{__struct__: %{atom: atom} = d2})
+       when map_size(d2) == 1 do
+    disjoint_atom_descr?(atom, d1)
+  end
+
+  defp disjoint_structs?(_, _), do: false
 
   # Intersects two map literals; throws if their intersection is empty.
   # Both open: the result is open.
@@ -4301,16 +4317,16 @@ defmodule Module.Types.Descr do
 
   # A very cheap check for tagged tuples
   defp disjoint_tagged_tuples?([%{atom: atom} = d1 | _], [d2 | _]) when map_size(d1) == 1,
-    do: disjoint_tagged_atom?(atom, d2)
+    do: disjoint_atom_descr?(atom, d2)
 
   defp disjoint_tagged_tuples?([d1 | _], [%{atom: atom} = d2 | _]) when map_size(d2) == 1,
-    do: disjoint_tagged_atom?(atom, d1)
+    do: disjoint_atom_descr?(atom, d1)
 
   defp disjoint_tagged_tuples?(_, _), do: false
 
-  defp disjoint_tagged_atom?(_atom, :term), do: false
-  defp disjoint_tagged_atom?(atom1, %{atom: atom2}), do: atom_intersection(atom1, atom2) === 0
-  defp disjoint_tagged_atom?(_atom, %{}), do: true
+  defp disjoint_atom_descr?(_atom, :term), do: false
+  defp disjoint_atom_descr?(atom1, %{atom: atom2}), do: atom_intersection(atom1, atom2) === 0
+  defp disjoint_atom_descr?(_atom, %{}), do: true
 
   defp non_empty_tuple_literals_intersection(tuples) do
     try do

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

@@ -568,6 +568,30 @@ defmodule Module.Types.DescrTest do
              |> equal?(open_map(a: integer()))
     end
 
+    test "map (struct optimizations)" do
+      # We do direct assertions because we want to check how it works underneath
+      atom_foo = atom([:foo])
+      atom_bar = atom([:bar])
+
+      assert difference(open_map(__struct__: atom_foo), open_map(__struct__: atom_bar)) ==
+               open_map(__struct__: atom_foo)
+
+      assert difference(closed_map(__struct__: atom_foo), open_map(__struct__: atom_bar)) ==
+               closed_map(__struct__: atom_foo)
+
+      assert difference(open_map(__struct__: atom_foo), closed_map(__struct__: atom_bar)) ==
+               open_map(__struct__: atom_foo)
+
+      assert difference(closed_map(__struct__: atom_foo), closed_map(__struct__: atom_bar)) ==
+               closed_map(__struct__: atom_foo)
+
+      refute difference(closed_map(__struct__: atom_foo), closed_map(__struct__: term())) ==
+               closed_map(__struct__: atom_foo)
+
+      refute difference(closed_map(__struct__: atom()), closed_map(__struct__: atom_bar)) ==
+               closed_map(__struct__: atom())
+    end
+
     test "map with domain keys" do
       # Non-overlapping domain keys
       t1 = closed_map([{domain_key(:integer), atom()}])