[Sema] SpaceEngine: Improve handling of empty/non-reduced spaces in construtors/disjuncts

Eagerly remove empty (sub-)spaces from constructors and disjuncts
to minimize number of operations required to check space coverage.
Also return original constructor space while subtracting a pair of
constructors, instead of disjunct, if subtraction of one of its
sub-spaces produced the same space, this reduces the number of
disjuncts in the path.

Resolves: rdar://problem/39710335

Author: xedin

lib/Sema/TypeCheckSwitchStmt.cpp

@@ -231,11 +231,18 @@ namespace {
         return Space(C);
       }
       static Space forDisjunct(ArrayRef<Space> SP) {
-        if (SP.empty())
+        SmallVector<Space, 4> spaces(SP.begin(), SP.end());
+        spaces.erase(
+            std::remove_if(spaces.begin(), spaces.end(),
+                           [](const Space &space) { return space.isEmpty(); }),
+            spaces.end());
+
+        if (spaces.empty())
           return Space();
-        if (SP.size() == 1)
-          return SP.front();
-        return Space(SP);
+        if (spaces.size() == 1)
+          return spaces.front();
+
+        return Space(spaces);
       }
 
       bool operator==(const Space &other) const {
@@ -805,7 +812,23 @@ namespace {
             // into each parameter.
             SmallVector<Space, 4> copyParams(this->getSpaces().begin(),
                                              this->getSpaces().end());
-            copyParams[idx] = s1.minus(s2, TC, DC);
+
+            auto reducedSpace = s1.minus(s2, TC, DC);
+            // If one of the constructor parameters is empty it means
+            // the whole constructor space is empty as well, so we can
+            // safely skip it.
+            if (reducedSpace.isEmpty())
+              continue;
+
+            // If reduced produced the same space as original one, we
+            // should return it directly instead of trying to create
+            // a disjunction of its sub-spaces because nothing got reduced.
+            // This is especially helpful when dealing with `unknown` case
+            // in parameter positions.
+            if (s1 == reducedSpace)
+              return *this;
+
+            copyParams[idx] = reducedSpace;
             Space CS = Space::forConstructor(this->getType(), this->getHead(),
                                              this->canDowngradeToWarning(),
                                              copyParams);

test/Sema/rdar39710335.swift

@@ -0,0 +1,61 @@
+// RUN: %target-typecheck-verify-swift
+
+enum E1 {
+  case a1
+  case b1
+  case c1
+  case d1
+  case e1
+  case f1
+}
+
+enum E2 {
+  case a2, b2, c2, d2
+}
+
+func foo(s: E1, style: E2) {
+  switch (s, style) {
+    case (.a1, .a2),
+         (.a1, .d2),
+         (.c1, .a2),
+         (.c1, .d2),
+         (.c1, .c2),
+         (.a1, .c2):
+      break
+
+    case (.a1, .b2),
+         (.b1, .b2),
+         (.c1, .b2):
+        break
+
+    case (.b1, .a2),
+         (.b1, .d2),
+         (.b1, .c2):
+      break
+
+    case (.e1, .a2),
+         (.e1, .d2),
+         (.e1, .c2):
+      break
+
+    case (.e1, .b2):
+        break
+
+    case (.d1, .a2),
+         (.d1, .d2):
+
+      break
+
+    case (.d1, .b2):
+      break
+
+    case (.d1, .c2):
+      break
+
+    case (.f1, .a2),
+         (.f1, .b2),
+         (.f1, .c2),
+         (.f1, .d2):
+      break
+  }
+}