Merge pull request swiftlang#9199 from nkcsgexi/separate-note-switch

CodaFi · web-flow · commit 155273a9687a · 2017-05-02T20:36:36.000-04:00
Sema: Move the fixit for adding missing enum cases to a separate note instead of attaching to the exhaustive error itself.
diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def
@@ -3615,12 +3615,14 @@ WARNING(debug_long_closure_body, none,
 ERROR(empty_switch_stmt,none,
       "'switch' statement body must have at least one 'case' or 'default' "
       "block; do you want to add a default case?",())
-ERROR(non_exhaustive_switch,none,
-      "%select{switch must be exhaustive, consider adding |do you want to add }0"
-      "%select{missing cases|a default clause}1"
-      "%select{:|?}0", (bool, bool))
+ERROR(non_exhaustive_switch,none, "switch must be exhaustive", ())
+NOTE(missing_several_cases,none,
+     "do you want to add "
+     "%select{missing cases|a default clause}0"
+     "?", (bool))
+
 NOTE(missing_particular_case,none,
-     "missing case: '%0'", (StringRef))
+     "add missing case: '%0'", (StringRef))
 WARNING(redundant_particular_case,none,
         "case is already handled by previous patterns; consider removing it",())
 
diff --git a/include/swift/Migrator/FixitFilter.h b/include/swift/Migrator/FixitFilter.h
@@ -118,7 +118,9 @@ struct FixitFilter {
         Info.ID == diag::objc_inference_swift3_addobjc.ID ||
         Info.ID == diag::objc_inference_swift3_dynamic.ID ||
         Info.ID == diag::override_swift3_objc_inference.ID ||
-        Info.ID == diag::objc_inference_swift3_objc_derived.ID)
+        Info.ID == diag::objc_inference_swift3_objc_derived.ID ||
+        Info.ID == diag::missing_several_cases.ID ||
+        Info.ID == diag::missing_particular_case.ID)
       return true;
 
     return false;
diff --git a/lib/Sema/TypeCheckSwitchStmt.cpp b/lib/Sema/TypeCheckSwitchStmt.cpp
@@ -910,9 +910,10 @@ namespace {
           TC.Context.Diags.diagnose(StartLoc, diag::empty_switch_stmt)
              .fixItInsert(EndLoc, Buffer.str());
         } else {
-          TC.Context.Diags.diagnose(StartLoc, diag::non_exhaustive_switch,
-                             InEditor, uncovered.isEmpty())
-             .fixItInsert(EndLoc, Buffer.str());
+          TC.Context.Diags.diagnose(StartLoc, diag::non_exhaustive_switch);
+          TC.Context.Diags.diagnose(StartLoc, diag::missing_several_cases,
+                                    uncovered.isEmpty()).fixItInsert(EndLoc,
+                                                              Buffer.str());
         }
         return;
       }
@@ -944,11 +945,11 @@ namespace {
           }
         }
 
-        TC.Context.Diags.diagnose(StartLoc, diag::non_exhaustive_switch, InEditor,
-                           false).fixItInsert(EndLoc, Buffer.str());
+        TC.Context.Diags.diagnose(StartLoc, diag::non_exhaustive_switch);
+        TC.Context.Diags.diagnose(StartLoc, diag::missing_several_cases, false)
+          .fixItInsert(EndLoc, Buffer.str());
       } else {
-        TC.Context.Diags.diagnose(StartLoc, diag::non_exhaustive_switch,
-                           InEditor, false);
+        TC.Context.Diags.diagnose(StartLoc, diag::non_exhaustive_switch);
 
         for (auto &uncoveredSpace : uncovered.getSpaces()) {
           SmallVector<Space, 4> flats;
diff --git a/test/ClangImporter/enum-dataflow.swift b/test/ClangImporter/enum-dataflow.swift
@@ -7,15 +7,15 @@ import user_objc
 
 let aliasOriginal = NSAliasesEnum.byName
 
-switch aliasOriginal { // expected-error {{switch must be exhaustive, consider adding missing cases:}}
-// expected-note@-1 {{missing case: '.differentValue'}}
+switch aliasOriginal { // expected-error {{switch must be exhaustive}}
+// expected-note@-1 {{add missing case: '.differentValue'}}
 case .original:
   break
 }
 
-switch aliasOriginal { // expected-error {{switch must be exhaustive, consider adding missing cases:}}
-// expected-note@-1 {{missing case: '.original'}}
-// expected-note@-2 {{missing case: '.differentValue'}}
+switch aliasOriginal { // expected-error {{switch must be exhaustive}}
+// expected-note@-1 {{add missing case: '.original'}}
+// expected-note@-2 {{add missing case: '.differentValue'}}
 case .bySameValue:
   break
 }
diff --git a/test/ClangImporter/enum-error.swift b/test/ClangImporter/enum-error.swift
@@ -83,8 +83,8 @@ func testError() {
   switch (terr) { case .TENone, .TEOne, .TETwo: break } // ok
 
   switch (terr) { case .TENone, .TEOne: break }
-  // EXHAUSTIVE: [[@LINE-1]]:{{.+}}: error: switch must be exhaustive, consider adding missing cases
-  // EXHAUSTIVE: [[@LINE-2]]:{{.+}}: note: missing case: '.TETwo'
+  // EXHAUSTIVE: [[@LINE-1]]:{{.+}}: error: switch must be exhaustive
+  // EXHAUSTIVE: [[@LINE-2]]:{{.+}}: note: add missing case: '.TETwo'
   let _ = TestError.Code(rawValue: 2)!
 
   do {
diff --git a/test/ClangImporter/enum-new.swift b/test/ClangImporter/enum-new.swift
@@ -13,12 +13,11 @@ func test() {
   case .Yellow, .Magenta, .Black, .Cyan: break
   } // no-error
 
-  switch getColorOptions() { // expected-error {{switch must be exhaustive, consider adding a default clause}}
+  switch getColorOptions() { // expected-error {{switch must be exhaustive}} expected-note{{do you want to add a default clause?}}
   case ColorOptions.Pastel: break
   case ColorOptions.Swift: break
   }
   
-  switch 5 as Int16 { // expected-error {{switch must be exhaustive, consider adding a default clause}}
-  case Zero: break // no-error
+  switch 5 as Int16 { // expected-error {{'switch' statement body must have at least one 'case' or 'default' block; do you want to add a default case?}}
   }
 }
diff --git a/test/ClangImporter/swift2_warnings.swift b/test/ClangImporter/swift2_warnings.swift
@@ -99,9 +99,9 @@ class X : NSDocument {
 func makeProgress<T: NSProgressReporting>(thing: T) {} // expected-error {{'NSProgressReporting' has been renamed to 'ProgressReporting'}} {{22-41=ProgressReporting}} 
 
 func useLowercasedEnumCase(x: NSRuncingMode) {
-  switch x { // expected-error {{switch must be exhaustive, consider adding missing cases:}}
-    // expected-note@-1 {{missing case: '.mince'}}
-    // expected-note@-2 {{missing case: '.quince'}}
+  switch x { // expected-error {{switch must be exhaustive}}
+    // expected-note@-1 {{add missing case: '.mince'}}
+    // expected-note@-2 {{add missing case: '.quince'}}
     case .Mince: return // expected-error {{'Mince' has been renamed to 'mince'}} {{11-16=mince}}
     case .Quince: return // expected-error {{'Quince' has been renamed to 'quince'}} {{11-17=quince}}
   }
diff --git a/test/Parse/matching_patterns.swift b/test/Parse/matching_patterns.swift
@@ -58,7 +58,7 @@ case _: // expected-warning {{case is already handled by previous patterns; cons
 
 var e : Any = 0
 
-switch e { // expected-error {{switch must be exhaustive, consider adding a default clause:}}
+switch e { // expected-error {{switch must be exhaustive}} expected-note{{do you want to add a default clause?}}
 // 'is' pattern.
 case is Int,
      is A<Int>,
@@ -152,7 +152,7 @@ struct ContainsEnum {
   }
 
   func member(_ n: Possible<Int>) {
-    switch n { // expected-error {{switch must be exhaustive, consider adding missing cases:}}
+    switch n { // expected-error {{switch must be exhaustive}}
     // expected-note@-1 {{missing case: '.Mere(_)'}}
     // expected-note@-2 {{missing case: '.Twain(_, _)'}}
     case ContainsEnum.Possible<Int>.Naught,
@@ -166,7 +166,7 @@ struct ContainsEnum {
 }
 
 func nonmemberAccessesMemberType(_ n: ContainsEnum.Possible<Int>) {
-  switch n { // expected-error {{switch must be exhaustive, consider adding missing cases:}}
+  switch n { // expected-error {{switch must be exhaustive}}
   // expected-note@-1 {{missing case: '.Mere(_)'}}
   // expected-note@-2 {{missing case: '.Twain(_, _)'}}
   case ContainsEnum.Possible<Int>.Naught,
diff --git a/test/Parse/switch.swift b/test/Parse/switch.swift
@@ -71,7 +71,7 @@ default:
 }
 
 // Multiple cases per case block
-switch x { // expected-error {{switch must be exhaustive, consider adding a default clause:}}
+switch x { // expected-error {{switch must be exhaustive}} expected-note{{do you want to add a default clause?}}
 case 0: // expected-error {{'case' label in a 'switch' should have at least one executable statement}} {{8-8= break}}
 case 1:
   x = 0
@@ -83,7 +83,7 @@ default:
   x = 0
 }
 
-switch x { // expected-error {{switch must be exhaustive, consider adding a default clause:}}
+switch x { // expected-error {{switch must be exhaustive}} expected-note{{do you want to add a default clause?}}
 case 0:
   x = 0
 case 1: // expected-error {{'case' label in a 'switch' should have at least one executable statement}} {{8-8= break}}
@@ -95,7 +95,7 @@ case 0:
 default: // expected-error {{'default' label in a 'switch' should have at least one executable statement}} {{9-9= break}}
 }
 
-switch x { // expected-error {{switch must be exhaustive, consider adding a default clause:}}
+switch x { // expected-error {{switch must be exhaustive}} expected-note{{do you want to add a default clause?}}
 case 0:
   ; // expected-error {{';' statements are not allowed}} {{3-5=}}
 case 1:
@@ -142,22 +142,22 @@ default: // expected-error{{additional 'case' blocks cannot appear after the 'de
   x = 0
 }
 
-switch x { // expected-error {{switch must be exhaustive, consider adding a default clause:}}
+switch x { // expected-error {{switch must be exhaustive}} expected-note{{do you want to add a default clause?}}
 default where x == 0: // expected-error{{'default' cannot be used with a 'where' guard expression}}
   x = 0
 }
 
-switch x { // expected-error {{switch must be exhaustive, consider adding a default clause:}}
+switch x { // expected-error {{switch must be exhaustive}} expected-note{{do you want to add a default clause?}}
 case 0: // expected-error {{'case' label in a 'switch' should have at least one executable statement}} {{8-8= break}}
 }
 
-switch x { // expected-error {{switch must be exhaustive, consider adding a default clause:}}
+switch x { // expected-error {{switch must be exhaustive}} expected-note{{do you want to add a default clause?}}
 case 0: // expected-error{{'case' label in a 'switch' should have at least one executable statement}} {{8-8= break}}
 case 1:
   x = 0
 }
 
-switch x { // expected-error {{switch must be exhaustive, consider adding a default clause:}}
+switch x { // expected-error {{switch must be exhaustive}} expected-note{{do you want to add a default clause?}}
 case 0:
   x = 0
 case 1: // expected-error{{'case' label in a 'switch' should have at least one executable statement}} {{8-8= break}}
@@ -260,7 +260,7 @@ case (var a, var b): // expected-warning {{variable 'a' was never mutated; consi
 }
 
 func test_label(x : Int) {
-Gronk: // expected-error {{switch must be exhaustive, consider adding a default clause:}}
+Gronk: // expected-error {{switch must be exhaustive}} expected-note{{do you want to add a default clause?}}
   switch x {
   case 42: return
   }
diff --git a/test/Parse/switch_incomplete.swift b/test/Parse/switch_incomplete.swift
@@ -2,6 +2,6 @@
 
 // <rdar://problem/15971438> Incomplete switch was parsing to an AST that
 // triggered an assertion failure.
-// expected-error@+1 {{switch must be exhaustive, consider adding a default clause:}}
+// expected-error@+1 {{switch must be exhaustive}} expected-note@+1{{do you want to add a default clause?}}
 switch 1 { // expected-note{{to match this opening '{'}}
 case 1:    // expected-error@+1{{expected '}' at end of 'switch' statement}}
diff --git a/test/Sema/exhaustive_switch.swift b/test/Sema/exhaustive_switch.swift
@@ -79,8 +79,8 @@ enum Threepeat {
 }
 
 func test3(x: Threepeat, y: Threepeat) {
-  switch (x, y) { // expected-error {{switch must be exhaustive, consider adding missing cases:}}
-  // expected-note@-1 {{missing case: '(.a, .c)'}}
+  switch (x, y) { // expected-error {{switch must be exhaustive}}
+  // expected-note@-1 {{add missing case: '(.a, .c)'}}
   case (.a, .a):
     ()
   case (.b, _):
diff --git a/test/stmt/statements.swift b/test/stmt/statements.swift
@@ -267,7 +267,7 @@ func breakContinue(_ x : Int) -> Int {
 Outer:
   for _ in 0...1000 {
 
-  Switch: // expected-error {{switch must be exhaustive, consider adding a default clause:}}
+  Switch: // expected-error {{switch must be exhaustive}} expected-note{{do you want to add a default clause?}}
   switch x {
     case 42: break Outer
     case 97: continue Outer
@@ -299,7 +299,7 @@ Loop:  // expected-note {{previously declared here}}
   let x : Int? = 42
   
   // <rdar://problem/16879701> Should be able to pattern match 'nil' against optionals
-  switch x { // expected-error {{switch must be exhaustive, consider adding missing cases:}}
+  switch x { // expected-error {{switch must be exhaustive}}
   // expected-note@-1 {{missing case: '.some(_)'}}
   case .some(42): break
   case nil: break
@@ -452,7 +452,7 @@ enum Type {
   case Bar
 }
 func r25178926(_ a : Type) {
-  switch a { // expected-error {{switch must be exhaustive, consider adding missing cases:}}
+  switch a { // expected-error {{switch must be exhaustive}}
   // expected-note@-1 {{missing case: '.Bar'}}
   case .Foo, .Bar where 1 != 100:
     // expected-warning @-1 {{'where' only applies to the second pattern match in this case}}
@@ -461,20 +461,20 @@ func r25178926(_ a : Type) {
     break
   }
 
-  switch a { // expected-error {{switch must be exhaustive, consider adding missing cases:}}
+  switch a { // expected-error {{switch must be exhaustive}}
   // expected-note@-1 {{missing case: '.Bar'}}
   case .Foo: break
   case .Bar where 1 != 100: break
   }
 
-  switch a { // expected-error {{switch must be exhaustive, consider adding missing cases:}}
+  switch a { // expected-error {{switch must be exhaustive}}
   // expected-note@-1 {{missing case: '.Bar'}}
   case .Foo,  // no warn
        .Bar where 1 != 100:
     break
   }
 
-  switch a { // expected-error {{switch must be exhaustive, consider adding missing cases:}}
+  switch a { // expected-error {{switch must be exhaustive}}
   // expected-note@-1 {{missing case: '.Foo'}}
   // expected-note@-2 {{missing case: '.Bar'}}
   case .Foo where 1 != 100, .Bar where 1 != 100:
diff --git a/test/stmt/switch_stmt1.swift b/test/stmt/switch_stmt1.swift
@@ -6,7 +6,7 @@ enum E {
 }
 
 func foo1(e : E, i : Int) {
-  switch e {} // expected-error{{switch must be exhaustive, consider adding missing cases:}}
+  switch e {} // expected-error{{switch must be exhaustive}}
   // expected-note@-1 {{missing case: '.e1'}}
   // expected-note@-2 {{missing case: '.e2'}}
   switch i {} // expected-error{{'switch' statement body must have at least one 'case' or 'default' block; do you want to add a default case?}}{{13-13=default: <#code#>\n}}
diff --git a/test/stmt/switch_stmt2.swift b/test/stmt/switch_stmt2.swift
@@ -6,14 +6,15 @@ enum E {
 }
 
 func foo1(e : E) {
-  switch e { // expected-error{{switch must be exhaustive, consider adding missing cases:}}
-  // expected-note@-1 {{missing case: '.e2'}}
+  switch e { // expected-error{{switch must be exhaustive}}
+  // expected-note@-1 {{add missing case: '.e2'}}
   case .e1: return
   }
 }
 
 func foo2(i : Int) {
-  switch i { // expected-error{{switch must be exhaustive, consider adding a default clause}}{{3-3=default: <#code#>\n}}
+  switch i { // expected-error{{switch must be exhaustive}}
+  // expected-note@-1{{do you want to add a default clause?}}{{3-3=default: <#code#>\n}}
   case 1: return
   }
 }
@@ -75,7 +76,7 @@ func testSwitchOptionalBool(_ b: Bool?, xi: Int) -> Int {
   }
 
   switch b { // expected-error{{switch must be exhaustive}}
-  // expected-note@-1 {{missing case: '.some(false)'}}
+  // expected-note@-1 {{add missing case: '.some(false)'}}
   case .some(true):
     x += 1
   case .none:
@@ -97,15 +98,15 @@ func testSwitchEnumBoolTuple(_ b1: Bool, b2: Bool, xi: Int) -> Int {
   }
 
   switch Cond { // expected-error{{switch must be exhaustive}}
-  // expected-note@-1 {{missing case: '(false, _)'}}
-  // expected-note@-2 {{missing case: '(_, false)'}}
+  // expected-note@-1 {{add missing case: '(false, _)'}}
+  // expected-note@-2 {{add missing case: '(_, false)'}}
   case (true, true):
     x += 1
   }
 
   switch Cond { // expected-error{{switch must be exhaustive}}
-  // expected-note@-1 {{missing case: '(true, _)'}}
-  // expected-note@-2 {{missing case: '(_, false)'}}
+  // expected-note@-1 {{add missing case: '(true, _)'}}
+  // expected-note@-2 {{add missing case: '(_, false)'}}
   case (false, true):
     x += 1
   }
@@ -126,7 +127,8 @@ func testSwitchEnumBoolTuple(_ b1: Bool, b2: Bool, xi: Int) -> Int {
 
 func non_fully_covered_switch(x: Int) -> Int {
   var x = x
-  switch x { // expected-error{{switch must be exhaustive, consider adding a default clause:}}
+  switch x { // expected-error{{switch must be exhaustive}}
+  // expected-note@-1{{do you want to add a default clause?}}
   case 0:
     x += 1
   case 3:
diff --git a/test/stmt/switch_stmt_editor1.swift b/test/stmt/switch_stmt_editor1.swift
@@ -6,6 +6,7 @@ enum E {
 }
 
 func foo1(e : E, i : Int) {
-  switch e {} // expected-error{{do you want to add missing cases?}}{{13-13=case .e1: <#code#>\ncase .e2: <#code#>\n}}
-  switch i {} // expected-error{{do you want to add a default case?}}{{13-13=default: <#code#>\n}}
+  switch e {} // expected-error{{switch must be exhaustive}}
+  // expected-note@-1{{do you want to add missing cases?}}{{13-13=case .e1: <#code#>\ncase .e2: <#code#>\n}}
+  switch i {} // expected-error{{'switch' statement body must have at least one 'case' or 'default' block; do you want to add a default case?}}{{13-13=default: <#code#>\n}}
 }
diff --git a/test/stmt/switch_stmt_editor2.swift b/test/stmt/switch_stmt_editor2.swift
@@ -6,13 +6,15 @@ enum E {
 }
 
 func foo1(e : E) {
-  switch e { // expected-error{{do you want to add missing cases?}}{{3-3=case .e2: <#code#>\n}}
+  switch e { // expected-error{{switch must be exhaustive}}
+  // expected-note@-1{{do you want to add missing cases?}}{{3-3=case .e2: <#code#>\n}}
   case .e1: return
   }
 }
 
 func foo2(i : Int) {
-  switch i { // expected-error{{do you want to add a default clause?}}{{3-3=default: <#code#>\n}}
+  switch i { // expected-error{{switch must be exhaustive}}
+  // expected-note@-1{{do you want to add a default clause?}}{{3-3=default: <#code#>\n}}
   case 1: return
   }
 }

Original file line number	Diff line number	Diff line change
`@@ -13,12 +13,11 @@ func test() {`
`13`	`13`	`case .Yellow, .Magenta, .Black, .Cyan: break`
`14`	`14`	`} // no-error`
`15`	`15`
`16`		`- switch getColorOptions() { // expected-error {{switch must be exhaustive, consider adding a default clause}}`
	`16`	`+ switch getColorOptions() { // expected-error {{switch must be exhaustive}} expected-note{{do you want to add a default clause?}}`
`17`	`17`	`case ColorOptions.Pastel: break`
`18`	`18`	`case ColorOptions.Swift: break`
`19`	`19`	`}`
`20`	`20`
`21`		`- switch 5 as Int16 { // expected-error {{switch must be exhaustive, consider adding a default clause}}`
`22`		`- case Zero: break // no-error`
	`21`	`+ switch 5 as Int16 { // expected-error {{'switch' statement body must have at least one 'case' or 'default' block; do you want to add a default case?}}`
`23`	`22`	`}`
`24`	`23`	`}`