mirror of
https://github.com/apple/swift.git
synced 2025-12-21 12:14:44 +01:00
931f3394d7
At the moment, if there is an error in the `switch` statement expression or if the `{` is missing, we return `nullptr` from `parseStmtSwitch`, but we consume tokens while trying to parse the `switch` statement. This causes the AST to not contain any nodes for the tokens that were consumed while trying to parse the `switch` statement.
While this doesn’t cause any issues during compilation (compiling fails anyway so not having the `switch` statement in the AST is not a problem) this causes issues when trying to complete inside an expression that was consumed while trying to parse the `switch` statement but doesn’t have a representation in the AST. The solver-based completion approach can’t find the expression that contains the completion token (because it’s not part of the AST) and thus return empty results.
To fix this, make sure we are always creating a `SwitchStmt` when consuming tokens for it.
Previously, one could always assume that a `SwitchStmt` had a valid `LBraceLoc` and `RBraceLoc`. This is no longer the case because of the recovery. In order to form the `SwitchStmt`’s `SourceRange`, I needed to add a `EndLoc` property to `SwitchStmt` that keeps track of the last token in the `SwitchStmt`. Theoretically we should be able to compute this location by traversing the right brace, case stmts, subject expression, … in reverse order until we find something that’s not missing. But if the `SubjectExpr` is an `ErrorExpr`, representing a missing expression, it might have a source range that points to one after the last token in the statement (this is due to the way the `ErrorExpr` is being constructed), therefore returning an invalid range. So overall I thought it was easier and safer to add another property.
Fixes rdar://76688441 [SR-14490]
648 lines
20 KiB
Swift
648 lines
20 KiB
Swift
// RUN: %target-typecheck-verify-swift
|
|
|
|
// TODO: Implement tuple equality in the library.
|
|
// BLOCKED: <rdar://problem/13822406>
|
|
func ~= (x: (Int,Int), y: (Int,Int)) -> Bool {
|
|
return true
|
|
}
|
|
|
|
func parseError1(x: Int) {
|
|
switch func {} // expected-error {{expected expression in 'switch' statement}} expected-error {{expected identifier in function declaration}} expected-error {{closure expression is unused}} expected-note{{did you mean to use a 'do' statement?}} {{15-15=do }}
|
|
}
|
|
|
|
func parseError2(x: Int) {
|
|
switch x // expected-error {{expected '{' after 'switch' subject expression}}
|
|
}
|
|
|
|
func parseError3(x: Int) {
|
|
switch x {
|
|
case // expected-error {{expected pattern}} expected-error {{expected ':' after 'case'}}
|
|
}
|
|
}
|
|
|
|
func parseError4(x: Int) {
|
|
switch x {
|
|
case var z where // expected-error {{expected expression for 'where' guard of 'case'}} expected-error {{expected ':' after 'case'}}
|
|
}
|
|
}
|
|
|
|
func parseError5(x: Int) {
|
|
switch x {
|
|
case let z // expected-error {{expected ':' after 'case'}} expected-warning {{immutable value 'z' was never used}} {{8-13=_}}
|
|
}
|
|
}
|
|
|
|
func parseError6(x: Int) {
|
|
switch x {
|
|
default // expected-error {{expected ':' after 'default'}}
|
|
}
|
|
}
|
|
|
|
var x: Int
|
|
|
|
switch x {} // expected-error {{'switch' statement body must have at least one 'case' or 'default' block}}
|
|
|
|
switch x {
|
|
case 0:
|
|
x = 0
|
|
// Multiple patterns per case
|
|
case 1, 2, 3:
|
|
x = 0
|
|
// 'where' guard
|
|
case _ where x % 2 == 0:
|
|
x = 1
|
|
x = 2
|
|
x = 3
|
|
case _ where x % 2 == 0,
|
|
_ where x % 3 == 0:
|
|
x = 1
|
|
case 10,
|
|
_ where x % 3 == 0:
|
|
x = 1
|
|
case _ where x % 2 == 0,
|
|
20:
|
|
x = 1
|
|
case var y where y % 2 == 0:
|
|
x = y + 1
|
|
case _ where 0: // expected-error {{type 'Int' cannot be used as a boolean; test for '!= 0' instead}}
|
|
x = 0
|
|
default:
|
|
x = 1
|
|
}
|
|
|
|
// Multiple cases per case block
|
|
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 {
|
|
case 0: // expected-error{{'case' label in a 'switch' should have at least one executable statement}} {{8-8= break}}
|
|
default:
|
|
x = 0
|
|
}
|
|
|
|
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}}
|
|
}
|
|
|
|
switch x {
|
|
case 0:
|
|
x = 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}} expected-note{{do you want to add a default clause?}}
|
|
case 0:
|
|
; // expected-error {{';' statements are not allowed}} {{3-5=}}
|
|
case 1:
|
|
x = 0
|
|
}
|
|
|
|
|
|
|
|
switch x {
|
|
x = 1 // expected-error{{all statements inside a switch must be covered by a 'case' or 'default'}}
|
|
default:
|
|
x = 0
|
|
case 0: // expected-error{{additional 'case' blocks cannot appear after the 'default' block of a 'switch'}}
|
|
x = 0
|
|
case 1:
|
|
x = 0
|
|
}
|
|
|
|
switch x {
|
|
default:
|
|
x = 0
|
|
default: // expected-error{{additional 'case' blocks cannot appear after the 'default' block of a 'switch'}}
|
|
x = 0
|
|
}
|
|
|
|
switch x { // expected-error{{'switch' statement body must have at least one 'case' or 'default' block}}
|
|
x = 1 // expected-error{{all statements inside a switch must be covered by a 'case' or 'default'}}
|
|
}
|
|
|
|
switch x { // expected-error{{'switch' statement body must have at least one 'case' or 'default' block}}
|
|
x = 1 // expected-error{{all statements inside a switch must be covered by a 'case' or 'default'}}
|
|
x = 2
|
|
}
|
|
|
|
switch x {
|
|
default: // expected-error{{'default' label in a 'switch' should have at least one executable statement}} {{9-9= break}}
|
|
case 0: // expected-error{{additional 'case' blocks cannot appear after the 'default' block of a 'switch'}}
|
|
x = 0
|
|
}
|
|
|
|
switch x {
|
|
default: // expected-error{{'default' label in a 'switch' should have at least one executable statement}} {{9-9= break}}
|
|
default: // expected-error{{additional 'case' blocks cannot appear after the 'default' block of a 'switch'}}
|
|
x = 0
|
|
}
|
|
|
|
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}} 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}} 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}} 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}}
|
|
}
|
|
|
|
|
|
case 0: // expected-error{{'case' label can only appear inside a 'switch' statement}}
|
|
var y = 0
|
|
default: // expected-error{{'default' label can only appear inside a 'switch' statement}}
|
|
var z = 1
|
|
|
|
fallthrough // expected-error{{'fallthrough' is only allowed inside a switch}}
|
|
|
|
switch x {
|
|
case 0:
|
|
fallthrough
|
|
case 1:
|
|
fallthrough
|
|
default:
|
|
fallthrough // expected-error{{'fallthrough' without a following 'case' or 'default' block}}
|
|
}
|
|
|
|
// Fallthrough can transfer control anywhere within a case and can appear
|
|
// multiple times in the same case.
|
|
switch x {
|
|
case 0:
|
|
if true { fallthrough }
|
|
if false { fallthrough }
|
|
x += 1
|
|
default:
|
|
x += 1
|
|
}
|
|
|
|
// Cases cannot contain 'var' bindings if there are multiple matching patterns
|
|
// attached to a block. They may however contain other non-binding patterns.
|
|
|
|
var t = (1, 2)
|
|
|
|
switch t {
|
|
case (var a, 2), (1, _): // expected-error {{'a' must be bound in every pattern}} expected-warning {{variable 'a' was never used; consider replacing with '_' or removing it}}
|
|
()
|
|
|
|
case (_, 2), (var a, _): // expected-error {{'a' must be bound in every pattern}}
|
|
()
|
|
|
|
case (var a, 2), (1, var b): // expected-error {{'a' must be bound in every pattern}} expected-error {{'b' must be bound in every pattern}} expected-warning {{variable 'a' was never used; consider replacing with '_' or removing it}}
|
|
()
|
|
|
|
case (var a, 2): // expected-error {{'case' label in a 'switch' should have at least one executable statement}} {{17-17= break}} expected-warning {{variable 'a' was never used; consider replacing with '_' or removing it}}
|
|
case (1, _):
|
|
()
|
|
|
|
case (_, 2): // expected-error {{'case' label in a 'switch' should have at least one executable statement}} {{13-13= break}}
|
|
case (1, var a): // expected-warning {{variable 'a' was never used; consider replacing with '_' or removing it}}
|
|
()
|
|
|
|
case (var a, 2): // expected-error {{'case' label in a 'switch' should have at least one executable statement}} {{17-17= break}} expected-warning {{variable 'a' was never used; consider replacing with '_' or removing it}}
|
|
case (1, var b): // expected-warning {{variable 'b' was never used; consider replacing with '_' or removing it}}
|
|
()
|
|
|
|
case (1, let b): // let bindings expected-warning {{immutable value 'b' was never used; consider replacing with '_' or removing it}}
|
|
()
|
|
|
|
case (_, 2), (let a, _): // expected-error {{'a' must be bound in every pattern}} expected-warning {{case is already handled by previous patterns; consider removing it}}
|
|
()
|
|
|
|
// OK
|
|
case (_, 2), (1, _):
|
|
()
|
|
|
|
case (_, var a), (_, var a): // expected-warning {{variable 'a' was never used; consider replacing with '_' or removing it}}
|
|
// expected-warning@-1 {{case is already handled by previous patterns; consider removing it}}
|
|
// expected-warning@-2 {{case is already handled by previous patterns; consider removing it}}
|
|
()
|
|
|
|
case (var a, var b), (var b, var a): // expected-warning {{variable 'a' was never used; consider replacing with '_' or removing it}} expected-warning {{variable 'b' was never used; consider replacing with '_' or removing it}}
|
|
// expected-warning@-1 {{case is already handled by previous patterns; consider removing it}}
|
|
// expected-warning@-2 {{case is already handled by previous patterns; consider removing it}}
|
|
()
|
|
|
|
case (_, 2): // expected-error {{'case' label in a 'switch' should have at least one executable statement}} {{13-13= break}}
|
|
case (1, _):
|
|
()
|
|
}
|
|
|
|
func patternVarUsedInAnotherPattern(x: Int) {
|
|
switch x {
|
|
case let a, // expected-error {{'a' must be bound in every pattern}}
|
|
a: // expected-error {{cannot find 'a' in scope}}
|
|
break
|
|
}
|
|
}
|
|
|
|
// Fallthroughs can only transfer control into a case label with bindings if the previous case binds a superset of those vars.
|
|
switch t {
|
|
case (1, 2):
|
|
fallthrough // expected-error {{'fallthrough' from a case which doesn't bind variable 'a'}} expected-error {{'fallthrough' from a case which doesn't bind variable 'b'}}
|
|
case (var a, var b): // expected-warning {{variable 'a' was never mutated; consider changing to 'let' constant}} expected-warning {{variable 'b' was never mutated; consider changing to 'let' constant}}
|
|
t = (b, a)
|
|
}
|
|
|
|
switch t { // specifically notice on next line that we shouldn't complain that a is unused - just never mutated
|
|
case (var a, let b): // expected-warning {{variable 'a' was never mutated; consider changing to 'let' constant}}
|
|
t = (b, b)
|
|
fallthrough // ok - notice that subset of bound variables falling through is fine
|
|
case (2, let a):
|
|
t = (a, a)
|
|
}
|
|
|
|
func patternVarDiffType(x: Int, y: Double) {
|
|
switch (x, y) {
|
|
case (1, let a): // expected-error {{pattern variable bound to type 'Double', fallthrough case bound to type 'Int'}}
|
|
fallthrough
|
|
case (let a, _):
|
|
break
|
|
}
|
|
}
|
|
|
|
func patternVarDiffMutability(x: Int, y: Double) {
|
|
switch x {
|
|
case let a where a < 5, var a where a > 10: // expected-error {{'var' pattern binding must match previous 'let' pattern binding}}{{27-30=let}}
|
|
break
|
|
default:
|
|
break
|
|
}
|
|
switch (x, y) {
|
|
// Would be nice to have a fixit in the following line if we detect that all bindings in the same pattern have the same problem.
|
|
case let (a, b) where a < 5, var (a, b) where a > 10: // expected-error 2{{'var' pattern binding must match previous 'let' pattern binding}}{{none}}
|
|
break
|
|
case (let a, var b) where a < 5, (let a, let b) where a > 10: // expected-error {{'let' pattern binding must match previous 'var' pattern binding}}{{44-47=var}}
|
|
break
|
|
case (let a, let b) where a < 5, (var a, let b) where a > 10, (let a, var b) where a == 8:
|
|
// expected-error@-1 {{'var' pattern binding must match previous 'let' pattern binding}}{{37-40=let}}
|
|
// expected-error@-2 {{'var' pattern binding must match previous 'let' pattern binding}}{{73-76=let}}
|
|
break
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
|
|
func test_label(x : Int) {
|
|
Gronk: // expected-error {{switch must be exhaustive}} expected-note{{do you want to add a default clause?}}
|
|
switch x {
|
|
case 42: return
|
|
}
|
|
}
|
|
|
|
func enumElementSyntaxOnTuple() {
|
|
switch (1, 1) {
|
|
case .Bar: // expected-error {{value of tuple type '(Int, Int)' has no member 'Bar'}}
|
|
break
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
|
|
// sr-176
|
|
enum Whatever { case Thing }
|
|
func f0(values: [Whatever]) { // expected-note {{'values' declared here}}
|
|
switch value { // expected-error {{cannot find 'value' in scope; did you mean 'values'?}}
|
|
case .Thing: // Ok. Don't emit diagnostics about enum case not found in type <<error type>>.
|
|
break
|
|
}
|
|
}
|
|
|
|
// sr-720
|
|
enum Whichever {
|
|
case Thing
|
|
static let title = "title"
|
|
static let alias: Whichever = .Thing
|
|
}
|
|
func f1(x: String, y: Whichever) {
|
|
switch x {
|
|
case Whichever.title: // Ok. Don't emit diagnostics for static member of enum.
|
|
break
|
|
case Whichever.buzz: // expected-error {{type 'Whichever' has no member 'buzz'}}
|
|
break
|
|
case Whichever.alias: // expected-error {{expression pattern of type 'Whichever' cannot match values of type 'String'}}
|
|
// expected-note@-1 {{overloads for '~=' exist with these partially matching parameter lists: (Substring, String)}}
|
|
break
|
|
default:
|
|
break
|
|
}
|
|
switch y {
|
|
case Whichever.Thing: // Ok.
|
|
break
|
|
case Whichever.alias: // Ok. Don't emit diagnostics for static member of enum.
|
|
break
|
|
case Whichever.title: // expected-error {{expression pattern of type 'String' cannot match values of type 'Whichever'}}
|
|
break
|
|
}
|
|
}
|
|
|
|
|
|
switch Whatever.Thing {
|
|
case .Thing: // expected-error{{'case' label in a 'switch' should have at least one executable statement}} {{13-13= break}}
|
|
@unknown case _:
|
|
x = 0
|
|
}
|
|
|
|
switch Whatever.Thing {
|
|
case .Thing: // expected-error{{'case' label in a 'switch' should have at least one executable statement}} {{13-13= break}}
|
|
@unknown default:
|
|
x = 0
|
|
}
|
|
|
|
switch Whatever.Thing {
|
|
case .Thing:
|
|
x = 0
|
|
@unknown case _: // expected-error {{'case' label in a 'switch' should have at least one executable statement}} {{17-17= break}}
|
|
}
|
|
|
|
switch Whatever.Thing {
|
|
case .Thing:
|
|
x = 0
|
|
@unknown default: // expected-error {{'default' label in a 'switch' should have at least one executable statement}} {{18-18= break}}
|
|
}
|
|
|
|
|
|
switch Whatever.Thing {
|
|
@unknown default:
|
|
x = 0
|
|
default: // expected-error{{additional 'case' blocks cannot appear after the 'default' block of a 'switch'}}
|
|
x = 0
|
|
case .Thing:
|
|
x = 0
|
|
}
|
|
|
|
switch Whatever.Thing {
|
|
default:
|
|
x = 0
|
|
@unknown case _: // expected-error{{additional 'case' blocks cannot appear after the 'default' block of a 'switch'}} expected-error {{'@unknown' can only be applied to the last case in a switch}}
|
|
x = 0
|
|
case .Thing:
|
|
x = 0
|
|
}
|
|
|
|
switch Whatever.Thing {
|
|
default:
|
|
x = 0
|
|
@unknown default: // expected-error{{additional 'case' blocks cannot appear after the 'default' block of a 'switch'}}
|
|
x = 0
|
|
case .Thing:
|
|
x = 0
|
|
}
|
|
|
|
switch Whatever.Thing { // expected-warning {{switch must be exhaustive}} expected-note{{add missing case: '.Thing'}}
|
|
@unknown default where x == 0: // expected-error{{'default' cannot be used with a 'where' guard expression}}
|
|
x = 0
|
|
}
|
|
|
|
switch Whatever.Thing { // expected-warning {{switch must be exhaustive}} expected-note{{add missing case: '.Thing'}}
|
|
@unknown case _:
|
|
fallthrough // expected-error{{'fallthrough' without a following 'case' or 'default' block}}
|
|
}
|
|
|
|
switch Whatever.Thing {
|
|
@unknown case _: // expected-error {{'@unknown' can only be applied to the last case in a switch}}
|
|
fallthrough
|
|
case .Thing:
|
|
break
|
|
}
|
|
|
|
switch Whatever.Thing {
|
|
@unknown default:
|
|
fallthrough
|
|
case .Thing: // expected-error{{additional 'case' blocks cannot appear after the 'default' block of a 'switch'}}
|
|
break
|
|
}
|
|
|
|
switch Whatever.Thing {
|
|
@unknown case _, _: // expected-error {{'@unknown' cannot be applied to multiple patterns}}
|
|
break
|
|
}
|
|
|
|
switch Whatever.Thing {
|
|
@unknown case _, _, _: // expected-error {{'@unknown' cannot be applied to multiple patterns}}
|
|
break
|
|
}
|
|
|
|
switch Whatever.Thing { // expected-warning {{switch must be exhaustive}} expected-note{{add missing case: '.Thing'}}
|
|
@unknown case let value: // expected-error {{'@unknown' is only supported for catch-all cases ("case _")}}
|
|
_ = value
|
|
}
|
|
|
|
switch (Whatever.Thing, Whatever.Thing) { // expected-warning {{switch must be exhaustive}} expected-note{{add missing case: '(_, _)'}}
|
|
@unknown case (_, _): // expected-error {{'@unknown' is only supported for catch-all cases ("case _")}}
|
|
break
|
|
}
|
|
|
|
switch Whatever.Thing { // expected-warning {{switch must be exhaustive}} expected-note{{add missing case: '.Thing'}}
|
|
@unknown case is Whatever: // expected-error {{'@unknown' is only supported for catch-all cases ("case _")}}
|
|
// expected-warning@-1 {{'is' test is always true}}
|
|
break
|
|
}
|
|
|
|
switch Whatever.Thing { // expected-warning {{switch must be exhaustive}} expected-note{{add missing case: '.Thing'}}
|
|
@unknown case .Thing: // expected-error {{'@unknown' is only supported for catch-all cases ("case _")}}
|
|
break
|
|
}
|
|
|
|
switch Whatever.Thing { // expected-warning {{switch must be exhaustive}} expected-note{{add missing case: '.Thing'}}
|
|
@unknown case (_): // okay
|
|
break
|
|
}
|
|
|
|
switch Whatever.Thing { // expected-warning {{switch must be exhaustive}} expected-note{{add missing case: '.Thing'}}
|
|
@unknown case _ where x == 0: // expected-error {{'where' cannot be used with '@unknown'}}
|
|
break
|
|
}
|
|
|
|
switch Whatever.Thing { // expected-warning {{switch must be exhaustive}} expected-note{{add missing case: '.Thing'}}
|
|
@unknown default where x == 0: // expected-error {{'default' cannot be used with a 'where' guard expression}}
|
|
break
|
|
}
|
|
|
|
switch Whatever.Thing {
|
|
case .Thing:
|
|
x = 0
|
|
#if true
|
|
@unknown case _:
|
|
x = 0
|
|
#endif
|
|
}
|
|
|
|
switch x {
|
|
case 0:
|
|
break
|
|
@garbage case _: // expected-error {{unknown attribute 'garbage'}}
|
|
break
|
|
}
|
|
|
|
switch x {
|
|
case 0:
|
|
break
|
|
@garbage @moreGarbage default: // expected-error {{unknown attribute 'garbage'}} expected-error {{unknown attribute 'moreGarbage'}}
|
|
break
|
|
}
|
|
|
|
@unknown let _ = 1 // expected-error {{unknown attribute 'unknown'}}
|
|
|
|
switch x {
|
|
case _:
|
|
@unknown let _ = 1 // expected-error {{unknown attribute 'unknown'}}
|
|
}
|
|
|
|
switch Whatever.Thing {
|
|
case .Thing:
|
|
break
|
|
@unknown(garbage) case _: // expected-error {{unexpected '(' in attribute 'unknown'}}
|
|
break
|
|
}
|
|
switch Whatever.Thing {
|
|
case .Thing:
|
|
break
|
|
@unknown // expected-note {{attribute already specified here}}
|
|
@unknown // expected-error {{duplicate attribute}}
|
|
case _:
|
|
break
|
|
}
|
|
switch Whatever.Thing { // expected-warning {{switch must be exhaustive}} expected-note {{add missing case: '.Thing'}}
|
|
@unknown @garbage(foobar) // expected-error {{unknown attribute 'garbage'}}
|
|
case _:
|
|
break
|
|
}
|
|
|
|
switch x { // expected-error {{switch must be exhaustive}}
|
|
case 1:
|
|
break
|
|
@unknown case _: // expected-note {{remove '@unknown' to handle remaining values}} {{1-10=}}
|
|
break
|
|
}
|
|
|
|
switch x { // expected-error {{switch must be exhaustive}}
|
|
@unknown case _: // expected-note {{remove '@unknown' to handle remaining values}} {{1-10=}}
|
|
break
|
|
}
|
|
|
|
switch x { // expected-error {{switch must be exhaustive}}
|
|
@unknown default: // expected-note {{remove '@unknown' to handle remaining values}} {{1-10=}}
|
|
break
|
|
}
|
|
|
|
switch Whatever.Thing {
|
|
case .Thing:
|
|
break
|
|
@unknown case _: // expected-error {{'@unknown' can only be applied to the last case in a switch}}
|
|
break
|
|
@unknown case _:
|
|
break
|
|
}
|
|
|
|
switch Whatever.Thing {
|
|
case .Thing:
|
|
break
|
|
@unknown case _: // expected-error {{'@unknown' can only be applied to the last case in a switch}}
|
|
break
|
|
@unknown default:
|
|
break
|
|
}
|
|
|
|
switch Whatever.Thing {
|
|
case .Thing:
|
|
break
|
|
@unknown default:
|
|
break
|
|
@unknown default: // expected-error {{additional 'case' blocks cannot appear after the 'default' block of a 'switch'}}
|
|
break
|
|
}
|
|
|
|
switch Whatever.Thing {
|
|
@unknown case _: // expected-error {{'@unknown' can only be applied to the last case in a switch}}
|
|
break
|
|
@unknown case _:
|
|
break
|
|
}
|
|
|
|
switch Whatever.Thing {
|
|
@unknown case _: // expected-error {{'@unknown' can only be applied to the last case in a switch}}
|
|
break
|
|
@unknown default:
|
|
break
|
|
}
|
|
|
|
switch Whatever.Thing {
|
|
@unknown default:
|
|
break
|
|
@unknown default: // expected-error {{additional 'case' blocks cannot appear after the 'default' block of a 'switch'}}
|
|
break
|
|
}
|
|
|
|
|
|
switch x {
|
|
@unknown case _: // expected-error {{'@unknown' can only be applied to the last case in a switch}}
|
|
break
|
|
@unknown case _:
|
|
break
|
|
}
|
|
|
|
switch x {
|
|
@unknown case _: // expected-error {{'@unknown' can only be applied to the last case in a switch}}
|
|
break
|
|
@unknown default:
|
|
break
|
|
}
|
|
|
|
switch x {
|
|
@unknown default:
|
|
break
|
|
@unknown default: // expected-error {{additional 'case' blocks cannot appear after the 'default' block of a 'switch'}}
|
|
break
|
|
}
|
|
|
|
func testReturnBeforeUnknownDefault() {
|
|
switch x { // expected-error {{switch must be exhaustive}}
|
|
case 1:
|
|
return
|
|
@unknown default: // expected-note {{remove '@unknown' to handle remaining values}}
|
|
break
|
|
}
|
|
}
|
|
|
|
func testReturnBeforeIncompleteUnknownDefault() {
|
|
switch x { // expected-error {{switch must be exhaustive}}
|
|
case 1:
|
|
return
|
|
@unknown default // expected-error {{expected ':' after 'default'}}
|
|
// expected-note@-1 {{remove '@unknown' to handle remaining values}}
|
|
}
|
|
}
|
|
|
|
func testReturnBeforeIncompleteUnknownDefault2() {
|
|
switch x { // expected-error {{switch must be exhaustive}} expected-note {{do you want to add a default clause?}}
|
|
case 1:
|
|
return
|
|
@unknown // expected-error {{unknown attribute 'unknown'}}
|
|
} // expected-error {{expected declaration}}
|
|
}
|
|
|
|
func testIncompleteArrayLiteral() {
|
|
switch x { // expected-error {{switch must be exhaustive}}
|
|
case 1:
|
|
_ = [1 // expected-error {{expected ']' in container literal expression}} expected-note {{to match this opening '['}}
|
|
@unknown default: // expected-note {{remove '@unknown' to handle remaining values}}
|
|
()
|
|
}
|
|
}
|