Revert previous strategy to use multiple differences

Author: josevalim

lib/elixir/lib/module/types/pattern.ex

@@ -12,39 +12,44 @@ defmodule Module.Types.Pattern do
   Returns the initial value for previous clause information.
   """
   def init_previous do
-    {[], none()}
+    []
   end
 
-  defp empty_previous?({list, _descr}), do: list == []
+  defp empty_previous?([]), do: true
+  defp empty_previous?([_ | _]), do: false
 
-  defp previous_subtype?(_, {[], _}), do: false
+  defp previous_subtype?(_, []), do: false
   defp previous_subtype?([], _), do: true
-  defp previous_subtype?([type], {_, descr}), do: subtype?(type, descr)
-  defp previous_subtype?(args, {_, descr}), do: subtype?(args_to_domain(args), descr)
+
+  defp previous_subtype?([type], previous),
+    do: subtype?(type, Enum.reduce(previous, none(), &union(&2, hd(&1))))
+
+  defp previous_subtype?(args, previous) do
+    subtype?(
+      args_to_domain(args),
+      Enum.reduce(previous, none(), &union(&2, args_to_domain(&1)))
+    )
+  end
 
   defp concat_previous([], previous),
     do: previous
 
-  defp concat_previous([type], {list, descr}),
-    do: {[[type] | list], union(type, descr)}
-
-  defp concat_previous(types, {list, descr}),
-    do: {[types | list], union(args_to_domain(types), descr)}
+  defp concat_previous(types, previous),
+    do: [types | previous]
 
-  defp of_pattern_previous(types, {[], _}, _trees, _pattern_info, _tag, _stack, _context) do
+  defp of_pattern_previous(types, [], _trees, _pattern_info, _tag, _stack, _context) do
     {:ok, types}
   end
 
-  defp of_pattern_previous(types, {_, descr}, trees, pattern_info, tag, stack, context) do
+  defp of_pattern_previous(types, previous, trees, pattern_info, tag, stack, context) do
     types =
       case types do
         [type] ->
-          [difference(type, descr)]
+          [Enum.reduce(previous, type, &difference(&2, hd(&1)))]
 
         [_ | _] ->
-          types
-          |> args_to_domain()
-          |> difference(descr)
+          previous
+          |> Enum.reduce(args_to_domain(types), &difference(&2, args_to_domain(&1)))
           |> domain_to_flat_args(types)
       end
 
@@ -57,7 +62,7 @@ defmodule Module.Types.Pattern do
     end
   end
 
-  defp previous_to_string({previous, _}) do
+  defp previous_to_string(previous) do
     Enum.map_join(previous, "\n    ", fn types ->
       types
       |> Enum.map_join(", ", &to_quoted_string/1)

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

@@ -887,6 +887,47 @@ defmodule Module.Types.IntegrationTest do
       assert_no_warnings(files)
     end
 
+    test "redundant clause checking with nested open maps" do
+      files = %{
+        "nested_maps.ex" => """
+        defmodule NestedMapsIssue do
+          def foo(%{a: nil, b: %{c: true}}), do: :ok
+          def foo(%{a: nil, b: %{c: false}}), do: :ok
+          def foo(%{a: nil, b: %{d: x}}) when is_list(x), do: :ok
+          def foo(%{a: nil, b: %{e: x}}) when is_list(x), do: :ok
+          def foo(%{a: nil, b: %{f: x}}) when is_list(x), do: :ok
+          def foo(%{a: nil}), do: :ok
+          def foo(%{b: %{g: :one, h: x}}) when is_map(x), do: :ok
+          def foo(%{b: %{g: _, i: x}}) when is_list(x), do: :ok
+          def foo(%{b: %{g: _, j: x}}) when is_list(x), do: :ok
+          def foo(%{b: %{g: _, k: x}}) when is_list(x), do: :ok
+          def foo(%{b: %{g: :one}}), do: :ok
+          def foo(%{b: %{g: :two}}), do: :ok
+          def foo(%{b: %{g: :three}}), do: :ok
+          def foo(%{b: %{g: :four}}), do: :ok
+          def foo(%{b: %{g: :five}}), do: :ok
+          def foo(%{b: %{g: :six}}), do: :ok
+          def foo(%{b: %{l: x}}) when is_list(x), do: :ok
+          def foo(%{b: %{m: x}}) when is_list(x), do: :ok
+          def foo(%{b: %{n: x}}) when is_list(x), do: :ok
+          def foo(%{b: %{o: x}}) when is_list(x), do: :ok
+          def foo(%{b: %{p: x, q: y}}) when is_number(x) and is_number(y), do: :ok
+          def foo(%{b: %{p: x}}) when is_number(x), do: :ok
+          def foo(%{b: %{q: x}}) when is_number(x), do: :ok
+          def foo(%{b: %{r: x}}) when is_integer(x), do: :ok
+          def foo(%{b: %{s: x}}) when is_integer(x), do: :ok
+          def foo(%{b: %{t: x}}) when is_binary(x), do: :ok
+          def foo(%{b: %{u: x}}) when is_atom(x), do: :ok
+          def foo(%{b: %{v: x}}) when is_integer(x), do: :ok
+          def foo(%{b: %{w: x}}) when is_integer(x), do: :ok
+          def foo(_), do: :ok
+        end
+        """
+      }
+
+      assert_no_warnings(files)
+    end
+
     test "unions and intersections of open maps" do
       files = %{
         "large_head.ex" => """

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

@@ -156,10 +156,10 @@ defmodule TypeHelper do
     previous = Pattern.init_previous()
     tag = {:fn, patterns}
 
-    {_trees, {previous, _}, _context} =
+    {_trees, previous, _context} =
       Pattern.of_head(patterns, guards, expected, previous, tag, [], stack, new_context())
 
-    previous != []
+    not match?([], previous)
   end
 
   def __typecheck__(mode, patterns, guards, body) do