Short circuit subspace check with empty subjects

When determining whether one constructor pattern is a subspace of
another, we only checked if the right-hand subspace was larger than the
left.  If the left is larger than the right then we can short-circuit
the comparison once more because it cannot be a subspace.

This also takes care of refutable casts in patterns tripping the
duplicate case warning.

Author: CodaFi

lib/Sema/TypeCheckSwitchStmt.cpp

@@ -251,10 +251,25 @@ namespace {
 
           // Special Case: A constructor pattern may include the head but not
           // the payload patterns.  In that case the space is covered.
+          // This also acts to short-circuit comparisons with payload-less
+          // constructors.
           if (other.getSpaces().empty()) {
             return true;
           }
 
+          // If 'this' constructor pattern has no payload and the other space
+          // does, then 'this' covers more of the space only if the other
+          // constructor isn't the explicit form.
+          //
+          // .case <= .case(_, _, _, ...)
+          if (this->getSpaces().empty()) {
+            return std::accumulate(other.getSpaces().begin(),
+                                   other.getSpaces().end(),
+                                   true, [](bool acc, const Space sp){
+              return acc && sp.getKind() == SpaceKind::Type;
+            });
+          }
+
           // H(a1, ..., an) <= H(b1, ..., bn) iff a1 <= b1 && ... && an <= bn
           auto i = this->getSpaces().begin();
           auto j = other.getSpaces().begin();

test/Sema/exhaustive_switch.swift

@@ -1,4 +1,5 @@
 // RUN: %target-typecheck-verify-swift
+
 func foo(a: Int?, b: Int?) -> Int {
   switch (a, b) {
   case (.none, _): return 1
@@ -286,3 +287,25 @@ func switcheroo(a: XX, b: XX) -> Int {
     return 13
   }
 }
+
+enum PatternCasts {
+  case one(Any)
+  case two
+}
+
+func checkPatternCasts() {
+  // Pattern casts with this structure shouldn't warn about duplicate cases.
+  let x: PatternCasts = .one("One")
+  switch x {
+  case .one(let s as String): print(s)
+  case .one: break
+  case .two: break
+  }
+
+  // But should warn here.
+  switch x {
+  case .one(_): print(s)
+  case .one: break // expected-warning {{case is already handled by previous patterns; consider removing it}}
+  case .two: break
+  }
+}