Tackle empty intersections in map fetch key

Author: josevalim

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

@@ -3266,7 +3266,8 @@ defmodule Module.Types.Descr do
   catch
     :open -> {true, term()}
   else
-    value -> pop_optional_static(value)
+    value ->
+      pop_optional_static(value)
   end
 
   defp map_split_negative_key(negs, key, value, bdd) do
@@ -3290,7 +3291,7 @@ defmodule Module.Types.Descr do
 
         if not found? and neg_tag == :open do
           # In case the map is open, t \ t₁ is always empty,
-          # so we just need to deal with the bdd.
+          # t ∩ t₁ is always t, so we just need to deal with the bdd.
           Enum.reduce(acc, [], fn {value, bdd}, acc ->
             diff_bdd = map_difference(bdd, neg_bdd)
 
@@ -3307,17 +3308,19 @@ defmodule Module.Types.Descr do
             if neg_tag == :closed and map_empty?(map_intersection(bdd, neg_bdd)) do
               [{value, bdd} | acc]
             else
-              diff_bdd = map_difference(bdd, neg_bdd)
+              intersection_value = intersection(value, neg_value)
 
-              cond do
-                value == neg_value or subtype?(value, neg_value) ->
-                  if map_empty?(diff_bdd), do: acc, else: [{value, diff_bdd} | acc]
+              if empty?(intersection_value) do
+                [{value, bdd} | acc]
+              else
+                diff_bdd = map_difference(bdd, neg_bdd)
 
-                map_empty?(diff_bdd) ->
+                if map_empty?(diff_bdd) do
                   prepend_pair_unless_empty_diff(value, neg_value, bdd, acc)
-
-                true ->
-                  prepend_pair_unless_empty_diff(value, neg_value, bdd, [{value, diff_bdd} | acc])
+                else
+                  acc = [{intersection_value, diff_bdd} | acc]
+                  prepend_pair_unless_empty_diff(value, neg_value, bdd, acc)
+                end
               end
             end
           end)

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

@@ -928,7 +928,62 @@ defmodule Module.Types.IntegrationTest do
       assert_no_warnings(files)
     end
 
-    test "unions and intersections of open maps" do
+    test "redundant clause checking of mixed open and closed maps" do
+      files = %{
+        "mixed_open_closed_maps.ex" => """
+        defmodule MixedOpenClosedMaps do
+          defmodule S1, do: defstruct([:name])
+          defmodule S2, do: defstruct([:name])
+          defmodule S3, do: defstruct([:name])
+          defmodule S4, do: defstruct([:name])
+          defmodule S5, do: defstruct([:name])
+          defmodule S6, do: defstruct([:name])
+          defmodule S7, do: defstruct([:name])
+          defmodule S8, do: defstruct([:name])
+          defmodule S9, do: defstruct([:name])
+          defmodule S10, do: defstruct([:name])
+          defmodule S11, do: defstruct([:name])
+          defmodule S12, do: defstruct([:name])
+          defmodule S13, do: defstruct([:name])
+          defmodule S14, do: defstruct([:name])
+          defmodule S15, do: defstruct([:name])
+          defmodule S16, do: defstruct([:name])
+          defmodule S17, do: defstruct([:name])
+          defmodule S18, do: defstruct([:name])
+
+          defmodule SValue do
+            defstruct [:value]
+          end
+
+          def render(%S1{}), do: :ok
+          def render(%S2{}), do: :ok
+          def render(%S3{}), do: :ok
+          def render(%S4{}), do: :ok
+          def render(%S5{}), do: :ok
+          def render(%S6{}), do: :ok
+          def render(%S7{}), do: :ok
+          def render(%S8{}), do: :ok
+          def render(%S9{}), do: :ok
+          def render(%S10{}), do: :ok
+          def render(%S11{}), do: :ok
+          def render(%S12{}), do: :ok
+          def render(%S13{}), do: :ok
+          def render(%S14{}), do: :ok
+          def render(%S15{}), do: :ok
+          def render(%S16{}), do: :ok
+          def render(%S17{}), do: :ok
+          def render(%S18{}), do: :ok
+          # Having the closed map and the struct overlap on a key is important
+          def render(%SValue{}), do: :ok
+          def render(%{value: value}), do: value
+        end
+        """
+      }
+
+      assert_no_warnings(files)
+    end
+
+    test "redundant clause checking of open maps with distinct keys" do
       files = %{
         "large_head.ex" => """
         defmodule LargeHead do