Limit exhaustivity checking when weird things happen with '@unknown'

If someone uses it twice, or on a non-final case, or tries to use it
with a multiple-pattern case, don't bother checking the exhaustiveness
of the switch. (For other violations, the pattern or where-clause is
ignored.)

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

Author: jrose-apple

lib/Sema/TypeCheckStmt.cpp

@@ -377,6 +377,7 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
 
   template<typename StmtTy>
   bool typeCheckStmt(StmtTy *&S) {
+    PrettyStackTraceStmt trace(TC.Context, "type-checking", S);
     StmtTy *S2 = cast_or_null<StmtTy>(visit(S));
     if (S2 == nullptr)
       return true;
@@ -821,7 +822,7 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
     // Type-check the subject expression.
     Expr *subjectExpr = S->getSubjectExpr();
     auto resultTy = TC.typeCheckExpression(subjectExpr, DC);
-    auto hadError = !resultTy;
+    auto limitExhaustivityChecks = !resultTy;
     if (Expr *newSubjectExpr = TC.coerceToRValue(subjectExpr))
       subjectExpr = newSubjectExpr;
     S->setSubjectExpr(subjectExpr);
@@ -856,7 +857,7 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
           // Coerce the pattern to the subject's type.
           if (!subjectType || TC.coercePatternToType(pattern, DC, subjectType,
                                      TypeResolutionFlags::InExpression)) {
-            hadError = true;
+            limitExhaustivityChecks = true;
 
             // If that failed, mark any variables binding pieces of the pattern
             // as invalid to silence follow-on errors.
@@ -907,7 +908,7 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
         }
         // Check the guard expression, if present.
         if (auto *guard = labelItem.getGuardExpr()) {
-          hadError |= TC.typeCheckCondition(guard, DC);
+          limitExhaustivityChecks |= TC.typeCheckCondition(guard, DC);
           labelItem.setGuardExpr(guard);
         }
       }
@@ -920,11 +921,13 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
           TC.diagnose(caseBlock->getLoc(),
                       diag::unknown_case_multiple_patterns)
             .highlight(caseBlock->getCaseLabelItems()[1].getSourceRange());
+          limitExhaustivityChecks = true;
         }
 
-        if (!caseBlock->isDefault() && FallthroughDest != nullptr) {
-          TC.diagnose(caseBlock->getLoc(),
-                      diag::unknown_case_must_be_last);
+        if (FallthroughDest != nullptr) {
+          if (!caseBlock->isDefault())
+            TC.diagnose(caseBlock->getLoc(), diag::unknown_case_must_be_last);
+          limitExhaustivityChecks = true;
         }
 
         const CaseLabelItem &labelItem = caseBlock->getCaseLabelItems().front();
@@ -981,13 +984,13 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
       // Type-check the body statements.
       PreviousFallthrough = nullptr;
       Stmt *body = caseBlock->getBody();
-      hadError |= typeCheckStmt(body);
+      limitExhaustivityChecks |= typeCheckStmt(body);
       caseBlock->setBody(body);
       previousBlock = caseBlock;
     }
 
     if (!S->isImplicit()) {
-      TC.checkSwitchExhaustiveness(S, DC, /*limitChecking*/hadError);
+      TC.checkSwitchExhaustiveness(S, DC, limitExhaustivityChecks);
     }
 
     return S;

lib/Sema/TypeCheckSwitchStmt.cpp

@@ -1216,7 +1216,7 @@ namespace {
       SmallVector<Space, 4> spaces;
       for (auto *caseBlock : Switch->getCases()) {
         if (caseBlock->hasUnknownAttr()) {
-          assert(unknownCase == nullptr);
+          assert(unknownCase == nullptr && "multiple unknown cases");
           unknownCase = caseBlock;
           continue;
         }

test/Parse/switch.swift

@@ -427,12 +427,12 @@ case .Thing: // expected-error{{additional 'case' blocks cannot appear after the
   break
 }
 
-switch Whatever.Thing { // expected-warning {{switch must be exhaustive}} expected-note{{add missing case: '.Thing'}}
+switch Whatever.Thing {
 @unknown case _, _: // expected-error {{'@unknown' cannot be applied to multiple patterns}}
   break
 }
 
-switch Whatever.Thing { // expected-warning {{switch must be exhaustive}} expected-note{{add missing case: '.Thing'}}
+switch Whatever.Thing {
 @unknown case _, _, _: // expected-error {{'@unknown' cannot be applied to multiple patterns}}
   break
 }
@@ -539,3 +539,73 @@ switch x { // expected-error {{switch must be exhaustive}}
 @unknown default: // expected-note {{remove '@unknown' to handle remaining values}} {{1-10=}}
   break
 }
+
+switch Whatever.Thing {
+case .Thing:
+  break
+@unknown case _: // expected-error {{'@unknown' can only be applied to the last case in a switch}}
+  break
+@unknown case _:
+  break
+}
+
+switch Whatever.Thing {
+case .Thing:
+  break
+@unknown case _: // expected-error {{'@unknown' can only be applied to the last case in a switch}}
+  break
+@unknown default:
+  break
+}
+
+switch Whatever.Thing {
+case .Thing:
+  break
+@unknown default:
+  break
+@unknown default: // expected-error {{additional 'case' blocks cannot appear after the 'default' block of a 'switch'}}
+  break
+}
+
+switch Whatever.Thing {
+@unknown case _: // expected-error {{'@unknown' can only be applied to the last case in a switch}}
+  break
+@unknown case _:
+  break
+}
+
+switch Whatever.Thing {
+@unknown case _: // expected-error {{'@unknown' can only be applied to the last case in a switch}}
+  break
+@unknown default:
+  break
+}
+
+switch Whatever.Thing {
+@unknown default:
+  break
+@unknown default: // expected-error {{additional 'case' blocks cannot appear after the 'default' block of a 'switch'}}
+  break
+}
+
+
+switch x {
+@unknown case _: // expected-error {{'@unknown' can only be applied to the last case in a switch}}
+  break
+@unknown case _:
+  break
+}
+
+switch x {
+@unknown case _: // expected-error {{'@unknown' can only be applied to the last case in a switch}}
+  break
+@unknown default:
+  break
+}
+
+switch x {
+@unknown default:
+  break
+@unknown default: // expected-error {{additional 'case' blocks cannot appear after the 'default' block of a 'switch'}}
+  break
+}