Fix issue with expression patterns in switch exhaustivity checking (#23804)

Expression patterns (and cast patterns) don't actually contribute to
the exhaustivity of a switch statement---if you're matching against a
String, matching "abc" doesn't meaningfully reduce the full space of
the values you have to match. This was already handled, but didn't do
the right thing in a particular case involving a tuple payload in an
enum after the Space Engine (exhaustivity checker) optimizations that
went out in Swift 5.

https://bugs.swift.org/browse/SR-10301

Author: jrose-apple

lib/Sema/TypeCheckSwitchStmt.cpp

@@ -1380,6 +1380,7 @@ namespace {
         }
       }
       case PatternKind::Typed:
+        llvm_unreachable("cannot appear in case patterns");
       case PatternKind::Expr:
         return Space();
       case PatternKind::Var: {
@@ -1428,6 +1429,8 @@ namespace {
                                        conArgSpace);
         }
         case PatternKind::Paren: {
+          // If we've got an extra level of parens, we need to flatten that into
+          // the enum payload.
           auto *PP = dyn_cast<ParenPattern>(SP);
           auto *SP = PP->getSemanticsProvidingPattern();
 
@@ -1448,6 +1451,12 @@ namespace {
             }
           } else if (SP->getKind() == PatternKind::Tuple) {
             Space argTupleSpace = projectPattern(TC, SP);
+            // Tuples are modeled as if they are enums with a single, nameless
+            // case, which means argTupleSpace will either be a Constructor or
+            // Empty space. If it's empty (i.e. it contributes nothing to the
+            // overall exhaustiveness), the entire enum case space is empty.
+            if (argTupleSpace.isEmpty())
+              return Space();
             assert(argTupleSpace.getKind() == SpaceKind::Constructor);
             conArgSpace.insert(conArgSpace.end(),
                                argTupleSpace.getSpaces().begin(),

test/Compatibility/exhaustive_switch.swift

@@ -1176,3 +1176,43 @@ extension Result where T == NoError {
     }
   }
 }
+
+enum SR10301<T,E> {
+  case value(T)
+  case error(E)
+}
+enum SR10301Error: Error {
+  case bad
+}
+
+func sr10301(_ foo: SR10301<String,(Int,Error)>) {
+  switch foo {
+  case .value: return
+  case .error((_, SR10301Error.bad)): return
+  case .error((_, let err)):
+    _ = err
+    return
+  }
+}
+
+func sr10301_is(_ foo: SR10301<String,(Int,Error)>) {
+  switch foo {
+  case .value: return
+  case .error((_, is SR10301Error)): return
+  case .error((_, let err)):
+    _ = err
+    return
+  }
+}
+
+func sr10301_as(_ foo: SR10301<String,(Int,Error)>) {
+  switch foo {
+  case .value: return
+  case .error((_, let err as SR10301Error)):
+    _ = err
+    return
+  case .error((_, let err)):
+    _ = err
+    return
+  }
+}

test/Sema/exhaustive_switch.swift

@@ -1135,3 +1135,43 @@ extension Result where T == NoError {
     }
   }
 }
+
+enum SR10301<T,E> {
+  case value(T)
+  case error(E)
+}
+enum SR10301Error: Error {
+  case bad
+}
+
+func sr10301(_ foo: SR10301<String,(Int,Error)>) {
+  switch foo {
+  case .value: return
+  case .error((_, SR10301Error.bad)): return
+  case .error((_, let err)):
+    _ = err
+    return
+  }
+}
+
+func sr10301_is(_ foo: SR10301<String,(Int,Error)>) {
+  switch foo {
+  case .value: return
+  case .error((_, is SR10301Error)): return
+  case .error((_, let err)):
+    _ = err
+    return
+  }
+}
+
+func sr10301_as(_ foo: SR10301<String,(Int,Error)>) {
+  switch foo {
+  case .value: return
+  case .error((_, let err as SR10301Error)):
+    _ = err
+    return
+  case .error((_, let err)):
+    _ = err
+    return
+  }
+}