Stricter enforcement of the "large space" heuristic

The Space Engine includes a heuristic that attempted a combinatorics-
based check to see if a pattern covered an insufficient amount of cases.
In straight-line switches this avoided computing a subspace match that
would have been quite expensive computationally.  However, when
expressive patterns (like tuple patterns) are used, it can fool the
check because the covered space is much larger than the actual size of
the space due to pattern overlap that counting like this simply can't detect.

Instead, just do the right thing and perform a space subtraction after
the existing preconditions for the heuristic are satisfied.

Resolves SR-6316

Author: CodaFi

lib/Sema/TypeCheckSwitchStmt.cpp

@@ -1063,23 +1063,25 @@ namespace {
 
       Space totalSpace(subjectType, Identifier());
       Space coveredSpace(spaces);
+
       size_t totalSpaceSize = totalSpace.getSize(TC);
       if (totalSpaceSize > Space::getMaximumSize()) {
-        // Because the space is large, we have to extend the size
-        // heuristic to compensate for actually exhaustively pattern matching
-        // over enormous spaces.  In this case, if the covered space covers
-        // as much as the total space, and there were no duplicates, then we
-        // can assume the user did the right thing and that they don't need
-        // a 'default' to be inserted.
+        // Because the space is large, fall back to a heuristic that rejects
+        // the common case of providing an insufficient number of covering
+        // patterns.  We still need to fall back to space subtraction if the
+        // covered space is larger than the total space because there is
+        // necessarily overlap in the pattern matrix that can't be detected
+        // by combinatorics alone.
         if (!sawRedundantPattern
-            && coveredSpace.getSize(TC) >= totalSpaceSize) {
+            && coveredSpace.getSize(TC) >= totalSpaceSize
+            && totalSpace.minus(coveredSpace, TC).simplify(TC).isEmpty()) {
           return;
         }
 
         diagnoseMissingCases(TC, Switch, /*justNeedsDefault*/true, Space());
         return;
       }
-      
+
       auto uncovered = totalSpace.minus(coveredSpace, TC).simplify(TC);
       if (uncovered.isEmpty()) {
         return;

test/Sema/exhaustive_switch.swift

@@ -559,6 +559,28 @@ func infinitelySized() -> Bool {
   }
 }
 
+// SR-6316: Size heuristic is insufficient to catch space covering when the
+// covered space size is greater than or equal to the master space size.
+func largeSpaceMatch(_ x: Bool) {
+  switch (x, (x, x, x, x), (x, x, x, x)) { // expected-error {{switch must be exhaustive}}
+  // expected-note@-1 {{do you want to add a default clause?}}
+  case (true, (_, _, _, _), (_, true, true, _)):
+    break
+  case (true, (_, _, _, _), (_, _, false, _)):
+    break
+  case (_, (_, true, true, _), (_, _, false, _)):
+    break
+  case (_, (_, _, false, _), (_, true, true, _)):
+    break
+  case (_, (_, true, true, _), (_, true, true, _)):
+    break
+  case (_, (_, _, false, _), (_, _, false, _)):
+    break
+  case (_, (false, false, false, false), (_, _, _, _)):
+    break
+  }
+}
+
 func diagnoseDuplicateLiterals() {
   let str = "def"
   let int = 2