Enforce restrictions on '@unknown'

- Must be a single pattern
- Must be last in the switch
- Must not have a 'where' clause
- Must specifically be the "any" pattern if using 'case'

We may lift some of these restrictions in the future, but that would
need a new proposal.

Author: jrose-apple

include/swift/AST/DiagnosticsSema.def

@@ -2944,6 +2944,15 @@ ERROR(type_mismatch_multiple_pattern_list,none,
 ERROR(type_mismatch_fallthrough_pattern_list,none,
       "pattern variable bound to type %0, fallthrough case bound to type %1", (Type, Type))
 
+ERROR(unknown_case_must_be_catchall,none,
+      "'@unknown' is only supported for catch-all cases (\"case _\")", ())
+ERROR(unknown_case_where_clause,none,
+      "'where' cannot be used with '@unknown'", ())
+ERROR(unknown_case_multiple_patterns,none,
+      "'@unknown' cannot be applied to multiple patterns", ())
+ERROR(unknown_case_must_be_last,none,
+      "'@unknown' can only be applied to the last case in a switch", ())
+
 WARNING(where_on_one_item, none,
         "'where' only applies to the second pattern match in this case", ())
 

lib/Sema/TypeCheckStmt.cpp

@@ -913,7 +913,38 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
           labelItem.setGuardExpr(guard);
         }
       }
-        
+
+      // Check restrictions on '@unknown'.
+      if (caseBlock->hasUnknownAttr()) {
+        if (caseBlock->getCaseLabelItems().size() != 1) {
+          assert(!caseBlock->getCaseLabelItems().empty() &&
+                 "parser should not produce case blocks with no items");
+          TC.diagnose(caseBlock->getLoc(),
+                      diag::unknown_case_multiple_patterns)
+            .highlight(caseBlock->getCaseLabelItems()[1].getSourceRange());
+        }
+
+        if (!caseBlock->isDefault() && FallthroughDest != nullptr) {
+          TC.diagnose(caseBlock->getLoc(),
+                      diag::unknown_case_must_be_last);
+        }
+
+        const CaseLabelItem &labelItem = caseBlock->getCaseLabelItems().front();
+        if (labelItem.getGuardExpr() && !labelItem.isDefault()) {
+          TC.diagnose(labelItem.getStartLoc(),
+                      diag::unknown_case_where_clause)
+            .highlight(labelItem.getGuardExpr()->getSourceRange());
+        }
+
+        const Pattern *pattern =
+            labelItem.getPattern()->getSemanticsProvidingPattern();
+        if (!isa<AnyPattern>(pattern)) {
+          TC.diagnose(labelItem.getStartLoc(),
+                      diag::unknown_case_must_be_catchall)
+            .highlight(pattern->getSourceRange());
+        }
+      }
+
       // If the previous case fellthrough, similarly check that that case's bindings
       // includes our first label item's pattern bindings and types.
       if (PreviousFallthrough) {

test/Parse/switch.swift

@@ -388,7 +388,7 @@ case .Thing:
 switch Whatever.Thing {
 default:
   x = 0
-@unknown case _: // expected-error{{additional 'case' blocks cannot appear after the 'default' block of a 'switch'}}
+@unknown case _: // expected-error{{additional 'case' blocks cannot appear after the 'default' block of a 'switch'}} expected-error {{'@unknown' can only be applied to the last case in a switch}}
   x = 0
 case .Thing:
   x = 0
@@ -413,6 +413,66 @@ switch Whatever.Thing { // expected-warning {{switch must be exhaustive}} expect
   fallthrough // expected-error{{'fallthrough' without a following 'case' or 'default' block}}
 }
 
+switch Whatever.Thing {
+@unknown case _: // expected-error {{'@unknown' can only be applied to the last case in a switch}}
+  fallthrough
+case .Thing:
+  break
+}
+
+switch Whatever.Thing {
+@unknown default:
+  fallthrough
+case .Thing: // expected-error{{additional 'case' blocks cannot appear after the 'default' block of a 'switch'}}
+  break
+}
+
+switch Whatever.Thing { // expected-warning {{switch must be exhaustive}} expected-note{{add missing case: '.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'}}
+@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'}}
+@unknown case let value: // expected-error {{'@unknown' is only supported for catch-all cases ("case _")}}
+  _ = value
+}
+
+switch (Whatever.Thing, Whatever.Thing) { // expected-warning {{switch must be exhaustive}} expected-note{{add missing case: '(_, _)'}}
+@unknown case (_, _): // expected-error {{'@unknown' is only supported for catch-all cases ("case _")}}
+  break
+}
+
+switch Whatever.Thing { // expected-warning {{switch must be exhaustive}} expected-note{{add missing case: '.Thing'}}
+@unknown case is Whatever: // expected-error {{'@unknown' is only supported for catch-all cases ("case _")}}
+  // expected-warning@-1 {{'is' test is always true}}
+  break
+}
+
+switch Whatever.Thing { // expected-warning {{switch must be exhaustive}} expected-note{{add missing case: '.Thing'}}
+@unknown case .Thing: // expected-error {{'@unknown' is only supported for catch-all cases ("case _")}}
+  break
+}
+
+switch Whatever.Thing { // expected-warning {{switch must be exhaustive}} expected-note{{add missing case: '.Thing'}}
+@unknown case (_): // okay
+  break
+}
+
+switch Whatever.Thing { // expected-warning {{switch must be exhaustive}} expected-note{{add missing case: '.Thing'}}
+@unknown case _ where x == 0: // expected-error {{'where' cannot be used with '@unknown'}}
+  break
+}
+
+switch Whatever.Thing { // expected-warning {{switch must be exhaustive}} expected-note{{add missing case: '.Thing'}}
+@unknown default where x == 0: // expected-error {{'default' cannot be used with a 'where' guard expression}}
+  break
+}
+
 switch Whatever.Thing {
 case .Thing:
   x = 0