Avoid nested differences

Author: josevalim

lib/elixir/lib/module/types/apply.ex

@@ -1486,9 +1486,9 @@ defmodule Module.Types.Apply do
     domain(domain, clauses)
   end
 
-  defp filter_domain({_type, domain, clauses}, expected, arity) do
+  defp filter_domain({_type, domain, clauses}, expected, _arity) do
     case filter_domain(clauses, expected, [], true) do
-      :none -> List.duplicate(term(), arity)
+      :none -> domain(domain, clauses)
       :all -> domain(domain, clauses)
       args -> Enum.zip_with(args, fn types -> Enum.reduce(types, &union/2) end)
     end

lib/elixir/lib/module/types/of.ex

@@ -105,31 +105,62 @@ defmodule Module.Types.Of do
           context
       end
 
-    if gradual?(old_type) and type not in [term(), dynamic()] and not is_map_key(data, :errored) do
-      case compatible_intersection(old_type, type) do
-        {:error, _} when allow_empty? ->
-          data = %{
-            data
-            | type: none(),
-              off_traces: new_trace(expr, none(), stack, off_traces)
-          }
-
-          {none(), %{context | vars: %{vars | version => data}}}
-
-        {:ok, new_type} when new_type != old_type ->
-          data = %{
-            data
-            | type: new_type,
-              off_traces: new_trace(expr, new_type, stack, off_traces)
-          }
-
-          {new_type, %{context | vars: %{vars | version => data}}}
-
-        _ ->
-          {old_type, context}
+    if match?(%{pattern_info: %{allow_empty?: _}}, context) do
+      if type not in [term(), dynamic()] and not is_map_key(data, :errored) do
+        new_type = intersection(old_type, type)
+
+        case empty?(new_type) do
+          true when allow_empty? ->
+            data = %{
+              data
+              | type: none(),
+                off_traces: new_trace(expr, none(), stack, off_traces)
+            }
+
+            {none(), %{context | vars: %{vars | version => data}}}
+
+          false when new_type != old_type ->
+            data = %{
+              data
+              | type: new_type,
+                off_traces: new_trace(expr, new_type, stack, off_traces)
+            }
+
+            {new_type, %{context | vars: %{vars | version => data}}}
+
+          _ ->
+            {old_type, context}
+        end
+      else
+        {old_type, context}
       end
     else
-      {old_type, context}
+      if gradual?(old_type) and type not in [term(), dynamic()] and not is_map_key(data, :errored) do
+        case compatible_intersection(old_type, type) do
+          {:error, _} when allow_empty? ->
+            data = %{
+              data
+              | type: none(),
+                off_traces: new_trace(expr, none(), stack, off_traces)
+            }
+
+            {none(), %{context | vars: %{vars | version => data}}}
+
+          {:ok, new_type} when new_type != old_type ->
+            data = %{
+              data
+              | type: new_type,
+                off_traces: new_trace(expr, new_type, stack, off_traces)
+            }
+
+            {new_type, %{context | vars: %{vars | version => data}}}
+
+          _ ->
+            {old_type, context}
+        end
+      else
+        {old_type, context}
+      end
     end
   end