Fix formatting of map-like types in warnings (#11351)

This came up in issue #11204:

When emitting a warning for a type unification error,
the compiler overly simplifies the formatting of types
when these are maps or unions of maps.

To address this, we recursively check for maps inside
of a union type when comparing it to another map-like type.

Author: gldubc

lib/elixir/lib/module/types.ex

@@ -354,7 +354,7 @@ defmodule Module.Types do
   end
 
   defp simplify_type?(type, other) do
-    map_type?(type) and not map_type?(other)
+    map_like_type?(type) and not map_like_type?(other)
   end
 
   ## EXPRESSION FORMATTING
@@ -505,6 +505,10 @@ defmodule Module.Types do
   defp map_type?({:map, _}), do: true
   defp map_type?(_other), do: false
 
+  defp map_like_type?({:map, _}), do: true
+  defp map_like_type?({:union, union}), do: Enum.any?(union, &map_like_type?/1)
+  defp map_like_type?(_other), do: false
+
   defp atom_type?(:atom), do: true
   defp atom_type?({:atom, _}), do: false
   defp atom_type?({:union, union}), do: Enum.all?(union, &atom_type?/1)

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

@@ -606,6 +606,41 @@ defmodule Module.Types.TypesTest do
                  %{foo: ^other_key} = event
              """
     end
+
+    test "expands map when maps are nested" do
+      string =
+        warning(
+          [map1, map2],
+          (
+            [_var1, _var2] = [map1, map2]
+            %{} = map1
+            %{} = map2.subkey
+          )
+        )
+
+      assert string == """
+             incompatible types:
+
+                 %{subkey: var1, optional(dynamic()) => dynamic()} !~ %{optional(dynamic()) => dynamic()} | %{optional(dynamic()) => dynamic()}
+
+             in expression:
+
+                 # types_test.ex:5
+                 map2.subkey
+
+             where "map2" was given the type %{optional(dynamic()) => dynamic()} | %{optional(dynamic()) => dynamic()} in:
+
+                 # types_test.ex:3
+                 [_var1, _var2] = [map1, map2]
+
+             where "map2" was given the type %{subkey: var1, optional(dynamic()) => dynamic()} (due to calling var.field) in:
+
+                 # types_test.ex:5
+                 map2.subkey
+
+             HINT: "var.field" (without parentheses) implies "var" is a map() while "var.fun()" (with parentheses) implies "var" is an atom()
+             """
+    end
   end
 
   describe "regressions" do