averello/swift-mirror
1
0
Fork 0
mirror of https://github.com/apple/swift.git synced 2025-12-14 20:36:38 +01:00
Code Issues Packages Projects Releases Wiki Activity

[Sema/IDE] Emit same diagnostics for missing switch cases independent of editor mode

Browse Source
This commit is contained in:
Alex Hoppen
2024-08-08 16:08:46 -07:00
parent 1d485486e1
commit 7d7eb6e61d
25 changed files with 303 additions and 1179 deletions
Download Patch File Download Diff File Expand all files Collapse all files

72
lib/Sema/TypeCheckSwitchStmt.cpp
View File

@@ -1124,8 +1124,6 @@ namespace {
llvm::SmallString<128> buffer;
llvm::raw_svector_ostream OS(buffer);
bool InEditor = Context.LangOpts.DiagnosticsEditorMode;
// Decide whether we want an error or a warning.
std::optional<decltype(diag::non_exhaustive_switch)> mainDiagType =
diag::non_exhaustive_switch;
@@ -1274,7 +1272,8 @@ namespace {
}
};
// If editing is enabled, emit a formatted error of the form:
// Emit a formatted note of the form, which has a Fix-It associated with
// it, primarily to be used in IDEs:
//
// switch must be exhaustive, do you want to add missing cases?
// case (.none, .some(_)):
@@ -1282,53 +1281,40 @@ namespace {
// case (.some(_), .none):
// <#code#>
//
// else:
//
// switch must be exhaustive, consider adding missing cases:
// To also provide actionable output for command line errors, emit notes
// like the following:
//
// missing case '(.none, .some(_))'
// missing case '(.some(_), .none)'
if (InEditor) {
buffer.clear();
SmallString<128> missingSeveralCasesFixIt;
int diagnosedCases = 0;
bool alreadyEmittedSomething = false;
processUncoveredSpaces([&](const Space &space,
bool onlyOneUncoveredSpace) {
if (space.getKind() == SpaceKind::UnknownCase) {
OS << "@unknown " << tok::kw_default;
if (onlyOneUncoveredSpace) {
OS << ":\n<#fatalError()#>\n";
DE.diagnose(startLoc, diag::missing_unknown_case)
.fixItInsert(insertLoc, buffer.str());
alreadyEmittedSomething = true;
return;
}
} else {
OS << tok::kw_case << " ";
space.show(OS);
}
OS << ":\n" << placeholder << "\n";
});
processUncoveredSpaces([&](const Space &space,
bool onlyOneUncoveredSpace) {
llvm::SmallString<64> fixItBuffer;
llvm::raw_svector_ostream fixItOS(fixItBuffer);
if (space.getKind() == SpaceKind::UnknownCase) {
fixItOS << "@unknown " << tok::kw_default << ":\n<#fatalError()#>\n";
DE.diagnose(startLoc, diag::missing_unknown_case)
.fixItInsert(insertLoc, fixItBuffer.str());
} else {
llvm::SmallString<64> spaceBuffer;
llvm::raw_svector_ostream spaceOS(spaceBuffer);
space.show(spaceOS);
if (!alreadyEmittedSomething) {
DE.diagnose(startLoc, diag::missing_several_cases, false)
.fixItInsert(insertLoc, buffer.str());
fixItOS << tok::kw_case << " " << spaceBuffer << ":\n"
<< placeholder << "\n";
DE.diagnose(startLoc, diag::missing_particular_case,
spaceBuffer.str())
.fixItInsert(insertLoc, fixItBuffer);
}
diagnosedCases += 1;
missingSeveralCasesFixIt += fixItBuffer;
});
} else {
processUncoveredSpaces([&](const Space &space,
bool onlyOneUncoveredSpace) {
if (space.getKind() == SpaceKind::UnknownCase) {
auto note = DE.diagnose(startLoc, diag::missing_unknown_case);
if (onlyOneUncoveredSpace)
note.fixItInsert(insertLoc, "@unknown default:\n<#fatalError#>()\n");
return;
}
buffer.clear();
space.show(OS);
DE.diagnose(startLoc, diag::missing_particular_case, buffer.str());
});
if (diagnosedCases > 1) {
DE.diagnose(startLoc, diag::missing_several_cases, false)
.fixItInsert(insertLoc, missingSeveralCasesFixIt.str());
}
}

1
test/ClangImporter/availability_open_enums.swift
View File

@@ -10,6 +10,7 @@ func exhaustiveSwitch(e: NSEnumAddedCasesIn2017) {
switch e { // expected-error{{switch must be exhaustive}}
// expected-note@-1{{add missing case: '.newCaseOne'}}
// expected-note@-2{{handle unknown values using "@unknown default"}}
// expected-note@-3 {{add missing cases}}
case .existingCaseOne:
return
case .existingCaseTwo:

1
test/ClangImporter/enum-dataflow.swift
View File

@@ -14,6 +14,7 @@ case .original:
switch aliasOriginal { // expected-error {{switch must be exhaustive}}
// expected-note@-1 {{add missing case: '.original'}}
// expected-note@-2 {{add missing case: '.differentValue'}}
// expected-note@-3 {{add missing cases}}
case .bySameValue:
break
}

1
test/ClangImporter/swift2_warnings.swift
View File

@@ -101,6 +101,7 @@ func useLowercasedEnumCase(x: NSRuncingMode) {
switch x { // expected-error {{switch must be exhaustive}}
// expected-note@-1 {{add missing case: '.mince'}}
// expected-note@-2 {{add missing case: '.quince'}}
// expected-note@-3 {{add missing cases}}
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}}
}

41
test/Compatibility/exhaustive_switch.swift
View File

@@ -368,6 +368,7 @@ func checkDiagnosticMinimality(x: Runcible?) {
// expected-note@-1 {{add missing case: '(.fork, _)'}}
// expected-note@-2 {{add missing case: '(.hat, .hat)'}}
// expected-note@-3 {{add missing case: '(_, .fork)'}}
// expected-note@-4 {{add missing cases}} {{+11:3-3=case (.fork, _):\n<#code#>\ncase (.hat, .hat):\n<#code#>\ncase (_, .fork):\n<#code#>\n}}
case (.spoon, .spoon):
break
case (.spoon, .hat):
@@ -381,6 +382,7 @@ func checkDiagnosticMinimality(x: Runcible?) {
// expected-note@-2 {{add missing case: '(.hat, .spoon)'}}
// expected-note@-3 {{add missing case: '(.spoon, .hat)'}}
// expected-note@-4 {{add missing case: '(_, .fork)'}}
// expected-note@-5 {{add missing cases}} {{+10:3-3=case (.fork, _):\n<#code#>\ncase (.hat, .spoon):\n<#code#>\ncase (.spoon, .hat):\n<#code#>\ncase (_, .fork):\n<#code#>\n}}
case (.spoon, .spoon):
break
case (.hat, .hat):
@@ -405,6 +407,7 @@ enum LargeSpaceEnum {
func notQuiteBigEnough() -> Bool {
switch (LargeSpaceEnum.case1, LargeSpaceEnum.case2) { // expected-error {{switch must be exhaustive}}
// expected-note@-1 110 {{add missing case:}}
// expected-note@-2 {{add missing cases}}
case (.case0, .case0): return true
case (.case1, .case1): return true
case (.case2, .case2): return true
@@ -443,6 +446,7 @@ enum ContainsOverlyLargeEnum {
func quiteBigEnough() -> Bool {
switch (OverlyLargeSpaceEnum.case1, OverlyLargeSpaceEnum.case2) { // expected-error {{switch must be exhaustive}}
// expected-note@-1 132 {{add missing case:}}
// expected-note@-2 {{add missing cases}}
case (.case0, .case0): return true
case (.case1, .case1): return true
case (.case2, .case2): return true
@@ -543,7 +547,7 @@ func quiteBigEnough() -> Bool {
}
// Make sure we haven't just stopped emitting diagnostics.
switch OverlyLargeSpaceEnum.case1 { // expected-error {{switch must be exhaustive}} expected-note 12 {{add missing case}}
switch OverlyLargeSpaceEnum.case1 { // expected-error {{switch must be exhaustive}} expected-note 12 {{add missing case}} expected-note {{add missing cases}}
}
}
@@ -564,12 +568,14 @@ indirect enum MutuallyRecursive {
func infinitelySized() -> Bool {
switch (InfinitelySized.one, InfinitelySized.one) { // expected-error {{switch must be exhaustive}}
// expected-note@-1 8 {{add missing case:}}
// expected-note@-2 {{add missing cases}}
case (.one, .one): return true
case (.two, .two): return true
}
switch (MutuallyRecursive.one, MutuallyRecursive.one) { // expected-error {{switch must be exhaustive}}
// expected-note@-1 8 {{add missing case:}}
// expected-note@-2 {{add missing cases}}
case (.one, .one): return true
case (.two, .two): return true
}
@@ -840,7 +846,7 @@ public enum NonExhaustivePayload {
// case.
@inlinable
public func testNonExhaustive(_ value: NonExhaustive, _ payload: NonExhaustivePayload, for interval: TemporalProxy, flag: Bool) {
switch value { // expected-error {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b'}} {{none}}
switch value { // expected-error {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b'}} {{+2:3-3=case .b:\n<#code#>\n}}
case .a: break
}
@@ -861,12 +867,16 @@ public func testNonExhaustive(_ value: NonExhaustive, _ payload: NonExhaustivePa
@unknown case _: break // no-warning
}
switch value { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b'}} {{none}}
switch value { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b'}} {{+2:3-3=case .b:\n<#code#>\n}}
case .a: break
@unknown case _: break
}
switch value { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.a'}} {{none}} expected-note {{add missing case: '.b'}} {{none}}
switch value {
// expected-warning@-1 {{switch must be exhaustive}} {{none}}
// expected-note@-2 {{add missing case: '.a'}} {{+5:3-3=case .a:\n<#code#>\n}}
// expected-note@-3 {{add missing case: '.b'}} {{+5:3-3=case .b:\n<#code#>\n}}
// expected-note@-4 {{add missing cases}} {{+5:3-3=case .a:\n<#code#>\ncase .b:\n<#code#>\n}}
@unknown case _: break
}
@@ -932,7 +942,7 @@ public func testNonExhaustive(_ value: NonExhaustive, _ payload: NonExhaustivePa
} // no-warning
// Test payloaded enums.
switch payload { // expected-error {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(_)'}} {{none}}
switch payload { // expected-error {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(_)'}} {{+2:3-3=case .b(_):\n<#code#>\n}}
case .a: break
}
@@ -953,17 +963,17 @@ public func testNonExhaustive(_ value: NonExhaustive, _ payload: NonExhaustivePa
@unknown case _: break // no-warning
}
switch payload { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(_)'}} {{none}}
switch payload { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(_)'}} {{+2:3-3=case .b(_):\n<#code#>\n}}
case .a: break
@unknown case _: break
}
switch payload { // expected-error {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(true)'}} {{none}}
switch payload { // expected-error {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(true)'}} {{+3:3-3=case .b(true):\n<#code#>\n}}
case .a: break
case .b(false): break
}
switch payload { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(true)'}} {{none}}
switch payload { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(true)'}} {{+3:3-3=case .b(true):\n<#code#>\n}}
case .a: break
case .b(false): break
@unknown case _: break
@@ -1017,12 +1027,15 @@ public func testNonExhaustiveWithinModule(_ value: NonExhaustive, _ payload: Non
@unknown case _: break // no-warning
}
switch value { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b'}} {{none}}
switch value { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b'}} {{+2:3-3=case .b:\n<#code#>\n}}
case .a: break
@unknown case _: break
}
switch value { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.a'}} {{none}} expected-note {{add missing case: '.b'}} {{none}}
switch value { // expected-warning {{switch must be exhaustive}} {{none}}
// expected-note@-1 {{add missing case: '.a'}} {{+4:3-3=case .a:\n<#code#>\n}}
// expected-note@-2 {{add missing case: '.b'}} {{+4:3-3=case .b:\n<#code#>\n}}
// expected-note@-3 {{add missing cases}} {{+4:3-3=case .a:\n<#code#>\ncase .b:\n<#code#>\n}}
@unknown case _: break
}
@@ -1071,7 +1084,7 @@ public func testNonExhaustiveWithinModule(_ value: NonExhaustive, _ payload: Non
}
// Test payloaded enums.
switch payload { // expected-error {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(_)'}} {{none}}
switch payload { // expected-error {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(_)'}} {{+2:3-3=case .b(_):\n<#code#>\n}}
case .a: break
}
@@ -1092,17 +1105,17 @@ public func testNonExhaustiveWithinModule(_ value: NonExhaustive, _ payload: Non
@unknown case _: break // no-warning
}
switch payload { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(_)'}} {{none}}
switch payload { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(_)'}} {{+2:3-3=case .b(_):\n<#code#>\n}}
case .a: break
@unknown case _: break
}
switch payload { // expected-error {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(true)'}} {{none}}
switch payload { // expected-error {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(true)'}} {{+3:3-3=case .b(true):\n<#code#>\n}}
case .a: break
case .b(false): break
}
switch payload { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(true)'}} {{none}}
switch payload { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(true)'}} {{+3:3-3=case .b(true):\n<#code#>\n}}
case .a: break
case .b(false): break
@unknown case _: break

8
test/FixCode/fixits-empty-switch-multifile.swift
View File

@@ -1,7 +1,11 @@
// RUN: not %swift -typecheck -target %target-triple %s %S/Inputs/fixits-enum-multifile.swift -emit-fixits-path %t.remap -I %S/Inputs -diagnostics-editor-mode
// RUN: c-arcmt-test %t.remap | arcmt-test -verify-transformed-files %s.result
// RUN: %target-typecheck-verify-swift %s %S/Inputs/fixits-enum-multifile.swift -I %S/Inputs
func foo1(_ e: EMulti) {
switch e {
// expected-error@-1 {{switch must be exhaustive}}
// expected-note@-2 {{add missing case: '.e1'}} {{+6:3-3=case .e1:\n<#code#>\n}}
// expected-note@-3 {{add missing case: '.e2'}} {{+6:3-3=case .e2:\n<#code#>\n}}
// expected-note@-4 {{add missing case: '.e3(_)'}} {{+6:3-3=case .e3(_):\n<#code#>\n}}
// expected-note@-5 {{add missing cases}} {{+6:3-3=case .e1:\n<#code#>\ncase .e2:\n<#code#>\ncase .e3(_):\n<#code#>\n}}
}
}

13
test/FixCode/fixits-empty-switch-multifile.swift.result
View File

@@ -1,13 +0,0 @@
// RUN: not %swift -typecheck -target %target-triple %s %S/Inputs/fixits-enum-multifile.swift -emit-fixits-path %t.remap -I %S/Inputs -diagnostics-editor-mode
// RUN: c-arcmt-test %t.remap | arcmt-test -verify-transformed-files %s.result
func foo1(_ e: EMulti) {
switch e {
case .e1:
<#code#>
case .e2:
<#code#>
case .e3(_):
<#code#>
}
}

10
test/FixCode/fixits-empty-switch.swift
View File

@@ -1,5 +1,4 @@
// RUN: not %swift -typecheck -target %target-triple %s -emit-fixits-path %t.remap -I %S/Inputs -diagnostics-editor-mode
// RUN: c-arcmt-test %t.remap | arcmt-test -verify-transformed-files %s.result
// RUN: %target-typecheck-verify-swift %s -I %S/Inputs -diagnostics-editor-mode
enum E1 {
case e1
@@ -9,10 +8,15 @@ enum E1 {
func foo1(_ e: E1) {
switch e {
//expected-error@-1 {{switch must be exhaustive}}
//expected-note@-2 {{add missing case: '.e1'}} {{+6:3-3=case .e1:\n<#code#>\n}}
//expected-note@-3 {{add missing case: '.e2'}} {{+6:3-3=case .e2:\n<#code#>\n}}
//expected-note@-4 {{add missing case: '.e3'}} {{+6:3-3=case .e3:\n<#code#>\n}}
//expected-note@-5 {{add missing cases}} {{+6:3-3=case .e1:\n<#code#>\ncase .e2:\n<#code#>\ncase .e3:\n<#code#>\n}}
}
}
func foo1 (_ i : Int) {
switch i {
switch i { // expected-error {{'switch' statement body must have at least one 'case' or 'default' block; add a default case}} {{+1:3-3=default:\n<#code#>\n}}
}
}

26
test/FixCode/fixits-empty-switch.swift.result
View File

@@ -1,26 +0,0 @@
// RUN: not %swift -typecheck -target %target-triple %s -emit-fixits-path %t.remap -I %S/Inputs -diagnostics-editor-mode
// RUN: c-arcmt-test %t.remap | arcmt-test -verify-transformed-files %s.result
enum E1 {
case e1
case e2
case e3
}
func foo1(_ e: E1) {
switch e {
case .e1:
<#code#>
case .e2:
<#code#>
case .e3:
<#code#>
}
}
func foo1 (_ i : Int) {
switch i {
default:
<#code#>
}
}

88
test/FixCode/fixits-switch-nonfrozen.swift
View File

@@ -1,5 +1,4 @@
// RUN: not %target-swift-frontend -emit-sil %s -emit-fixits-path %t.remap -enable-library-evolution -enable-nonfrozen-enum-exhaustivity-diagnostics -diagnostics-editor-mode
// RUN: c-arcmt-test %t.remap | arcmt-test -verify-transformed-files %s.result
// RUN: %target-swift-frontend -emit-sil %s -enable-library-evolution -enable-nonfrozen-enum-exhaustivity-diagnostics -diagnostics-editor-mode -verify -swift-version 6
enum Runcible {
case spoon
@@ -9,6 +8,11 @@ enum Runcible {
func checkDiagnosticMinimality(x: Runcible?) {
switch (x!, x!) {
// expected-error@-1 {{switch must be exhaustive}}
// expected-note@-2 {{add missing case: '(.fork, _)'}} {{+12:3-3=case (.fork, _):\n<#code#>\n}}
// expected-note@-3 {{add missing case: '(.hat, .hat)'}} {{+12:3-3=case (.hat, .hat):\n<#code#>\n}}
// expected-note@-4 {{add missing case: '(_, .fork)'}} {{+12:3-3=case (_, .fork):\n<#code#>\n}}
// expected-note@-5 {{add missing cases}} {{+12:3-3=case (.fork, _):\n<#code#>\ncase (.hat, .hat):\n<#code#>\ncase (_, .fork):\n<#code#>\n}}
case (.spoon, .spoon):
break
case (.spoon, .hat):
@@ -18,6 +22,12 @@ func checkDiagnosticMinimality(x: Runcible?) {
}
switch (x!, x!) {
// expected-error@-1 {{switch must be exhaustive}}
// expected-note@-2 {{add missing case: '(.fork, _)'}} {{+11:3-3=case (.fork, _):\n<#code#>\n}}
// expected-note@-3 {{add missing case: '(.hat, .spoon)'}} {{+11:3-3=case (.hat, .spoon):\n<#code#>\n}}
// expected-note@-4 {{add missing case: '(.spoon, .hat)'}} {{+11:3-3=case (.spoon, .hat):\n<#code#>\n}}
// expected-note@-5 {{add missing case: '(_, .fork)'}} {{+11:3-3=case (_, .fork):\n<#code#>\n}}
// expected-note@-6 {{add missing cases}} {{+11:3-3=case (.fork, _):\n<#code#>\ncase (.hat, .spoon):\n<#code#>\ncase (.spoon, .hat):\n<#code#>\ncase (_, .fork):\n<#code#>\n}}
case (.spoon, .spoon):
break
case (.hat, .hat):
@@ -41,6 +51,9 @@ enum LargeSpaceEnum {
func notQuiteBigEnough() -> Bool {
switch (LargeSpaceEnum.case1, LargeSpaceEnum.case2) {
// expected-error@-1 {{switch must be exhaustive}}
// expected-note@-2 110{{add missing case}}
// expected-note@-3 {{add missing cases}} {{+15:3-3=case (.case10, .case0):\n<#code#>\ncase (.case10, .case1):\n<#code#>\ncase (.case10, .case2):\n<#code#>\ncase (.case10, .case3):\n<#code#>\ncase (.case10, .case4):\n<#code#>\ncase (.case10, .case5):\n<#code#>\ncase (.case10, .case6):\n<#code#>\ncase (.case10, .case7):\n<#code#>\ncase (.case10, .case8):\n<#code#>\ncase (.case10, .case9):\n<#code#>\ncase (.case9, .case0):\n<#code#>\ncase (.case9, .case1):\n<#code#>\ncase (.case9, .case2):\n<#code#>\ncase (.case9, .case3):\n<#code#>\ncase (.case9, .case4):\n<#code#>\ncase (.case9, .case5):\n<#code#>\ncase (.case9, .case6):\n<#code#>\ncase (.case9, .case7):\n<#code#>\ncase (.case9, .case8):\n<#code#>\ncase (.case9, .case10):\n<#code#>\ncase (.case8, .case0):\n<#code#>\ncase (.case8, .case1):\n<#code#>\ncase (.case8, .case2):\n<#code#>\ncase (.case8, .case3):\n<#code#>\ncase (.case8, .case4):\n<#code#>\ncase (.case8, .case5):\n<#code#>\ncase (.case8, .case6):\n<#code#>\ncase (.case8, .case7):\n<#code#>\ncase (.case8, .case9):\n<#code#>\ncase (.case8, .case10):\n<#code#>\ncase (.case7, .case0):\n<#code#>\ncase (.case7, .case1):\n<#code#>\ncase (.case7, .case2):\n<#code#>\ncase (.case7, .case3):\n<#code#>\ncase (.case7, .case4):\n<#code#>\ncase (.case7, .case5):\n<#code#>\ncase (.case7, .case6):\n<#code#>\ncase (.case7, .case8):\n<#code#>\ncase (.case7, .case9):\n<#code#>\ncase (.case7, .case10):\n<#code#>\ncase (.case6, .case0):\n<#code#>\ncase (.case6, .case1):\n<#code#>\ncase (.case6, .case2):\n<#code#>\ncase (.case6, .case3):\n<#code#>\ncase (.case6, .case4):\n<#code#>\ncase (.case6, .case5):\n<#code#>\ncase (.case6, .case7):\n<#code#>\ncase (.case6, .case8):\n<#code#>\ncase (.case6, .case9):\n<#code#>\ncase (.case6, .case10):\n<#code#>\ncase (.case5, .case0):\n<#code#>\ncase (.case5, .case1):\n<#code#>\ncase (.case5, .case2):\n<#code#>\ncase (.case5, .case3):\n<#code#>\ncase (.case5, .case4):\n<#code#>\ncase (.case5, .case6):\n<#code#>\ncase (.case5, .case7):\n<#code#>\ncase (.case5, .case8):\n<#code#>\ncase (.case5, .case9):\n<#code#>\ncase (.case5, .case10):\n<#code#>\ncase (.case4, .case0):\n<#code#>\ncase (.case4, .case1):\n<#code#>\ncase (.case4, .case2):\n<#code#>\ncase (.case4, .case3):\n<#code#>\ncase (.case4, .case5):\n<#code#>\ncase (.case4, .case6):\n<#code#>\ncase (.case4, .case7):\n<#code#>\ncase (.case4, .case8):\n<#code#>\ncase (.case4, .case9):\n<#code#>\ncase (.case4, .case10):\n<#code#>\ncase (.case3, .case0):\n<#code#>\ncase (.case3, .case1):\n<#code#>\ncase (.case3, .case2):\n<#code#>\ncase (.case3, .case4):\n<#code#>\ncase (.case3, .case5):\n<#code#>\ncase (.case3, .case6):\n<#code#>\ncase (.case3, .case7):\n<#code#>\ncase (.case3, .case8):\n<#code#>\ncase (.case3, .case9):\n<#code#>\ncase (.case3, .case10):\n<#code#>\ncase (.case2, .case0):\n<#code#>\ncase (.case2, .case1):\n<#code#>\ncase (.case2, .case3):\n<#code#>\ncase (.case2, .case4):\n<#code#>\ncase (.case2, .case5):\n<#code#>\ncase (.case2, .case6):\n<#code#>\ncase (.case2, .case7):\n<#code#>\ncase (.case2, .case8):\n<#code#>\ncase (.case2, .case9):\n<#code#>\ncase (.case2, .case10):\n<#code#>\ncase (.case1, .case0):\n<#code#>\ncase (.case1, .case2):\n<#code#>\ncase (.case1, .case3):\n<#code#>\ncase (.case1, .case4):\n<#code#>\ncase (.case1, .case5):\n<#code#>\ncase (.case1, .case6):\n<#code#>\ncase (.case1, .case7):\n<#code#>\ncase (.case1, .case8):\n<#code#>\ncase (.case1, .case9):\n<#code#>\ncase (.case1, .case10):\n<#code#>\ncase (.case0, .case1):\n<#code#>\ncase (.case0, .case2):\n<#code#>\ncase (.case0, .case3):\n<#code#>\ncase (.case0, .case4):\n<#code#>\ncase (.case0, .case5):\n<#code#>\ncase (.case0, .case6):\n<#code#>\ncase (.case0, .case7):\n<#code#>\ncase (.case0, .case8):\n<#code#>\ncase (.case0, .case9):\n<#code#>\ncase (.case0, .case10):\n<#code#>\n}}
case (.case0, .case0): return true
case (.case1, .case1): return true
case (.case2, .case2): return true
@@ -78,6 +91,9 @@ enum ContainsOverlyLargeEnum {
func quiteBigEnough() -> Bool {
switch (OverlyLargeSpaceEnum.case1, OverlyLargeSpaceEnum.case2) {
// expected-error@-1 {{switch must be exhaustive}}
// expected-note@-2 132{{add missing case}}
// expected-note@-3 {{add missing cases}} {{+16:3-3=case (.case11, .case0):\n<#code#>\ncase (.case11, .case1):\n<#code#>\ncase (.case11, .case2):\n<#code#>\ncase (.case11, .case3):\n<#code#>\ncase (.case11, .case4):\n<#code#>\ncase (.case11, .case5):\n<#code#>\ncase (.case11, .case6):\n<#code#>\ncase (.case11, .case7):\n<#code#>\ncase (.case11, .case8):\n<#code#>\ncase (.case11, .case9):\n<#code#>\ncase (.case11, .case10):\n<#code#>\ncase (.case10, .case0):\n<#code#>\ncase (.case10, .case1):\n<#code#>\ncase (.case10, .case2):\n<#code#>\ncase (.case10, .case3):\n<#code#>\ncase (.case10, .case4):\n<#code#>\ncase (.case10, .case5):\n<#code#>\ncase (.case10, .case6):\n<#code#>\ncase (.case10, .case7):\n<#code#>\ncase (.case10, .case8):\n<#code#>\ncase (.case10, .case9):\n<#code#>\ncase (.case10, .case11):\n<#code#>\ncase (.case9, .case0):\n<#code#>\ncase (.case9, .case1):\n<#code#>\ncase (.case9, .case2):\n<#code#>\ncase (.case9, .case3):\n<#code#>\ncase (.case9, .case4):\n<#code#>\ncase (.case9, .case5):\n<#code#>\ncase (.case9, .case6):\n<#code#>\ncase (.case9, .case7):\n<#code#>\ncase (.case9, .case8):\n<#code#>\ncase (.case9, .case10):\n<#code#>\ncase (.case9, .case11):\n<#code#>\ncase (.case8, .case0):\n<#code#>\ncase (.case8, .case1):\n<#code#>\ncase (.case8, .case2):\n<#code#>\ncase (.case8, .case3):\n<#code#>\ncase (.case8, .case4):\n<#code#>\ncase (.case8, .case5):\n<#code#>\ncase (.case8, .case6):\n<#code#>\ncase (.case8, .case7):\n<#code#>\ncase (.case8, .case9):\n<#code#>\ncase (.case8, .case10):\n<#code#>\ncase (.case8, .case11):\n<#code#>\ncase (.case7, .case0):\n<#code#>\ncase (.case7, .case1):\n<#code#>\ncase (.case7, .case2):\n<#code#>\ncase (.case7, .case3):\n<#code#>\ncase (.case7, .case4):\n<#code#>\ncase (.case7, .case5):\n<#code#>\ncase (.case7, .case6):\n<#code#>\ncase (.case7, .case8):\n<#code#>\ncase (.case7, .case9):\n<#code#>\ncase (.case7, .case10):\n<#code#>\ncase (.case7, .case11):\n<#code#>\ncase (.case6, .case0):\n<#code#>\ncase (.case6, .case1):\n<#code#>\ncase (.case6, .case2):\n<#code#>\ncase (.case6, .case3):\n<#code#>\ncase (.case6, .case4):\n<#code#>\ncase (.case6, .case5):\n<#code#>\ncase (.case6, .case7):\n<#code#>\ncase (.case6, .case8):\n<#code#>\ncase (.case6, .case9):\n<#code#>\ncase (.case6, .case10):\n<#code#>\ncase (.case6, .case11):\n<#code#>\ncase (.case5, .case0):\n<#code#>\ncase (.case5, .case1):\n<#code#>\ncase (.case5, .case2):\n<#code#>\ncase (.case5, .case3):\n<#code#>\ncase (.case5, .case4):\n<#code#>\ncase (.case5, .case6):\n<#code#>\ncase (.case5, .case7):\n<#code#>\ncase (.case5, .case8):\n<#code#>\ncase (.case5, .case9):\n<#code#>\ncase (.case5, .case10):\n<#code#>\ncase (.case5, .case11):\n<#code#>\ncase (.case4, .case0):\n<#code#>\ncase (.case4, .case1):\n<#code#>\ncase (.case4, .case2):\n<#code#>\ncase (.case4, .case3):\n<#code#>\ncase (.case4, .case5):\n<#code#>\ncase (.case4, .case6):\n<#code#>\ncase (.case4, .case7):\n<#code#>\ncase (.case4, .case8):\n<#code#>\ncase (.case4, .case9):\n<#code#>\ncase (.case4, .case10):\n<#code#>\ncase (.case4, .case11):\n<#code#>\ncase (.case3, .case0):\n<#code#>\ncase (.case3, .case1):\n<#code#>\ncase (.case3, .case2):\n<#code#>\ncase (.case3, .case4):\n<#code#>\ncase (.case3, .case5):\n<#code#>\ncase (.case3, .case6):\n<#code#>\ncase (.case3, .case7):\n<#code#>\ncase (.case3, .case8):\n<#code#>\ncase (.case3, .case9):\n<#code#>\ncase (.case3, .case10):\n<#code#>\ncase (.case3, .case11):\n<#code#>\ncase (.case2, .case0):\n<#code#>\ncase (.case2, .case1):\n<#code#>\ncase (.case2, .case3):\n<#code#>\ncase (.case2, .case4):\n<#code#>\ncase (.case2, .case5):\n<#code#>\ncase (.case2, .case6):\n<#code#>\ncase (.case2, .case7):\n<#code#>\ncase (.case2, .case8):\n<#code#>\ncase (.case2, .case9):\n<#code#>\ncase (.case2, .case10):\n<#code#>\ncase (.case2, .case11):\n<#code#>\ncase (.case1, .case0):\n<#code#>\ncase (.case1, .case2):\n<#code#>\ncase (.case1, .case3):\n<#code#>\ncase (.case1, .case4):\n<#code#>\ncase (.case1, .case5):\n<#code#>\ncase (.case1, .case6):\n<#code#>\ncase (.case1, .case7):\n<#code#>\ncase (.case1, .case8):\n<#code#>\ncase (.case1, .case9):\n<#code#>\ncase (.case1, .case10):\n<#code#>\ncase (.case1, .case11):\n<#code#>\ncase (.case0, .case1):\n<#code#>\ncase (.case0, .case2):\n<#code#>\ncase (.case0, .case3):\n<#code#>\ncase (.case0, .case4):\n<#code#>\ncase (.case0, .case5):\n<#code#>\ncase (.case0, .case6):\n<#code#>\ncase (.case0, .case7):\n<#code#>\ncase (.case0, .case8):\n<#code#>\ncase (.case0, .case9):\n<#code#>\ncase (.case0, .case10):\n<#code#>\ncase (.case0, .case11):\n<#code#>\n}}
case (.case0, .case0): return true
case (.case1, .case1): return true
case (.case2, .case2): return true
@@ -93,6 +109,8 @@ func quiteBigEnough() -> Bool {
}
switch (OverlyLargeSpaceEnum.case1, OverlyLargeSpaceEnum.case2) {
// expected-error@-1 {{switch must be exhaustive}}
// expected-note@-2 {{add missing case: '(.case11, _)'}} {{+14:3-3=case (.case11, _):\n<#code#>\n}}
case (.case0, _): return true
case (.case1, _): return true
case (.case2, _): return true
@@ -123,11 +141,31 @@ indirect enum MutuallyRecursive {
func infinitelySized() -> Bool {
switch (InfinitelySized.one, InfinitelySized.one) {
// expected-error@-1 {{switch must be exhaustive}}
// expected-note@-2 {{add missing case: '(.recur(_), _)'}} {{+13:3-3=case (.recur(_), _):\n<#code#>\n}}
// expected-note@-3 {{add missing case: '(.mutualRecur(_, _), _)'}} {{+13:3-3=case (.mutualRecur(_, _), _):\n<#code#>\n}}
// expected-note@-4 {{add missing case: '(.two, .one)'}} {{+13:3-3=case (.two, .one):\n<#code#>\n}}
// expected-note@-5 {{add missing case: '(.recur(_), .mutualRecur(_, _))'}} {{+13:3-3=case (.recur(_), .mutualRecur(_, _)):\n<#code#>\n}}
// expected-note@-6 {{add missing case: '(.mutualRecur(_, _), .mutualRecur(_, _))'}} {{+13:3-3=case (.mutualRecur(_, _), .mutualRecur(_, _)):\n<#code#>\n}}
// expected-note@-7 {{add missing case: '(.one, .two)'}} {{+13:3-3=case (.one, .two):\n<#code#>\n}}
// expected-note@-8 {{add missing case: '(_, .recur(_))'}} {{+13:3-3=case (_, .recur(_)):\n<#code#>\n}}
// expected-note@-9 {{add missing case: '(_, .mutualRecur(_, _))'}} {{+13:3-3=case (_, .mutualRecur(_, _)):\n<#code#>\n}}
// expected-note@-10 {{add missing cases}} {{+13:3-3=case (.recur(_), _):\n<#code#>\ncase (.mutualRecur(_, _), _):\n<#code#>\ncase (.two, .one):\n<#code#>\ncase (.recur(_), .mutualRecur(_, _)):\n<#code#>\ncase (.mutualRecur(_, _), .mutualRecur(_, _)):\n<#code#>\ncase (.one, .two):\n<#code#>\ncase (_, .recur(_)):\n<#code#>\ncase (_, .mutualRecur(_, _)):\n<#code#>\n}}
case (.one, .one): return true
case (.two, .two): return true
}
switch (MutuallyRecursive.one, MutuallyRecursive.one) {
// expected-error@-1 {{switch must be exhaustive}}
// expected-note@-2 {{add missing case: '(.recur(_), _)'}} {{+13:3-3=case (.recur(_), _):\n<#code#>\n}}
// expected-note@-3 {{add missing case: '(.mutualRecur(_, _), _)'}} {{+13:3-3=case (.mutualRecur(_, _), _):\n<#code#>\n}}
// expected-note@-4 {{add missing case: '(.two, .one)'}} {{+13:3-3=case (.two, .one):\n<#code#>\n}}
// expected-note@-5 {{add missing case: '(.recur(_), .mutualRecur(_, _))'}} {{+13:3-3=case (.recur(_), .mutualRecur(_, _)):\n<#code#>\n}}
// expected-note@-6 {{add missing case: '(.mutualRecur(_, _), .mutualRecur(_, _))'}} {{+13:3-3=case (.mutualRecur(_, _), .mutualRecur(_, _)):\n<#code#>\n}}
// expected-note@-7 {{add missing case: '(.one, .two)'}} {{+13:3-3=case (.one, .two):\n<#code#>\n}}
// expected-note@-8 {{add missing case: '(_, .recur(_))'}} {{+13:3-3=case (_, .recur(_)):\n<#code#>\n}}
// expected-note@-9 {{add missing case: '(_, .mutualRecur(_, _))'}} {{+13:3-3=case (_, .mutualRecur(_, _)):\n<#code#>\n}}
// expected-note@-10 {{add missing cases}} {{+13:3-3=case (.recur(_), _):\n<#code#>\ncase (.mutualRecur(_, _), _):\n<#code#>\ncase (.two, .one):\n<#code#>\ncase (.recur(_), .mutualRecur(_, _)):\n<#code#>\ncase (.mutualRecur(_, _), .mutualRecur(_, _)):\n<#code#>\ncase (.one, .two):\n<#code#>\ncase (_, .recur(_)):\n<#code#>\ncase (_, .mutualRecur(_, _)):\n<#code#>\n}}
case (.one, .one): return true
case (.two, .two): return true
}
@@ -154,10 +192,16 @@ public enum NonExhaustivePayload {
@inlinable
public func testNonExhaustive(_ value: NonExhaustive, _ payload: NonExhaustivePayload, for interval: TemporalProxy, flag: Bool) {
switch value {
// expected-error@-1 {{switch must be exhaustive}}
// expected-note@-2 {{add missing case: '.b'}} {{+6:3-3=case .b:\n<#code#>\n}}
// expected-note@-3 {{handle unknown values using "@unknown default"}} {{+6:3-3=@unknown default:\n<#fatalError()#>\n}}
// expected-note@-4 {{add missing cases}} {{+6:3-3=case .b:\n<#code#>\n@unknown default:\n<#fatalError()#>\n}}
case .a: break
}
switch value {
// expected-error@-1 {{switch covers known cases, but 'NonExhaustive' may have additional unknown values}}
// expected-note@-2 {{handle unknown values using "@unknown default"}} {{+5:3-3=@unknown default:\n<#fatalError()#>\n}}
case .a: break
case .b: break
}
@@ -175,16 +219,24 @@ public func testNonExhaustive(_ value: NonExhaustive, _ payload: NonExhaustivePa
}
switch value {
// expected-error@-1 {{switch must be exhaustive}}
// expected-note@-2 {{add missing case: '.b'}} {{+4:3-3=case .b:\n<#code#>\n}}
case .a: break
@unknown case _: break
}
switch value {
// expected-error@-1 {{switch must be exhaustive}}
// expected-note@-2 {{add missing case: '.a'}} {{+5:3-3=case .a:\n<#code#>\n}}
// expected-note@-3 {{add missing case: '.b'}} {{+5:3-3=case .b:\n<#code#>\n}}
// expected-note@-4 {{add missing cases}} {{+5:3-3=case .a:\n<#code#>\ncase .b:\n<#code#>\n}}
@unknown case _: break
}
// Test being part of other spaces.
switch value as Optional {
// expected-error@-1 {{switch covers known cases, but 'Optional<NonExhaustive>' may have additional unknown values}}
// expected-note@-2 {{add missing case: '.some(_)'}} {{+6:3-3=case .some(_):\n<#code#>\n}}
case .a?: break
case .b?: break
case nil: break
@@ -203,6 +255,8 @@ public func testNonExhaustive(_ value: NonExhaustive, _ payload: NonExhaustivePa
} // no-warning
switch (value, flag) {
// expected-error@-1 {{switch covers known cases, but '(NonExhaustive, Bool)' may have additional unknown values}}
// expected-note@-2 {{add missing case: '(_, false)'}} {{+6:3-3=case (_, false):\n<#code#>\n}}
case (.a, _): break
case (.b, false): break
case (_, true): break
@@ -216,6 +270,8 @@ public func testNonExhaustive(_ value: NonExhaustive, _ payload: NonExhaustivePa
} // no-warning
switch (flag, value) {
// expected-error@-1 {{switch covers known cases, but '(Bool, NonExhaustive)' may have additional unknown values}}
// expected-note@-2 {{add missing case: '(false, _)'}} {{+6:3-3=case (false, _):\n<#code#>\n}}
case (_, .a): break
case (false, .b): break
case (true, _): break
@@ -229,6 +285,8 @@ public func testNonExhaustive(_ value: NonExhaustive, _ payload: NonExhaustivePa
} // no-warning
switch (value, value) {
// expected-error@-1 {{switch covers known cases, but '(NonExhaustive, NonExhaustive)' may have additional unknown values}}
// expected-note@-2 {{add missing case: '(_, _)'}} {{+5:3-3=case (_, _):\n<#code#>\n}}
case (.a, _), (_, .a): break
case (.b, _), (_, .b): break
}
@@ -240,12 +298,24 @@ public func testNonExhaustive(_ value: NonExhaustive, _ payload: NonExhaustivePa
} // no-warning
switch (value, interval) {
// expected-error@-1 {{switch covers known cases, but '(NonExhaustive, TemporalProxy)' may have additional unknown values}}
// expected-note@-2 {{add missing case: '(_, .milliseconds(_))'}} {{+10:3-3=case (_, .milliseconds(_)):\n<#code#>\n}}
// expected-note@-3 {{add missing case: '(_, .microseconds(_))'}} {{+10:3-3=case (_, .microseconds(_)):\n<#code#>\n}}
// expected-note@-4 {{add missing case: '(_, .nanoseconds(_))'}} {{+10:3-3=case (_, .nanoseconds(_)):\n<#code#>\n}}
// expected-note@-5 {{add missing case: '(_, .never)'}} {{+10:3-3=case (_, .never):\n<#code#>\n}}
// expected-note@-6 {{add missing cases}} {{+10:3-3=case (_, .milliseconds(_)):\n<#code#>\ncase (_, .microseconds(_)):\n<#code#>\ncase (_, .nanoseconds(_)):\n<#code#>\ncase (_, .never):\n<#code#>\n}}
case (_, .seconds): break
case (.a, _): break
case (.b, _): break
}
switch (value, interval) {
// expected-error@-1 {{switch covers known cases, but '(NonExhaustive, TemporalProxy)' may have additional unknown values}}
// expected-note@-2 {{add missing case: '(_, .seconds(_))'}} {{+10:3-3=case (_, .seconds(_)):\n<#code#>\n}}
// expected-note@-3 {{add missing case: '(_, .milliseconds(_))'}} {{+10:3-3=case (_, .milliseconds(_)):\n<#code#>\n}}
// expected-note@-4 {{add missing case: '(_, .microseconds(_))'}} {{+10:3-3=case (_, .microseconds(_)):\n<#code#>\n}}
// expected-note@-5 {{add missing case: '(_, .nanoseconds(_))'}} {{+10:3-3=case (_, .nanoseconds(_)):\n<#code#>\n}}
// expected-note@-6 {{add missing cases}} {{+10:3-3=case (_, .seconds(_)):\n<#code#>\ncase (_, .milliseconds(_)):\n<#code#>\ncase (_, .microseconds(_)):\n<#code#>\ncase (_, .nanoseconds(_)):\n<#code#>\n}}
case (_, .never): break
case (.a, _): break
case (.b, _): break
@@ -253,10 +323,16 @@ public func testNonExhaustive(_ value: NonExhaustive, _ payload: NonExhaustivePa
// Test payloaded enums.
switch payload {
// expected-error@-1 {{switch must be exhaustive}}
// expected-note@-2 {{add missing case: '.b(_)'}} {{+6:3-3=case .b(_):\n<#code#>\n}}
// expected-note@-3 {{handle unknown values using "@unknown default"}} {{+6:3-3=@unknown default:\n<#fatalError()#>\n}}
// expected-note@-4 {{add missing cases}} {{+6:3-3=case .b(_):\n<#code#>\n@unknown default:\n<#fatalError()#>\n}}
case .a: break
}
switch payload {
// expected-error@-1 {{switch covers known cases, but 'NonExhaustivePayload' may have additional unknown values}}
// expected-note@-2 {{handle unknown values using "@unknown default"}} {{+5:3-3=@unknown default:\n<#fatalError()#>\n}}
case .a: break
case .b: break
}
@@ -274,16 +350,24 @@ public func testNonExhaustive(_ value: NonExhaustive, _ payload: NonExhaustivePa
}
switch payload {
// expected-error@-1 {{switch must be exhaustive}}
// expected-note@-2 {{add missing case: '.b(_)'}} {{+4:3-3=case .b(_):\n<#code#>\n}}
case .a: break
@unknown case _: break
}
switch payload {
// expected-error@-1 {{switch must be exhaustive}}
// expected-note@-2 {{add missing case: '.b(true)'}} {{+7:3-3=case .b(true):\n<#code#>\n}}
// expected-note@-3 {{handle unknown values using "@unknown default"}} {{+7:3-3=@unknown default:\n<#fatalError()#>\n}}
// expected-note@-4 {{add missing cases}} {{+7:3-3=case .b(true):\n<#code#>\n@unknown default:\n<#fatalError()#>\n}}
case .a: break
case .b(false): break
}
switch payload {
// expected-error@-1 {{switch must be exhaustive}}
// expected-note@-2 {{add missing case: '.b(true)'}} {{+5:3-3=case .b(true):\n<#code#>\n}}
case .a: break
case .b(false): break
@unknown case _: break

873
test/FixCode/fixits-switch-nonfrozen.swift.result
View File

@@ -1,873 +0,0 @@
// RUN: not %target-swift-frontend -emit-sil %s -emit-fixits-path %t.remap -enable-library-evolution -enable-nonfrozen-enum-exhaustivity-diagnostics -diagnostics-editor-mode
// RUN: c-arcmt-test %t.remap | arcmt-test -verify-transformed-files %s.result
enum Runcible {
case spoon
case hat
case fork
}
func checkDiagnosticMinimality(x: Runcible?) {
switch (x!, x!) {
case (.spoon, .spoon):
break
case (.spoon, .hat):
break
case (.hat, .spoon):
break
case (.fork, _):
<#code#>
case (.hat, .hat):
<#code#>
case (_, .fork):
<#code#>
}
switch (x!, x!) {
case (.spoon, .spoon):
break
case (.hat, .hat):
break
case (.fork, _):
<#code#>
case (.hat, .spoon):
<#code#>
case (.spoon, .hat):
<#code#>
case (_, .fork):
<#code#>
}
}
enum LargeSpaceEnum {
case case0
case case1
case case2
case case3
case case4
case case5
case case6
case case7
case case8
case case9
case case10
}
func notQuiteBigEnough() -> Bool {
switch (LargeSpaceEnum.case1, LargeSpaceEnum.case2) {
case (.case0, .case0): return true
case (.case1, .case1): return true
case (.case2, .case2): return true
case (.case3, .case3): return true
case (.case4, .case4): return true
case (.case5, .case5): return true
case (.case6, .case6): return true
case (.case7, .case7): return true
case (.case8, .case8): return true
case (.case9, .case9): return true
case (.case10, .case10): return true
case (.case10, .case0):
<#code#>
case (.case10, .case1):
<#code#>
case (.case10, .case2):
<#code#>
case (.case10, .case3):
<#code#>
case (.case10, .case4):
<#code#>
case (.case10, .case5):
<#code#>
case (.case10, .case6):
<#code#>
case (.case10, .case7):
<#code#>
case (.case10, .case8):
<#code#>
case (.case10, .case9):
<#code#>
case (.case9, .case0):
<#code#>
case (.case9, .case1):
<#code#>
case (.case9, .case2):
<#code#>
case (.case9, .case3):
<#code#>
case (.case9, .case4):
<#code#>
case (.case9, .case5):
<#code#>
case (.case9, .case6):
<#code#>
case (.case9, .case7):
<#code#>
case (.case9, .case8):
<#code#>
case (.case9, .case10):
<#code#>
case (.case8, .case0):
<#code#>
case (.case8, .case1):
<#code#>
case (.case8, .case2):
<#code#>
case (.case8, .case3):
<#code#>
case (.case8, .case4):
<#code#>
case (.case8, .case5):
<#code#>
case (.case8, .case6):
<#code#>
case (.case8, .case7):
<#code#>
case (.case8, .case9):
<#code#>
case (.case8, .case10):
<#code#>
case (.case7, .case0):
<#code#>
case (.case7, .case1):
<#code#>
case (.case7, .case2):
<#code#>
case (.case7, .case3):
<#code#>
case (.case7, .case4):
<#code#>
case (.case7, .case5):
<#code#>
case (.case7, .case6):
<#code#>
case (.case7, .case8):
<#code#>
case (.case7, .case9):
<#code#>
case (.case7, .case10):
<#code#>
case (.case6, .case0):
<#code#>
case (.case6, .case1):
<#code#>
case (.case6, .case2):
<#code#>
case (.case6, .case3):
<#code#>
case (.case6, .case4):
<#code#>
case (.case6, .case5):
<#code#>
case (.case6, .case7):
<#code#>
case (.case6, .case8):
<#code#>
case (.case6, .case9):
<#code#>
case (.case6, .case10):
<#code#>
case (.case5, .case0):
<#code#>
case (.case5, .case1):
<#code#>
case (.case5, .case2):
<#code#>
case (.case5, .case3):
<#code#>
case (.case5, .case4):
<#code#>
case (.case5, .case6):
<#code#>
case (.case5, .case7):
<#code#>
case (.case5, .case8):
<#code#>
case (.case5, .case9):
<#code#>
case (.case5, .case10):
<#code#>
case (.case4, .case0):
<#code#>
case (.case4, .case1):
<#code#>
case (.case4, .case2):
<#code#>
case (.case4, .case3):
<#code#>
case (.case4, .case5):
<#code#>
case (.case4, .case6):
<#code#>
case (.case4, .case7):
<#code#>
case (.case4, .case8):
<#code#>
case (.case4, .case9):
<#code#>
case (.case4, .case10):
<#code#>
case (.case3, .case0):
<#code#>
case (.case3, .case1):
<#code#>
case (.case3, .case2):
<#code#>
case (.case3, .case4):
<#code#>
case (.case3, .case5):
<#code#>
case (.case3, .case6):
<#code#>
case (.case3, .case7):
<#code#>
case (.case3, .case8):
<#code#>
case (.case3, .case9):
<#code#>
case (.case3, .case10):
<#code#>
case (.case2, .case0):
<#code#>
case (.case2, .case1):
<#code#>
case (.case2, .case3):
<#code#>
case (.case2, .case4):
<#code#>
case (.case2, .case5):
<#code#>
case (.case2, .case6):
<#code#>
case (.case2, .case7):
<#code#>
case (.case2, .case8):
<#code#>
case (.case2, .case9):
<#code#>
case (.case2, .case10):
<#code#>
case (.case1, .case0):
<#code#>
case (.case1, .case2):
<#code#>
case (.case1, .case3):
<#code#>
case (.case1, .case4):
<#code#>
case (.case1, .case5):
<#code#>
case (.case1, .case6):
<#code#>
case (.case1, .case7):
<#code#>
case (.case1, .case8):
<#code#>
case (.case1, .case9):
<#code#>
case (.case1, .case10):
<#code#>
case (.case0, .case1):
<#code#>
case (.case0, .case2):
<#code#>
case (.case0, .case3):
<#code#>
case (.case0, .case4):
<#code#>
case (.case0, .case5):
<#code#>
case (.case0, .case6):
<#code#>
case (.case0, .case7):
<#code#>
case (.case0, .case8):
<#code#>
case (.case0, .case9):
<#code#>
case (.case0, .case10):
<#code#>
}
}
enum OverlyLargeSpaceEnum {
case case0
case case1
case case2
case case3
case case4
case case5
case case6
case case7
case case8
case case9
case case10
case case11
}
enum ContainsOverlyLargeEnum {
case one(OverlyLargeSpaceEnum)
case two(OverlyLargeSpaceEnum)
case three(OverlyLargeSpaceEnum, OverlyLargeSpaceEnum)
}
func quiteBigEnough() -> Bool {
switch (OverlyLargeSpaceEnum.case1, OverlyLargeSpaceEnum.case2) {
case (.case0, .case0): return true
case (.case1, .case1): return true
case (.case2, .case2): return true
case (.case3, .case3): return true
case (.case4, .case4): return true
case (.case5, .case5): return true
case (.case6, .case6): return true
case (.case7, .case7): return true
case (.case8, .case8): return true
case (.case9, .case9): return true
case (.case10, .case10): return true
case (.case11, .case11): return true
case (.case11, .case0):
<#code#>
case (.case11, .case1):
<#code#>
case (.case11, .case2):
<#code#>
case (.case11, .case3):
<#code#>
case (.case11, .case4):
<#code#>
case (.case11, .case5):
<#code#>
case (.case11, .case6):
<#code#>
case (.case11, .case7):
<#code#>
case (.case11, .case8):
<#code#>
case (.case11, .case9):
<#code#>
case (.case11, .case10):
<#code#>
case (.case10, .case0):
<#code#>
case (.case10, .case1):
<#code#>
case (.case10, .case2):
<#code#>
case (.case10, .case3):
<#code#>
case (.case10, .case4):
<#code#>
case (.case10, .case5):
<#code#>
case (.case10, .case6):
<#code#>
case (.case10, .case7):
<#code#>
case (.case10, .case8):
<#code#>
case (.case10, .case9):
<#code#>
case (.case10, .case11):
<#code#>
case (.case9, .case0):
<#code#>
case (.case9, .case1):
<#code#>
case (.case9, .case2):
<#code#>
case (.case9, .case3):
<#code#>
case (.case9, .case4):
<#code#>
case (.case9, .case5):
<#code#>
case (.case9, .case6):
<#code#>
case (.case9, .case7):
<#code#>
case (.case9, .case8):
<#code#>
case (.case9, .case10):
<#code#>
case (.case9, .case11):
<#code#>
case (.case8, .case0):
<#code#>
case (.case8, .case1):
<#code#>
case (.case8, .case2):
<#code#>
case (.case8, .case3):
<#code#>
case (.case8, .case4):
<#code#>
case (.case8, .case5):
<#code#>
case (.case8, .case6):
<#code#>
case (.case8, .case7):
<#code#>
case (.case8, .case9):
<#code#>
case (.case8, .case10):
<#code#>
case (.case8, .case11):
<#code#>
case (.case7, .case0):
<#code#>
case (.case7, .case1):
<#code#>
case (.case7, .case2):
<#code#>
case (.case7, .case3):
<#code#>
case (.case7, .case4):
<#code#>
case (.case7, .case5):
<#code#>
case (.case7, .case6):
<#code#>
case (.case7, .case8):
<#code#>
case (.case7, .case9):
<#code#>
case (.case7, .case10):
<#code#>
case (.case7, .case11):
<#code#>
case (.case6, .case0):
<#code#>
case (.case6, .case1):
<#code#>
case (.case6, .case2):
<#code#>
case (.case6, .case3):
<#code#>
case (.case6, .case4):
<#code#>
case (.case6, .case5):
<#code#>
case (.case6, .case7):
<#code#>
case (.case6, .case8):
<#code#>
case (.case6, .case9):
<#code#>
case (.case6, .case10):
<#code#>
case (.case6, .case11):
<#code#>
case (.case5, .case0):
<#code#>
case (.case5, .case1):
<#code#>
case (.case5, .case2):
<#code#>
case (.case5, .case3):
<#code#>
case (.case5, .case4):
<#code#>
case (.case5, .case6):
<#code#>
case (.case5, .case7):
<#code#>
case (.case5, .case8):
<#code#>
case (.case5, .case9):
<#code#>
case (.case5, .case10):
<#code#>
case (.case5, .case11):
<#code#>
case (.case4, .case0):
<#code#>
case (.case4, .case1):
<#code#>
case (.case4, .case2):
<#code#>
case (.case4, .case3):
<#code#>
case (.case4, .case5):
<#code#>
case (.case4, .case6):
<#code#>
case (.case4, .case7):
<#code#>
case (.case4, .case8):
<#code#>
case (.case4, .case9):
<#code#>
case (.case4, .case10):
<#code#>
case (.case4, .case11):
<#code#>
case (.case3, .case0):
<#code#>
case (.case3, .case1):
<#code#>
case (.case3, .case2):
<#code#>
case (.case3, .case4):
<#code#>
case (.case3, .case5):
<#code#>
case (.case3, .case6):
<#code#>
case (.case3, .case7):
<#code#>
case (.case3, .case8):
<#code#>
case (.case3, .case9):
<#code#>
case (.case3, .case10):
<#code#>
case (.case3, .case11):
<#code#>
case (.case2, .case0):
<#code#>
case (.case2, .case1):
<#code#>
case (.case2, .case3):
<#code#>
case (.case2, .case4):
<#code#>
case (.case2, .case5):
<#code#>
case (.case2, .case6):
<#code#>
case (.case2, .case7):
<#code#>
case (.case2, .case8):
<#code#>
case (.case2, .case9):
<#code#>
case (.case2, .case10):
<#code#>
case (.case2, .case11):
<#code#>
case (.case1, .case0):
<#code#>
case (.case1, .case2):
<#code#>
case (.case1, .case3):
<#code#>
case (.case1, .case4):
<#code#>
case (.case1, .case5):
<#code#>
case (.case1, .case6):
<#code#>
case (.case1, .case7):
<#code#>
case (.case1, .case8):
<#code#>
case (.case1, .case9):
<#code#>
case (.case1, .case10):
<#code#>
case (.case1, .case11):
<#code#>
case (.case0, .case1):
<#code#>
case (.case0, .case2):
<#code#>
case (.case0, .case3):
<#code#>
case (.case0, .case4):
<#code#>
case (.case0, .case5):
<#code#>
case (.case0, .case6):
<#code#>
case (.case0, .case7):
<#code#>
case (.case0, .case8):
<#code#>
case (.case0, .case9):
<#code#>
case (.case0, .case10):
<#code#>
case (.case0, .case11):
<#code#>
}
switch (OverlyLargeSpaceEnum.case1, OverlyLargeSpaceEnum.case2) {
case (.case0, _): return true
case (.case1, _): return true
case (.case2, _): return true
case (.case3, _): return true
case (.case4, _): return true
case (.case5, _): return true
case (.case6, _): return true
case (.case7, _): return true
case (.case8, _): return true
case (.case9, _): return true
case (.case10, _): return true
case (.case11, _):
<#code#>
}
}
indirect enum InfinitelySized {
case one
case two
case recur(InfinitelySized)
case mutualRecur(MutuallyRecursive, InfinitelySized)
}
indirect enum MutuallyRecursive {
case one
case two
case recur(MutuallyRecursive)
case mutualRecur(InfinitelySized, MutuallyRecursive)
}
func infinitelySized() -> Bool {
switch (InfinitelySized.one, InfinitelySized.one) {
case (.one, .one): return true
case (.two, .two): return true
case (.recur(_), _):
<#code#>
case (.mutualRecur(_, _), _):
<#code#>
case (.two, .one):
<#code#>
case (.recur(_), .mutualRecur(_, _)):
<#code#>
case (.mutualRecur(_, _), .mutualRecur(_, _)):
<#code#>
case (.one, .two):
<#code#>
case (_, .recur(_)):
<#code#>
case (_, .mutualRecur(_, _)):
<#code#>
}
switch (MutuallyRecursive.one, MutuallyRecursive.one) {
case (.one, .one): return true
case (.two, .two): return true
case (.recur(_), _):
<#code#>
case (.mutualRecur(_, _), _):
<#code#>
case (.two, .one):
<#code#>
case (.recur(_), .mutualRecur(_, _)):
<#code#>
case (.mutualRecur(_, _), .mutualRecur(_, _)):
<#code#>
case (.one, .two):
<#code#>
case (_, .recur(_)):
<#code#>
case (_, .mutualRecur(_, _)):
<#code#>
}
}
public enum NonExhaustive {
case a, b
}
public enum NonExhaustivePayload {
case a(Int), b(Bool)
}
@frozen public enum TemporalProxy {
case seconds(Int)
case milliseconds(Int)
case microseconds(Int)
case nanoseconds(Int)
case never
}
// Inlineable code is considered "outside" the module and must include a default
// case.
@inlinable
public func testNonExhaustive(_ value: NonExhaustive, _ payload: NonExhaustivePayload, for interval: TemporalProxy, flag: Bool) {
switch value {
case .a: break
case .b:
<#code#>
@unknown default:
<#code#>
}
switch value {
case .a: break
case .b: break
@unknown default:
<#fatalError()#>
}
switch value {
case .a: break
case .b: break
default: break // no-warning
}
switch value {
case .a: break
case .b: break
@unknown case _: break // no-warning
}
switch value {
case .a: break
case .b:
<#code#>
@unknown case _: break
}
switch value {
case .a:
<#code#>
case .b:
<#code#>
@unknown case _: break
}
// Test being part of other spaces.
switch value as Optional {
case .a?: break
case .b?: break
case nil: break
case .some(_):
<#code#>
}
switch value as Optional {
case .a?: break
case .b?: break
case nil: break
@unknown case _: break
} // no-warning
switch value as Optional {
case _?: break
case nil: break
} // no-warning
switch (value, flag) {
case (.a, _): break
case (.b, false): break
case (_, true): break
case (_, false):
<#code#>
}
switch (value, flag) {
case (.a, _): break
case (.b, false): break
case (_, true): break
@unknown case _: break
} // no-warning
switch (flag, value) {
case (_, .a): break
case (false, .b): break
case (true, _): break
case (false, _):
<#code#>
}
switch (flag, value) {
case (_, .a): break
case (false, .b): break
case (true, _): break
@unknown case _: break
} // no-warning
switch (value, value) {
case (.a, _), (_, .a): break
case (.b, _), (_, .b): break
case (_, _):
<#code#>
}
switch (value, value) {
case (.a, _), (_, .a): break
case (.b, _), (_, .b): break
@unknown case _: break
} // no-warning
switch (value, interval) {
case (_, .seconds): break
case (.a, _): break
case (.b, _): break
case (_, .milliseconds(_)):
<#code#>
case (_, .microseconds(_)):
<#code#>
case (_, .nanoseconds(_)):
<#code#>
case (_, .never):
<#code#>
}
switch (value, interval) {
case (_, .never): break
case (.a, _): break
case (.b, _): break
case (_, .seconds(_)):
<#code#>
case (_, .milliseconds(_)):
<#code#>
case (_, .microseconds(_)):
<#code#>
case (_, .nanoseconds(_)):
<#code#>
}
// Test payloaded enums.
switch payload {
case .a: break
case .b(_):
<#code#>
@unknown default:
<#code#>
}
switch payload {
case .a: break
case .b: break
@unknown default:
<#fatalError()#>
}
switch payload {
case .a: break
case .b: break
default: break // no-warning
}
switch payload {
case .a: break
case .b: break
@unknown case _: break // no-warning
}
switch payload {
case .a: break
case .b(_):
<#code#>
@unknown case _: break
}
switch payload {
case .a: break
case .b(false): break
case .b(true):
<#code#>
@unknown default:
<#code#>
}
switch payload {
case .a: break
case .b(false): break
case .b(true):
<#code#>
@unknown case _: break
}
}

47
test/FixCode/fixits-switch.swift
View File

@@ -1,5 +1,4 @@
// RUN: not %swift -emit-sil -target %target-triple %s -emit-fixits-path %t.remap -I %S/Inputs -diagnostics-editor-mode
// RUN: c-arcmt-test %t.remap | arcmt-test -verify-transformed-files %s.result
// RUN: %target-swift-frontend -emit-sil %s -I %S/Inputs -diagnostics-editor-mode -verify
enum E1 : Int {
case e1
@@ -10,6 +9,11 @@ enum E1 : Int {
func foo1(_ e : E1) -> Int {
switch(e) {
// expected-error@-1 {{switch must be exhaustive}}
// expected-note@-2 {{add missing case: '.e2'}} {{+8:3-3=case .e2:\n<#code#>\n}}
// expected-note@-3 {{add missing case: '.e3'}} {{+8:3-3=case .e3:\n<#code#>\n}}
// expected-note@-4 {{add missing case: '.e4'}} {{+8:3-3=case .e4:\n<#code#>\n}}
// expected-note@-5 {{add missing cases}} {{+8:3-3=case .e2:\n<#code#>\ncase .e3:\n<#code#>\ncase .e4:\n<#code#>\n}}
case .e1:
return 1
}
@@ -17,6 +21,8 @@ func foo1(_ e : E1) -> Int {
func foo2(_ i : Int) -> Int {
switch i {
// expected-error@-1 {{switch must be exhaustive}}
// expected-note@-2 {{add a default clause}} {{+5:3-3=default:\n<#code#>\n}}
case 1:
return 1
}
@@ -24,6 +30,8 @@ func foo2(_ i : Int) -> Int {
func foo3(_ c : Character) -> Character {
switch c {
// expected-error@-1 {{switch must be exhaustive}}
// expected-note@-2 {{add a default clause}} {{+5:3-3=default:\n<#code#>\n}}
case "a":
return "a"
}
@@ -43,6 +51,16 @@ enum E2 {
func foo4(_ e : E2) -> Int {
switch e {
// expected-error@-1 {{switch must be exhaustive}}
// expected-note@-2 {{add missing case: '.e1(a: let a, s: let s)'}} {{+13:3-3=case .e1(a: let a, s: let s):\n<#code#>\n}}
// expected-note@-3 {{add missing case: '.e3(a: let a)'}} {{+13:3-3=case .e3(a: let a):\n<#code#>\n}}
// expected-note@-4 {{add missing case: '.e4(_)'}} {{+13:3-3=case .e4(_):\n<#code#>\n}}
// expected-note@-5 {{add missing case: '.e5(_, _)'}} {{+13:3-3=case .e5(_, _):\n<#code#>\n}}
// expected-note@-6 {{add missing case: '.e6(a: let a, _)'}} {{+13:3-3=case .e6(a: let a, _):\n<#code#>\n}}
// expected-note@-7 {{add missing case: '.e7'}} {{+13:3-3=case .e7:\n<#code#>\n}}
// expected-note@-8 {{add missing case: '.e8(a: let a, _, _)'}} {{+13:3-3=case .e8(a: let a, _, _):\n<#code#>\n}}
// expected-note@-9 {{add missing case: '.e9(_, _, _)'}} {{+13:3-3=case .e9(_, _, _):\n<#code#>\n}}
// expected-note@-10 {{add missing cases}} {{+13:3-3=case .e1(a: let a, s: let s):\n<#code#>\ncase .e3(a: let a):\n<#code#>\ncase .e4(_):\n<#code#>\ncase .e5(_, _):\n<#code#>\ncase .e6(a: let a, _):\n<#code#>\ncase .e7:\n<#code#>\ncase .e8(a: let a, _, _):\n<#code#>\ncase .e9(_, _, _):\n<#code#>\n}}
case .e2:
return 1
}
@@ -50,6 +68,12 @@ func foo4(_ e : E2) -> Int {
func foo5(_ e : E1) -> Int {
switch e {
// expected-error@-1 {{switch must be exhaustive}}
// expected-note@-2 {{add missing case: '.e1'}} {{+9:3-3=case .e1:\n<#code#>\n}}
// expected-note@-3 {{add missing case: '.e2'}} {{+9:3-3=case .e2:\n<#code#>\n}}
// expected-note@-4 {{add missing case: '.e3'}} {{+9:3-3=case .e3:\n<#code#>\n}}
// expected-note@-5 {{add missing case: '.e4'}} {{+9:3-3=case .e4:\n<#code#>\n}}
// expected-note@-6 {{add missing cases}} {{+9:3-3=case .e1:\n<#code#>\ncase .e2:\n<#code#>\ncase .e3:\n<#code#>\ncase .e4:\n<#code#>\n}}
case _ where e.rawValue > 0:
return 1
}
@@ -57,6 +81,16 @@ func foo5(_ e : E1) -> Int {
func foo6(_ e : E2) -> Int {
switch e {
// expected-error@-1 {{switch must be exhaustive}}
// expected-note@-2 {{add missing case: '.e2(a: let a)'}} {{+13:3-3=case .e2(a: let a):\n<#code#>\n}}
// expected-note@-3 {{add missing case: '.e3(a: let a)'}} {{+13:3-3=case .e3(a: let a):\n<#code#>\n}}
// expected-note@-4 {{add missing case: '.e4(_)'}} {{+13:3-3=case .e4(_):\n<#code#>\n}}
// expected-note@-5 {{add missing case: '.e5(_, _)'}} {{+13:3-3=case .e5(_, _):\n<#code#>\n}}
// expected-note@-6 {{add missing case: '.e6(a: let a, _)'}} {{+13:3-3=case .e6(a: let a, _):\n<#code#>\n}}
// expected-note@-7 {{add missing case: '.e7'}} {{+13:3-3=case .e7:\n<#code#>\n}}
// expected-note@-8 {{add missing case: '.e8(a: let a, _, _)'}} {{+13:3-3=case .e8(a: let a, _, _):\n<#code#>\n}}
// expected-note@-9 {{add missing case: '.e9(_, _, _)'}} {{+13:3-3=case .e9(_, _, _):\n<#code#>\n}}
// expected-note@-10 {{add missing cases}} {{+13:3-3=case .e2(a: let a):\n<#code#>\ncase .e3(a: let a):\n<#code#>\ncase .e4(_):\n<#code#>\ncase .e5(_, _):\n<#code#>\ncase .e6(a: let a, _):\n<#code#>\ncase .e7:\n<#code#>\ncase .e8(a: let a, _, _):\n<#code#>\ncase .e9(_, _, _):\n<#code#>\n}}
case let .e1(x, y):
return x + y
}
@@ -64,6 +98,15 @@ func foo6(_ e : E2) -> Int {
func foo7(_ e : E2) -> Int {
switch e {
// expected-error@-1 {{switch must be exhaustive}}
// expected-note@-2 {{add missing case: '.e2(a: let a)'}} {{+13:3-3=case .e2(a: let a):\n<#code#>\n}}
// expected-note@-3 {{add missing case: '.e4(_)'}} {{+13:3-3=case .e4(_):\n<#code#>\n}}
// expected-note@-4 {{add missing case: '.e5(_, _)'}} {{+13:3-3=case .e5(_, _):\n<#code#>\n}}
// expected-note@-5 {{add missing case: '.e6(a: let a, _)'}} {{+13:3-3=case .e6(a: let a, _):\n<#code#>\n}}
// expected-note@-6 {{add missing case: '.e7'}} {{+13:3-3=case .e7:\n<#code#>\n}}
// expected-note@-7 {{add missing case: '.e8(a: let a, _, _)'}} {{+13:3-3=case .e8(a: let a, _, _):\n<#code#>\n}}
// expected-note@-8 {{add missing case: '.e9(_, _, _)'}} {{+13:3-3=case .e9(_, _, _):\n<#code#>\n}}
// expected-note@-9 {{add missing cases}} {{+13:3-3=case .e2(a: let a):\n<#code#>\ncase .e4(_):\n<#code#>\ncase .e5(_, _):\n<#code#>\ncase .e6(a: let a, _):\n<#code#>\ncase .e7:\n<#code#>\ncase .e8(a: let a, _, _):\n<#code#>\ncase .e9(_, _, _):\n<#code#>\n}}
case .e2(1): return 0
case .e1: return 0
case .e3: return 0

135
test/FixCode/fixits-switch.swift.result
View File

@@ -1,135 +0,0 @@
// RUN: not %swift -emit-sil -target %target-triple %s -emit-fixits-path %t.remap -I %S/Inputs -diagnostics-editor-mode
// RUN: c-arcmt-test %t.remap | arcmt-test -verify-transformed-files %s.result
enum E1 : Int {
case e1
case e2
case e3
case e4
}
func foo1(_ e : E1) -> Int {
switch(e) {
case .e1:
return 1
case .e2:
<#code#>
case .e3:
<#code#>
case .e4:
<#code#>
}
}
func foo2(_ i : Int) -> Int {
switch i {
case 1:
return 1
default:
<#code#>
}
}
func foo3(_ c : Character) -> Character {
switch c {
case "a":
return "a"
default:
<#code#>
}
}
enum E2 {
case e1(a: Int, s: Int)
case e2(a: Int)
case e3(a: Int)
case e4(_: Int)
case e5(_: Int, _: Int)
case e6(a : Int, _: Int)
case e7
case e8(a : Int, Int, Int)
case e9(Int, Int, Int)
}
func foo4(_ e : E2) -> Int {
switch e {
case .e2:
return 1
case .e1(a: let a, s: let s):
<#code#>
case .e3(a: let a):
<#code#>
case .e4(_):
<#code#>
case .e5(_, _):
<#code#>
case .e6(a: let a, _):
<#code#>
case .e7:
<#code#>
case .e8(a: let a, _, _):
<#code#>
case .e9(_, _, _):
<#code#>
}
}
func foo5(_ e : E1) -> Int {
switch e {
case _ where e.rawValue > 0:
return 1
case .e1:
<#code#>
case .e2:
<#code#>
case .e3:
<#code#>
case .e4:
<#code#>
}
}
func foo6(_ e : E2) -> Int {
switch e {
case let .e1(x, y):
return x + y
case .e2(a: let a):
<#code#>
case .e3(a: let a):
<#code#>
case .e4(_):
<#code#>
case .e5(_, _):
<#code#>
case .e6(a: let a, _):
<#code#>
case .e7:
<#code#>
case .e8(a: let a, _, _):
<#code#>
case .e9(_, _, _):
<#code#>
}
}
func foo7(_ e : E2) -> Int {
switch e {
case .e2(1): return 0
case .e1: return 0
case .e3: return 0
case .e2(a: let a):
<#code#>
case .e4(_):
<#code#>
case .e5(_, _):
<#code#>
case .e6(a: let a, _):
<#code#>
case .e7:
<#code#>
case .e8(a: let a, _, _):
<#code#>
case .e9(_, _, _):
<#code#>
}
}

2
test/Parse/matching_patterns.swift
View File

@@ -166,6 +166,7 @@ struct ContainsEnum {
switch n { // expected-error {{switch must be exhaustive}}
// expected-note@-1 {{missing case: '.Mere(_)'}}
// expected-note@-2 {{missing case: '.Twain(_, _)'}}
// expected-note@-3 {{add missing cases}}
case ContainsEnum.Possible<Int>.Naught,
ContainsEnum.Possible.Naught, // expected-warning {{case is already handled by previous patterns; consider removing it}}
Possible<Int>.Naught, // expected-warning {{case is already handled by previous patterns; consider removing it}}
@@ -180,6 +181,7 @@ func nonmemberAccessesMemberType(_ n: ContainsEnum.Possible<Int>) {
switch n { // expected-error {{switch must be exhaustive}}
// expected-note@-1 {{missing case: '.Mere(_)'}}
// expected-note@-2 {{missing case: '.Twain(_, _)'}}
// expected-note@-3 {{add missing cases}}
case ContainsEnum.Possible<Int>.Naught,
.Naught: // expected-warning {{case is already handled by previous patterns; consider removing it}}
()

2
test/Parse/matching_patterns_reference_bindings.swift
View File

@@ -184,6 +184,7 @@ struct ContainsEnum {
switch n { // expected-error {{switch must be exhaustive}}
// expected-note@-1 {{missing case: '.Mere(_)'}}
// expected-note@-2 {{missing case: '.Twain(_, _)'}}
// expected-note@-3 {{add missing cases}}
case ContainsEnum.Possible<Int>.Naught,
ContainsEnum.Possible.Naught, // expected-warning {{case is already handled by previous patterns; consider removing it}}
Possible<Int>.Naught, // expected-warning {{case is already handled by previous patterns; consider removing it}}
@@ -198,6 +199,7 @@ func nonmemberAccessesMemberType(_ n: ContainsEnum.Possible<Int>) {
switch n { // expected-error {{switch must be exhaustive}}
// expected-note@-1 {{missing case: '.Mere(_)'}}
// expected-note@-2 {{missing case: '.Twain(_, _)'}}
// expected-note@-3 {{add missing cases}}
case ContainsEnum.Possible<Int>.Naught,
.Naught: // expected-warning {{case is already handled by previous patterns; consider removing it}}
()

60
test/Sema/exhaustive_switch.swift
View File

@@ -406,6 +406,7 @@ func checkDiagnosticMinimality(x: Runcible?) {
// expected-note@-1 {{add missing case: '(.fork, _)'}}
// expected-note@-2 {{add missing case: '(.hat, .hat)'}}
// expected-note@-3 {{add missing case: '(_, .fork)'}}
// expected-note@-4 {{add missing cases}}
case (.spoon, .spoon):
break
case (.spoon, .hat):
@@ -419,6 +420,7 @@ func checkDiagnosticMinimality(x: Runcible?) {
// expected-note@-2 {{add missing case: '(.hat, .spoon)'}}
// expected-note@-3 {{add missing case: '(.spoon, .hat)'}}
// expected-note@-4 {{add missing case: '(_, .fork)'}}
// expected-note@-5 {{add missing cases}}
case (.spoon, .spoon):
break
case (.hat, .hat):
@@ -443,12 +445,14 @@ indirect enum MutuallyRecursive {
func infinitelySized() -> Bool {
switch (InfinitelySized.one, InfinitelySized.one) { // expected-error {{switch must be exhaustive}}
// expected-note@-1 8 {{add missing case:}}
// expected-note@-2 {{add missing cases}}
case (.one, .one): return true
case (.two, .two): return true
}
switch (MutuallyRecursive.one, MutuallyRecursive.one) { // expected-error {{switch must be exhaustive}}
// expected-note@-1 8 {{add missing case:}}
// expected-note@-2 {{add missing cases}}
case (.one, .one): return true
case (.two, .two): return true
}
@@ -470,6 +474,7 @@ do {
// expected-error@-1 {{switch must be exhaustive}}
// expected-note@-2 {{add missing case: '(false, (_, false, true, _), (_, true, _, _))'}}
// expected-note@-3 {{add missing case: '(_, (_, true, _, _), (_, false, true, _))'}}
// expected-note@-4 {{add missing cases}}
case (true, (_, _, _, _), (_, true, true, _)):
break
case (true, (_, _, _, _), (_, _, false, _)):
@@ -807,11 +812,15 @@ public enum NonExhaustivePayload {
// case.
@inlinable
public func testNonExhaustive(_ value: NonExhaustive, _ payload: NonExhaustivePayload, for interval: TemporalProxy, flag: Bool) {
switch value { // expected-error {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b'}} {{none}} expected-note {{handle unknown values using "@unknown default"}} {{none}}
switch value {
// expected-error@-1 {{switch must be exhaustive}} {{none}}
// expected-note@-2 {{add missing case: '.b'}} {{+6:3-3=case .b:\n<#code#>\n}}
// expected-note@-3 {{handle unknown values using "@unknown default"}} {{+6:3-3=@unknown default:\n<#fatalError()#>\n}}
// expected-note@-4 {{add missing cases}} {{+6:3-3=case .b:\n<#code#>\n@unknown default:\n<#fatalError()#>\n}}
case .a: break
}
switch value { // expected-warning {{switch covers known cases, but 'NonExhaustive' may have additional unknown values}} {{none}} expected-note {{handle unknown values using "@unknown default"}} {{+3:3-3=@unknown default:\n<#fatalError#>()\n}}
switch value { // expected-warning {{switch covers known cases, but 'NonExhaustive' may have additional unknown values}} {{none}} expected-note {{handle unknown values using "@unknown default"}} {{+3:3-3=@unknown default:\n<#fatalError()#>\n}}
case .a: break
case .b: break
}
@@ -828,12 +837,16 @@ public func testNonExhaustive(_ value: NonExhaustive, _ payload: NonExhaustivePa
@unknown case _: break // no-warning
}
switch value { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b'}} {{none}}
switch value { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b'}} {{+2:3-3=case .b:\n<#code#>\n}}
case .a: break
@unknown case _: break
}
switch value { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.a'}} {{none}} expected-note {{add missing case: '.b'}} {{none}}
switch value {
// expected-warning@-1 {{switch must be exhaustive}} {{none}}
// expected-note@-2 {{add missing case: '.a'}} {{+5:3-3=case .a:\n<#code#>\n}}
// expected-note@-3 {{add missing case: '.b'}} {{+5:3-3=case .b:\n<#code#>\n}}
// expected-note@-4 {{add missing cases}} {{+5:3-3=case .a:\n<#code#>\ncase .b:\n<#code#>\n}}
@unknown case _: break
}
@@ -899,11 +912,15 @@ public func testNonExhaustive(_ value: NonExhaustive, _ payload: NonExhaustivePa
} // no-warning
// Test payloaded enums.
switch payload { // expected-error {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(_)'}} {{none}} expected-note {{handle unknown values using "@unknown default"}} {{none}}
switch payload {
// expected-error@-1 {{switch must be exhaustive}} {{none}}
// expected-note@-2 {{add missing case: '.b(_)'}} {{+6:3-3=case .b(_):\n<#code#>\n}}
// expected-note@-3 {{handle unknown values using "@unknown default"}} {{+6:3-3=@unknown default:\n<#fatalError()#>\n}}
// expected-note@-4 {{add missing cases}} {{+6:3-3=case .b(_):\n<#code#>\n@unknown default:\n<#fatalError()#>\n}}
case .a: break
}
switch payload { // expected-warning {{switch covers known cases, but 'NonExhaustivePayload' may have additional unknown values}} {{none}} expected-note {{handle unknown values using "@unknown default"}} {{+3:3-3=@unknown default:\n<#fatalError#>()\n}}
switch payload { // expected-warning {{switch covers known cases, but 'NonExhaustivePayload' may have additional unknown values}} {{none}} expected-note {{handle unknown values using "@unknown default"}} {{+3:3-3=@unknown default:\n<#fatalError()#>\n}}
case .a: break
case .b: break
}
@@ -920,17 +937,21 @@ public func testNonExhaustive(_ value: NonExhaustive, _ payload: NonExhaustivePa
@unknown case _: break // no-warning
}
switch payload { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(_)'}} {{none}}
switch payload { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(_)'}} {{+2:3-3=case .b(_):\n<#code#>\n}}
case .a: break
@unknown case _: break
}
switch payload { // expected-error {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(true)'}} {{none}} expected-note {{handle unknown values using "@unknown default"}} {{none}}
switch payload {
// expected-error@-1 {{switch must be exhaustive}} {{none}}
// expected-note@-2 {{add missing case: '.b(true)'}} {{+7:3-3=case .b(true):\n<#code#>\n}}
// expected-note@-3 {{handle unknown values using "@unknown default"}} {{+7:3-3=@unknown default:\n<#fatalError()#>\n}}
// expected-note@-4 {{add missing cases}} {{+7:3-3=case .b(true):\n<#code#>\n@unknown default:\n<#fatalError()#>\n}}
case .a: break
case .b(false): break
}
switch payload { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(true)'}} {{none}}
switch payload { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(true)'}} {{+3:3-3=case .b(true):\n<#code#>\n}}
case .a: break
case .b(false): break
@unknown case _: break
@@ -984,12 +1005,16 @@ public func testNonExhaustiveWithinModule(_ value: NonExhaustive, _ payload: Non
@unknown case _: break // no-warning
}
switch value { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b'}} {{none}}
switch value { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b'}} {{+2:3-3=case .b:\n<#code#>\n}}
case .a: break
@unknown case _: break
}
switch value { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.a'}} {{none}} expected-note {{add missing case: '.b'}} {{none}}
switch value {
// expected-warning@-1 {{switch must be exhaustive}} {{none}}
// expected-note@-2 {{add missing case: '.a'}} {{+5:3-3=case .a:\n<#code#>\n}}
// expected-note@-3 {{add missing case: '.b'}} {{+5:3-3=case .b:\n<#code#>\n}}
// expected-note@-4 {{add missing cases}} {{+5:3-3=case .a:\n<#code#>\ncase .b:\n<#code#>\n}}
@unknown case _: break
}
@@ -1038,7 +1063,7 @@ public func testNonExhaustiveWithinModule(_ value: NonExhaustive, _ payload: Non
}
// Test payloaded enums.
switch payload { // expected-error {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(_)'}} {{none}}
switch payload { // expected-error {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(_)'}} {{+2:3-3=case .b(_):\n<#code#>\n}}
case .a: break
}
@@ -1059,17 +1084,17 @@ public func testNonExhaustiveWithinModule(_ value: NonExhaustive, _ payload: Non
@unknown case _: break // no-warning
}
switch payload { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(_)'}} {{none}}
switch payload { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(_)'}} {{+2:3-3=case .b(_):\n<#code#>\n}}
case .a: break
@unknown case _: break
}
switch payload { // expected-error {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(true)'}} {{none}}
switch payload { // expected-error {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(true)'}} {{+3:3-3=case .b(true):\n<#code#>\n}}
case .a: break
case .b(false): break
}
switch payload { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(true)'}} {{none}}
switch payload { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(true)'}} {{+3:3-3=case .b(true):\n<#code#>\n}}
case .a: break
case .b(false): break
@unknown case _: break
@@ -1236,6 +1261,7 @@ public enum E_54081 {
// expected-error@-1 {{switch must be exhaustive}}
// expected-note@-2 {{add missing case: '.a'}}
// expected-note@-3 {{add missing case: '.b'}}
// expected-note@-4 {{add missing cases}}
// Do not suggest adding '@unknown default'
}
@@ -1244,12 +1270,14 @@ public enum E_54081 {
// expected-note@-2 {{add missing case: '.a'}}
// expected-note@-3 {{add missing case: '.b'}}
// expected-note@-4 {{add missing case: '.c'}}
// expected-note@-5 {{add missing cases}}
}
switch value3 {
// expected-error@-1 {{switch must be exhaustive}}
// expected-note@-2 {{add missing case: '.a'}}
// expected-note@-3 {{add missing case: '.b'}}
// expected-note@-4 {{add missing cases}}
}
}
@@ -1258,6 +1286,7 @@ public enum E_54081 {
// expected-error@-1 {{switch must be exhaustive}}
// expected-note@-2 {{add missing case: '.a'}}
// expected-note@-3 {{add missing case: '.b'}}
// expected-note@-4 {{add missing cases}}
}
}
@@ -1269,6 +1298,7 @@ public enum E_54081 {
// expected-note@-2 {{add missing case: '.a'}}
// expected-note@-3 {{add missing case: '.b'}}
// expected-note@-4 {{handle unknown values using "@unknown default"}}
// expected-note@-5 {{add missing cases}}
}
}
}

46
test/Sema/exhaustive_switch_debugger.swift
View File

@@ -13,7 +13,11 @@ public enum NonExhaustivePayload {
// case.
@inlinable
public func testNonExhaustive(_ value: NonExhaustive, _ payload: NonExhaustivePayload, flag: Bool) {
switch value { // expected-error {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b'}} {{none}} expected-note {{handle unknown values using "@unknown default"}} {{none}}
switch value {
// expected-error@-1 {{switch must be exhaustive}} {{none}}
// expected-note@-2 {{add missing case: '.b'}} {{+6:3-3=case .b:\n<#code#>\n}}
// expected-note@-3 {{handle unknown values using "@unknown default"}} {{+6:3-3=@unknown default:\n<#fatalError()#>\n}}
// expected-note@-4 {{add missing cases}} {{+6:3-3=case .b:\n<#code#>\n@unknown default:\n<#fatalError()#>\n}}
case .a: break
}
@@ -34,12 +38,16 @@ public func testNonExhaustive(_ value: NonExhaustive, _ payload: NonExhaustivePa
@unknown case _: break // no-warning
}
switch value { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b'}} {{none}}
switch value { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b'}} {{+2:3-3=case .b:\n<#code#>\n}}
case .a: break
@unknown case _: break
}
switch value { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.a'}} {{none}} expected-note {{add missing case: '.b'}} {{none}}
switch value {
// expected-warning@-1 {{switch must be exhaustive}} {{none}}
// expected-note@-2 {{add missing case: '.a'}} {{+5:3-3=case .a:\n<#code#>\n}}
// expected-note@-3 {{add missing case: '.b'}} {{+5:3-3=case .b:\n<#code#>\n}}
// expected-note@-4 {{add missing cases}} {{+5:3-3=case .a:\n<#code#>\ncase .b:\n<#code#>\n}}
@unknown case _: break
}
@@ -73,7 +81,11 @@ public func testNonExhaustive(_ value: NonExhaustive, _ payload: NonExhaustivePa
}
// Test payloaded enums.
switch payload { // expected-error {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(_)'}} {{none}} expected-note {{handle unknown values using "@unknown default"}} {{none}}
switch payload {
// expected-error@-1 {{switch must be exhaustive}} {{none}}
// expected-note@-2 {{add missing case: '.b(_)'}} {{+6:3-3=case .b(_):\n<#code#>\n}}
// expected-note@-3 {{handle unknown values using "@unknown default"}} {{+6:3-3=@unknown default:\n<#fatalError()#>\n}}
// expected-note@-4 {{add missing cases}} {{+6:3-3=case .b(_):\n<#code#>\n@unknown default:\n<#fatalError()#>\n}}
case .a: break
}
@@ -94,17 +106,21 @@ public func testNonExhaustive(_ value: NonExhaustive, _ payload: NonExhaustivePa
@unknown case _: break // no-warning
}
switch payload { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(_)'}} {{none}}
switch payload { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(_)'}} {{+2:3-3=case .b(_):\n<#code#>\n}}
case .a: break
@unknown case _: break
}
switch payload { // expected-error {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(true)'}} {{none}} expected-note {{handle unknown values using "@unknown default"}} {{none}}
switch payload {
// expected-error@-1 {{switch must be exhaustive}} {{none}}
// expected-note@-2 {{add missing case: '.b(true)'}} {{+7:3-3=case .b(true):\n<#code#>\n}}
// expected-note@-3 {{handle unknown values using "@unknown default"}} {{+7:3-3=@unknown default:\n<#fatalError()#>\n}}
// expected-note@-4 {{add missing cases}} {{+7:3-3=case .b(true):\n<#code#>\n@unknown default:\n<#fatalError()#>\n}}
case .a: break
case .b(false): break
}
switch payload { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(true)'}} {{none}}
switch payload { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(true)'}} {{+3:3-3=case .b(true):\n<#code#>\n}}
case .a: break
case .b(false): break
@unknown case _: break
@@ -133,12 +149,16 @@ public func testNonExhaustiveWithinModule(_ value: NonExhaustive, _ payload: Non
@unknown case _: break // no-warning
}
switch value { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b'}} {{none}}
switch value { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b'}} {{+2:3-3=case .b:\n<#code#>\n}}
case .a: break
@unknown case _: break
}
switch value { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.a'}} {{none}} expected-note {{add missing case: '.b'}} {{none}}
switch value {
// expected-warning@-1 {{switch must be exhaustive}} {{none}}
// expected-note@-2 {{add missing case: '.a'}} {{+5:3-3=case .a:\n<#code#>\n}}
// expected-note@-3 {{add missing case: '.b'}} {{+5:3-3=case .b:\n<#code#>\n}}
// expected-note@-4 {{add missing cases}} {{+5:3-3=case .a:\n<#code#>\ncase .b:\n<#code#>\n}}
@unknown case _: break
}
@@ -172,7 +192,7 @@ public func testNonExhaustiveWithinModule(_ value: NonExhaustive, _ payload: Non
}
// Test payloaded enums.
switch payload { // expected-error {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(_)'}} {{none}}
switch payload { // expected-error {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(_)'}} {{+2:3-3=case .b(_):\n<#code#>\n}}
case .a: break
}
@@ -193,17 +213,17 @@ public func testNonExhaustiveWithinModule(_ value: NonExhaustive, _ payload: Non
@unknown case _: break // no-warning
}
switch payload { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(_)'}} {{none}}
switch payload { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(_)'}} {{+2:3-3=case .b(_):\n<#code#>\n}}
case .a: break
@unknown case _: break
}
switch payload { // expected-error {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(true)'}} {{none}}
switch payload { // expected-error {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(true)'}} {{+3:3-3=case .b(true):\n<#code#>\n}}
case .a: break
case .b(false): break
}
switch payload { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(true)'}} {{none}}
switch payload { // expected-warning {{switch must be exhaustive}} {{none}} expected-note {{add missing case: '.b(true)'}} {{+3:3-3=case .b(true):\n<#code#>\n}}
case .a: break
case .b(false): break
@unknown case _: break

2
test/expr/unary/switch_expr.swift
View File

@@ -550,6 +550,7 @@ _ = (switch Bool.random() {
// expected-error@-2 {{switch must be exhaustive}}
// expected-note@-3 {{add missing case: 'true'}}
// expected-note@-4 {{add missing case: 'false'}}
// expected-note@-5 {{add missing cases}}
#if FOO
case true:
0
@@ -564,6 +565,7 @@ _ = (switch Bool.random() {
// expected-error@-2 {{switch must be exhaustive}}
// expected-note@-3 {{add missing case: 'true'}}
// expected-note@-4 {{add missing case: 'false'}}
// expected-note@-5 {{add missing cases}}
#if FOO
case true:
0

11
test/stmt/nonexhaustive_switch_stmt_editor.swift
View File

@@ -9,7 +9,9 @@ public enum NonExhaustive {
@inlinable
public func testNonExhaustive(_ value: NonExhaustive) {
switch value { // expected-error {{switch must be exhaustive}}
// expected-note@-1 {{add missing cases}}
// expected-note@-1 {{add missing case: '.b'}}
// expected-note@-2 {{handle unknown values using "@unknown default"}}
// expected-note@-3 {{add missing cases}}
case .a: break
}
@@ -20,9 +22,12 @@ public func testNonExhaustive(_ value: NonExhaustive) {
case .b: break
}
// expected-error@+2 {{switch must be exhaustive}}
// expected-note@+1 {{add missing cases}} {{+1:3-3=case .a:\n<#code#>\ncase .b:\n<#code#>\n@unknown default:\n<#code#>\n}}
switch value {
// expected-error@-1 {{switch must be exhaustive}}
// expected-note@-2 {{add missing case: '.a'}} {{+6:3-3=case .a:\n<#code#>\n}}
// expected-note@-3 {{add missing case: '.b'}} {{+6:3-3=case .b:\n<#code#>\n}}
// expected-note@-4 {{handle unknown values using "@unknown default"}} {{+6:3-3=@unknown default:\n<#fatalError()#>\n}}
// expected-note@-5 {{add missing cases}} {{+6:3-3=case .a:\n<#code#>\ncase .b:\n<#code#>\n@unknown default:\n<#fatalError()#>\n}}
}
switch value {

1
test/stmt/rdar40400251.swift
View File

@@ -31,6 +31,7 @@ func bar(_ e: E2) {
// expected-error@-1 {{switch must be exhaustive}}
// expected-note@-2 {{add missing case: '.bar(_)'}}
// expected-note@-3 {{add missing case: '.baz'}}
// expected-note@-4 {{add missing cases}}
case .foo((_, _, _)): break
}

1
test/stmt/statements.swift
View File

@@ -498,6 +498,7 @@ func r25178926(_ a : Type) {
switch a { // expected-error {{switch must be exhaustive}}
// expected-note@-1 {{missing case: '.Foo'}}
// expected-note@-2 {{missing case: '.Bar'}}
// expected-note@-3 {{add missing cases}}
case .Foo where 1 != 100, .Bar where 1 != 100:
break
}

5
test/stmt/switch_stmt1.swift
View File

@@ -7,7 +7,8 @@ enum E {
func foo1(e : E, i : Int) {
switch e {} // expected-error{{switch must be exhaustive}}
// expected-note@-1 {{missing case: '.e1'}}
// expected-note@-2 {{missing case: '.e2'}}
// expected-note@-1 {{add missing cases}}{{13-13=case .e1:\n<#code#>\ncase .e2:\n<#code#>\n}}
// expected-note@-2 {{missing case: '.e1'}}
// expected-note@-3 {{missing case: '.e2'}}
switch i {} // expected-error{{'switch' statement body must have at least one 'case' or 'default' block; add a default case}}{{13-13=default:\n<#code#>\n}}
}

4
test/stmt/switch_stmt2.swift
View File

@@ -13,8 +13,8 @@ func foo1(e : E) {
}
func foo2(i : Int) {
// expected-note@+1{{add a default clause}}{{+2:3-3=default:\n<#code#>\n}}
switch i { // expected-error{{switch must be exhaustive}}
// expected-note@-1{{add a default clause}}{{+3:3-3=default:\n<#code#>\n}}
case 1: return
}
}
@@ -100,6 +100,7 @@ func testSwitchEnumBoolTuple(_ b1: Bool, b2: Bool, xi: Int) -> Int {
switch Cond { // expected-error{{switch must be exhaustive}}
// expected-note@-1 {{add missing case: '(false, _)'}}
// expected-note@-2 {{add missing case: '(_, false)'}}
// expected-note@-3 {{add missing cases}}
case (true, true):
x += 1
}
@@ -107,6 +108,7 @@ func testSwitchEnumBoolTuple(_ b1: Bool, b2: Bool, xi: Int) -> Int {
switch Cond { // expected-error{{switch must be exhaustive}}
// expected-note@-1 {{add missing case: '(true, _)'}}
// expected-note@-2 {{add missing case: '(_, false)'}}
// expected-note@-3 {{add missing cases}}
case (false, true):
x += 1
}

12
test/stmt/switch_stmt_editor1.swift
View File

@@ -1,12 +0,0 @@
// RUN: %target-typecheck-verify-swift -diagnostics-editor-mode
enum E {
case e1
case e2
}
func foo1(e : E, i : Int) {
switch e {} // expected-error{{switch must be exhaustive}}
// expected-note@-1{{add missing cases}}{{13-13=case .e1:\n<#code#>\ncase .e2:\n<#code#>\n}}
switch i {} // expected-error{{'switch' statement body must have at least one 'case' or 'default' block; add a default case}}{{13-13=default:\n<#code#>\n}}
}

20
test/stmt/switch_stmt_editor2.swift
View File

@@ -1,20 +0,0 @@
// RUN: %target-typecheck-verify-swift -emit-sil -diagnostics-editor-mode
enum E {
case e1
case e2
}
func foo1(e : E) {
// expected-note@+1{{add missing cases}}{{+2:3-3=case .e2:\n<#code#>\n}}
switch e { // expected-error{{switch must be exhaustive}}
case .e1: return
}
}
func foo2(i : Int) {
// expected-note@+1{{add a default clause}}{{+2:3-3=default:\n<#code#>\n}}
switch i { // expected-error{{switch must be exhaustive}}
case 1: return
}
}