mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
d762dd53f8
When parsing #if...#endif regions, parse the active clause directly into place in the AST without ever producing an IfConfigDecl instance.
1650 lines
50 KiB
Swift
1650 lines
50 KiB
Swift
// RUN: %target-typecheck-verify-swift -disable-availability-checking
|
|
|
|
// MARK: Functions
|
|
|
|
func foo() -> Int {
|
|
if .random() { 1 } else { 2 }
|
|
}
|
|
|
|
func foo2() -> Int {
|
|
return if .random() { 1 } else { 2 }
|
|
}
|
|
|
|
func foo3() -> Int {
|
|
if .random() { 1 } else { 2 } as Int
|
|
}
|
|
|
|
func foo4() -> Int {
|
|
return if .random() { 1 } else { 2 } as Int
|
|
}
|
|
|
|
func foo5() -> Int {
|
|
// We only allow coercions as a narrow case in the parser, so attempting to
|
|
// double them up is invalid.
|
|
if .random() { 1 } else { 2 } as Int as Int
|
|
// expected-error@-1 {{consecutive statements on a line must be separated by ';'}}
|
|
// expected-error@-2 {{expected expression}}
|
|
}
|
|
|
|
func foo6() -> Int {
|
|
let x = if .random() { 1 } else { 2 } as Int as Int
|
|
return x
|
|
}
|
|
|
|
func foo7() -> String {
|
|
if .random() { 1 } else { 2 } as String
|
|
// expected-error@-1 {{cannot convert value of type 'Int' to specified type 'String'}}
|
|
}
|
|
|
|
func foo8() -> Int {
|
|
return (if .random() { 1 } else { 2 } as Int)
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
}
|
|
|
|
func foo9() -> String? {
|
|
if .random() { 1 as Any } else { 2 as Any } as? String
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
}
|
|
|
|
func foo10() -> String {
|
|
if .random() { 1 as Any } else { 2 as Any } as! String
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
}
|
|
|
|
func foo11() -> Bool {
|
|
// We don't parse this.
|
|
if .random() { 1 as Any } else { 2 as Any } is String
|
|
// expected-error@-1 {{consecutive statements on a line must be separated by ';'}}
|
|
// expected-error@-2 {{expected expression}}
|
|
// expected-error@-3 {{cannot convert value of type 'Any' to specified type 'Bool'}}
|
|
}
|
|
|
|
func foo12() -> Bool {
|
|
let x = if .random() { 1 as Any } else { 2 as Any } is String
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
return x
|
|
}
|
|
|
|
func bar() -> Int {
|
|
if .random() {
|
|
fatalError()
|
|
} else {
|
|
2
|
|
}
|
|
}
|
|
|
|
func baz() -> Int {
|
|
if .random() {
|
|
"" // expected-error {{cannot convert value of type 'String' to specified type 'Int'}}
|
|
} else {
|
|
0
|
|
}
|
|
}
|
|
|
|
func qux(_ x: Int?) -> Int {
|
|
if let x = x { x } else { 0 }
|
|
}
|
|
|
|
func quux(_ x: Int?) -> Int {
|
|
if case let x? = x { x } else { 0 }
|
|
}
|
|
|
|
func elseIf(_ x: Int?) -> Int {
|
|
if .random() {
|
|
0
|
|
} else if let x = x {
|
|
x
|
|
} else if .random() {
|
|
1
|
|
} else {
|
|
7 + 8
|
|
}
|
|
}
|
|
|
|
func takesValue<T>(_ x: T) {}
|
|
|
|
// expected-error@+1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
takesValue(if .random() {
|
|
0
|
|
} else {
|
|
1
|
|
})
|
|
takesValue(if .random() { 0 } else { 1 })
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
|
|
// Cannot parse labeled if as expression.
|
|
do {
|
|
takesValue(x: if .random() { 0 } else { 1 })
|
|
// expected-error@-1 {{extraneous argument label 'x:' in call}}
|
|
// expected-error@-2 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
|
|
takesValue(_: x: if .random() { 0 } else { 1 })
|
|
// expected-error@-1 {{expected argument label before colon}}
|
|
// expected-error@-2 {{expected ',' separator}}
|
|
// expected-error@-3 {{cannot find 'x' in scope}}
|
|
// expected-error@-4 {{extra argument in call}}
|
|
// expected-error@-5 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
}
|
|
func takesValueWithLabel<T>(x: T) {}
|
|
do {
|
|
takesValueWithLabel(x: if .random() { 1 } else { 2 })
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
|
|
takesValueWithLabel(x: y: if .random() { 1 } else { 2 })
|
|
// expected-error@-1 {{expected argument label before colon}}
|
|
// expected-error@-2 {{expected ',' separator}}
|
|
// expected-error@-3 {{cannot find 'y' in scope}}
|
|
// expected-error@-4 {{extra argument in call}}
|
|
// expected-error@-5 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
}
|
|
func takesValueAndTrailingClosure<T>(_ x: T, _ fn: () -> Int) {}
|
|
takesValueAndTrailingClosure(if .random() { 0 } else { 1 }) { 2 }
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
|
|
func takesInOut<T>(_ x: inout T) {}
|
|
takesInOut(&if .random() { 1 } else { 2 })
|
|
// expected-error@-1 {{cannot pass immutable value of type 'Int' as inout argument}}
|
|
// expected-error@-2 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
|
|
struct HasSubscript {
|
|
static subscript(x: Int) -> Void { () }
|
|
|
|
subscript(x: Int...) -> Void { () }
|
|
}
|
|
HasSubscript[if .random() { 1 } else { 2 }]
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
|
|
func proposalExample1(isRoot: Bool, count: Int, willExpand: Bool, maxDepth: Int) -> String {
|
|
let bullet =
|
|
if isRoot && (count == 0 || !willExpand) { "" }
|
|
else if count == 0 { "- " }
|
|
else if maxDepth <= 0 { "▹ " }
|
|
else { "▿ " }
|
|
return bullet
|
|
}
|
|
|
|
var inAComputedVar: String {
|
|
if .random() { "a" } else { "b" }
|
|
}
|
|
|
|
// MARK: Outer pound if
|
|
|
|
func withPoundIf() -> Int {
|
|
#if true
|
|
if .random() { 0 } else { 1 }
|
|
#endif
|
|
}
|
|
|
|
func withPoundIfClosure() -> Int {
|
|
let fn = {
|
|
#if true
|
|
if .random() { 0 } else { 1 }
|
|
#endif
|
|
}
|
|
return fn()
|
|
}
|
|
|
|
func withPoundIfElse1() -> Int {
|
|
#if true
|
|
if .random() { 0 } else { 1 }
|
|
#else
|
|
0
|
|
#endif
|
|
}
|
|
|
|
func withPoundIfElse2() -> Int {
|
|
#if true
|
|
0
|
|
#else
|
|
if .random() { 0 } else { 1 }
|
|
#endif
|
|
}
|
|
|
|
func withPoundIfElseIf1() -> Int {
|
|
#if true
|
|
if .random() { 0 } else { 1 }
|
|
#elseif true
|
|
0
|
|
#endif
|
|
}
|
|
|
|
|
|
func withPoundIfElseIf2() -> Int {
|
|
#if true
|
|
0
|
|
#elseif true
|
|
if .random() { 0 } else { 1 }
|
|
#endif
|
|
}
|
|
|
|
func withPoundIfElseIfElse1() -> Int {
|
|
#if true
|
|
if .random() { 0 } else { 1 }
|
|
#elseif true
|
|
0
|
|
#else
|
|
0
|
|
#endif
|
|
}
|
|
|
|
func withPoundIfElseIfElse2() -> Int {
|
|
#if true
|
|
0
|
|
#elseif true
|
|
if .random() { 0 } else { 1 }
|
|
#else
|
|
0
|
|
#endif
|
|
}
|
|
|
|
func withPoundIfElseIfElse3() -> Int {
|
|
#if true
|
|
0
|
|
#elseif true
|
|
0
|
|
#else
|
|
if .random() { 0 } else { 1 }
|
|
#endif
|
|
}
|
|
|
|
func withVeryNestedPoundIf() -> Int {
|
|
#if true
|
|
#if true
|
|
#if false
|
|
""
|
|
#else
|
|
if .random() { 0 } else { 1 }
|
|
#endif
|
|
#elseif true
|
|
0
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
func withVeryNestedPoundIfClosure() -> Int {
|
|
let fn = {
|
|
#if true
|
|
#if true
|
|
#if false
|
|
""
|
|
#else
|
|
if .random() { 0 } else { 1 }
|
|
#endif
|
|
#elseif true
|
|
0
|
|
#endif
|
|
#endif
|
|
}
|
|
return fn()
|
|
}
|
|
|
|
// MARK: Explicit returns
|
|
|
|
func explicitReturn1() -> Int {
|
|
print("hello")
|
|
return if .random() { 0 } else { 1 }
|
|
}
|
|
|
|
func explicitReturn2() -> Int {
|
|
return
|
|
if .random() { 0 } else { 1 }
|
|
// expected-warning@-1 {{expression following 'return' is treated as an argument of the 'return'}}
|
|
// expected-note@-2 {{indent the expression to silence this warning}}
|
|
}
|
|
|
|
func explicitReturn3() -> Int {
|
|
return
|
|
if .random() { 0 } else { 1 }
|
|
}
|
|
|
|
func explicitReturn4() {
|
|
// This used to be legal, but is now treated as a return of the if expression.
|
|
return
|
|
if .random() { 0 } else { 1 }
|
|
// expected-error@-1 {{unexpected non-void return value in void function}}
|
|
// expected-note@-2 {{did you mean to add a return type?}}
|
|
}
|
|
|
|
func explicitReturn5() {
|
|
return;
|
|
if .random() { 0 } else { 1 } // expected-warning 2{{integer literal is unused}}
|
|
}
|
|
|
|
func explicitReturn6() {
|
|
return ()
|
|
if .random() { 0 } else { 1 } // expected-warning 2{{integer literal is unused}}
|
|
}
|
|
|
|
var explicitReturn7: String {
|
|
return if .random() { "a" } else { "b" }
|
|
}
|
|
|
|
struct AsPropertyInit {
|
|
var x: Int = if Bool.random() { 1 } else { 0 }
|
|
var y = if .random() { 1 } else { 0 }
|
|
}
|
|
|
|
func testNestedAssignment() {
|
|
var x = 0
|
|
x = if .random() { 0 } else { 1 } // Okay
|
|
let fn = {
|
|
x = if .random() { 0 } else { 1 } // Also okay
|
|
}
|
|
|
|
// We don't allow in a nested assignment.
|
|
// TODO: We could improve this error.
|
|
print(x = if .random() { 0 } else { 1 })
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
|
|
_ = x; _ = fn
|
|
}
|
|
|
|
struct TestFailableInit {
|
|
init?(_ x: Bool) {
|
|
let y = if x {
|
|
0
|
|
} else {
|
|
return nil // expected-error {{cannot use 'return' to transfer control out of 'if' expression}}
|
|
}
|
|
_ = y
|
|
}
|
|
}
|
|
|
|
struct TestFailableInitFatalError {
|
|
init?() {
|
|
// In this case, the if does not become an expression.
|
|
if .random() {
|
|
fatalError()
|
|
} else {
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: Expressions
|
|
|
|
let a = if .random() {
|
|
0
|
|
} else {
|
|
1
|
|
}
|
|
|
|
let b = (if .random() { 1 } else { 2 }) // expected-error {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
|
|
let c = (if .random() { 1 } else { 2 }, k: if .random() { 1 } else { 2 }) // expected-error 2{{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
|
|
var d = if .random() { if .random() { 1 } else { 2 } } else { 3 }
|
|
|
|
d = if .random() { 0 } else { 1 }
|
|
|
|
let e = "\(if .random() { 1 } else { 2 })" // expected-error {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
|
|
let f = { if .random() { 1 } else { 2 } }
|
|
|
|
func throwsError() throws {
|
|
struct E: Error {}
|
|
throw if .random() { E() } else { E() }
|
|
}
|
|
|
|
// FIXME: If we ever support this, we need to fix the premature inference of '[Any]'/'[AnyHashable: Any]'.
|
|
// The issue is that we're attempting to bind defaults to type variables before solving the conjuction.
|
|
let g = [if .random() { "a" } else { "b" }]
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
// expected-error@-2 {{heterogeneous collection literal could only be inferred to '[Any]'; add explicit type annotation if this is intentional}}
|
|
|
|
let h = [if .random() { 1 } else { 2 } : if .random() { "a" } else { "b" }]
|
|
// expected-error@-1 2{{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
// expected-error@-2 {{heterogeneous collection literal could only be inferred to '[AnyHashable : Any]'; add explicit type annotation if this is intentional}}
|
|
|
|
let i = [if .random() { 1 } else { 2 }: if .random() { "a" } else { "b" }]
|
|
// expected-error@-1 2{{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
// expected-error@-2 {{heterogeneous collection literal could only be inferred to '[AnyHashable : Any]'; add explicit type annotation if this is intentional}}
|
|
|
|
let j = [if .random() { 1 } else { 2 }:if .random() { "a" } else { "b" }]
|
|
// expected-error@-1 2{{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
// expected-error@-2 {{heterogeneous collection literal could only be inferred to '[AnyHashable : Any]'; add explicit type annotation if this is intentional}}
|
|
|
|
let k = [if .random() { 1 } else { 2 } :if .random() { "a" } else { "b" }]
|
|
// expected-error@-1 2{{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
// expected-error@-2 {{heterogeneous collection literal could only be inferred to '[AnyHashable : Any]'; add explicit type annotation if this is intentional}}
|
|
|
|
let l = if .random() { 1 } else { 2 } as Any
|
|
|
|
let _ = type(of: if .random() { 1 } else { 2 }) // expected-error {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
|
|
let _ = (if .random() { () } else { () }) // expected-error {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
|
|
let _ = if .random() { 0 } // expected-error {{'if' must have an unconditional 'else' to be used as expression}}
|
|
let _ = if .random() { 0 } else if .random() { 1 } // expected-error {{'if' must have an unconditional 'else' to be used as expression}}
|
|
|
|
func testNonExhaustiveInFunction() {
|
|
if .random() { 0 } // expected-warning {{integer literal is unused}}
|
|
}
|
|
|
|
func testLabelRejection1() -> Int {
|
|
// This was legal before, so remains legal.
|
|
x: if .random() { 0 } else { 1 }
|
|
// expected-warning@-1 2{{integer literal is unused}}
|
|
}
|
|
|
|
func testLabelRejection2() -> Int {
|
|
// This was never legal, so reject.
|
|
x: if .random() { 0 } else { 1 } as Int
|
|
// expected-error@-1 {{'if' cannot have a jump label when used as expression}}
|
|
}
|
|
|
|
do {
|
|
if .random() { 1 } else { 2 } = 3
|
|
// expected-error@-1 {{consecutive statements on a line must be separated by ';'}}
|
|
// expected-error@-2 {{expected expression}}
|
|
// expected-warning@-3 2{{integer literal is unused}}}
|
|
}
|
|
let m: Void = if .random() { 1 } else { 2 } // expected-error {{cannot convert value of type 'Int' to specified type 'Void'}}
|
|
let n: Never = if .random() { 1 } else { 2 } // expected-error {{cannot convert value of type 'Int' to specified type 'Never'}}
|
|
|
|
func testConditionalBinding1(_ x: Int?) -> Int {
|
|
if let x = if .random() { 0 } else { Int?.none } { // expected-error {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
x
|
|
} else {
|
|
0
|
|
}
|
|
}
|
|
|
|
func testConditionalBinding2(_ x: Int?) -> Int {
|
|
if case let x? = if .random() { 0 } else { Int?.none } { // expected-error {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
x
|
|
} else {
|
|
0
|
|
}
|
|
}
|
|
|
|
// MARK: Operators
|
|
|
|
let o = !if .random() { true } else { false } // expected-error {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
|
|
// FIXME: Shouldn't be ambiguous
|
|
let p = if .random() { 1 } else { 2 } + // expected-error {{ambiguous use of operator '+'}}
|
|
if .random() { 3 } else { 4 } +
|
|
if .random() { 5 } else { 6 }
|
|
// expected-error@-3 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
// expected-error@-3 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
// expected-error@-3 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
|
|
let p1 = if .random() { 1 } else { 2 } + 5
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
|
|
let q = .random() ? if .random() { 1 } else { 2 }
|
|
: if .random() { 3 } else { 4 }
|
|
// expected-error@-2 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
// expected-error@-2 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
|
|
let r = if .random() { 1 } else { 2 }...if .random() { 1 } else { 2 }
|
|
// expected-error@-1 2{{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
|
|
let s = if .random() { 1 } else { 2 } ... if .random() { 1 } else { 2 }
|
|
// expected-error@-1 2{{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
|
|
// MARK: Lookup
|
|
|
|
do {
|
|
let t = if .random() { t } else { 0 }
|
|
// expected-error@-1 {{use of local variable 't' before its declaration}}
|
|
// expected-note@-2 {{'t' declared here}}
|
|
}
|
|
|
|
// MARK: Postfix
|
|
|
|
// We don't allow postfix parsing.
|
|
do {
|
|
let _ = if .random() { [1] } else { [1, 2] }.count
|
|
// expected-error@-1 {{consecutive statements on a line must be separated by ';'}}
|
|
// expected-error@-2 {{reference to member 'count' cannot be resolved without a contextual type}}
|
|
|
|
let _ = (if .random() { [1] } else { [1, 2] }).count
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
}
|
|
do {
|
|
let _ = if .random() { Int?.none } else { 1 as Int? }?.bitWidth
|
|
// expected-error@-1 {{consecutive statements on a line must be separated by ';'}}
|
|
// expected-error@-2 {{expected expression}}
|
|
|
|
// FIXME: The type error is likely due to not solving the conjunction before attempting default type var bindings.
|
|
let _ = (if .random() { Int?.none } else { 1 as Int? })?.bitWidth
|
|
// expected-error@-1 {{type of expression is ambiguous without a type annotation}}
|
|
// expected-error@-2 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
}
|
|
do {
|
|
let _ = if .random() { Int?.none } else { 1 as Int? }!
|
|
// expected-error@-1 {{consecutive statements on a line must be separated by ';'}}
|
|
// expected-error@-2 {{expected expression}}
|
|
|
|
let _ = (if .random() { Int?.none } else { 1 as Int? })!
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
}
|
|
do {
|
|
func takesInts(_ x: Int...) {}
|
|
let _ = if .random() { takesInts } else { takesInts }(1, 2, 3)
|
|
// expected-error@-1 {{consecutive statements on a line must be separated by ';'}}
|
|
// expected-warning@-2 {{expression of type '(Int, Int, Int)' is unused}}
|
|
|
|
let _ = (if .random() { takesInts } else { takesInts })(1, 2, 3)
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
}
|
|
func testSubscriptPostfix(_ x: HasSubscript) {
|
|
if .random() { x } else { x }[1, 2, 3]
|
|
// expected-error@-1 {{consecutive statements on a line must be separated by ';'}}
|
|
// expected-warning@-2 {{expression of type 'HasSubscript' is unused}}
|
|
// expected-warning@-3 {{expression of type '[Int]' is unused}}
|
|
// expected-warning@-4 {{expression of type 'HasSubscript' is unused}}
|
|
|
|
(if .random() { x } else { x })[1, 2, 3]
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
}
|
|
do {
|
|
func takesClosure(_ fn: () -> Int) {}
|
|
|
|
let _ = if .random() { takesClosure } else { takesClosure } { 3 }
|
|
// expected-error@-1 {{getter/setter can only be defined for a single variable}}
|
|
|
|
let _ = (if .random() { takesClosure } else { takesClosure }) { 3 }
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
}
|
|
|
|
// MARK: Statements
|
|
|
|
func stmts() {
|
|
if if .random() { true } else { false } {}
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
|
|
if try if .random() { true } else { false } {}
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
// expected-warning@-2 {{'try' has no effect on 'if' expression}}
|
|
|
|
// expected-error@+1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
guard if .random() { true } else { false } else {
|
|
return
|
|
}
|
|
|
|
switch if .random() { true } else { false } {
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
case _ where if .random() { true } else { false }:
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
break
|
|
case if .random() { true } else { false }:
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
break
|
|
case if .random() { true } else { false } && false:
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
break
|
|
default:
|
|
break
|
|
}
|
|
|
|
for b in [true] where if b { true } else { false } {}
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
|
|
for _ in if .random() { [true] } else { [false] } {}
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
|
|
for _ in if .random() { [true] } else { [false] } {} // expected-error {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
|
|
// Make sure this doesn't parse as an if expr pattern with a label.
|
|
let x = 0
|
|
switch 0 {
|
|
case x: if .random() { 1 } else { 2 }
|
|
// expected-warning@-1 2{{integer literal is unused}}
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
|
|
// MARK: Non-expression branches
|
|
|
|
func noElse() -> Int {
|
|
// Not an expression because no else.
|
|
if .random() {
|
|
0 // expected-warning {{integer literal is unused}}
|
|
}
|
|
1 // expected-warning {{integer literal is unused}}
|
|
}
|
|
|
|
func returnBranches() -> Int {
|
|
// This is not an expression because the branches are not expressions.
|
|
if .random() {
|
|
return 0
|
|
} else {
|
|
return 1
|
|
}
|
|
}
|
|
|
|
func returnBranches1() -> Int {
|
|
return if .random() { // expected-error {{cannot convert return expression of type 'Void' to return type 'Int'}}
|
|
return 0 // expected-error {{cannot use 'return' to transfer control out of 'if' expression}}
|
|
} else {
|
|
return 1 // expected-error {{cannot use 'return' to transfer control out of 'if' expression}}
|
|
}
|
|
}
|
|
|
|
func returnBranchVoid() {
|
|
return if .random() { return } else { return () }
|
|
// expected-error@-1 2{{cannot use 'return' to transfer control out of 'if' expression}}
|
|
}
|
|
|
|
func returnBranchBinding() -> Int {
|
|
let x = if .random() {
|
|
// expected-warning@-1 {{constant 'x' inferred to have type 'Void', which may be unexpected}}
|
|
// expected-note@-2 {{add an explicit type annotation to silence this warning}}
|
|
return 0 // expected-error {{cannot use 'return' to transfer control out of 'if' expression}}
|
|
} else {
|
|
return 1 // expected-error {{cannot use 'return' to transfer control out of 'if' expression}}
|
|
}
|
|
return x // expected-error {{cannot convert return expression of type 'Void' to return type 'Int'}}
|
|
}
|
|
|
|
func returnBranches2() -> Int {
|
|
// We don't allow multiple expressions.
|
|
if .random() {
|
|
print("hello")
|
|
0 // expected-warning {{integer literal is unused}}
|
|
} else {
|
|
1 // expected-warning {{integer literal is unused}}
|
|
}
|
|
}
|
|
|
|
func returnBranches3() -> Int {
|
|
if .random() {
|
|
print("hello")
|
|
return 0
|
|
} else {
|
|
1 // expected-warning {{integer literal is unused}}
|
|
}
|
|
}
|
|
|
|
func returnBranches4() -> Int {
|
|
if .random() { return 1 } else { 0 } // expected-warning {{integer literal is unused}}
|
|
}
|
|
|
|
struct Err: Error {}
|
|
|
|
func returnBranches5() throws -> Int {
|
|
let i = if .random() {
|
|
// expected-warning@-1 {{constant 'i' inferred to have type 'Void', which may be unexpected}}
|
|
// expected-note@-2 {{add an explicit type annotation to silence this warning}}
|
|
return 0 // expected-error {{cannot use 'return' to transfer control out of 'if' expression}}
|
|
} else {
|
|
return 1 // expected-error {{cannot use 'return' to transfer control out of 'if' expression}}
|
|
}
|
|
let j = if .random() {
|
|
// expected-warning@-1 {{constant 'j' inferred to have type 'Void', which may be unexpected}}
|
|
// expected-note@-2 {{add an explicit type annotation to silence this warning}}
|
|
throw Err()
|
|
} else {
|
|
throw Err()
|
|
}
|
|
return i // expected-error {{cannot convert return expression of type 'Void' to return type 'Int'}}
|
|
}
|
|
|
|
func returnBranches6() -> Int {
|
|
// We don't allow multiple expressions.
|
|
let i = if .random() {
|
|
print("hello")
|
|
0 // expected-warning {{integer literal is unused}}
|
|
} else { // expected-error {{non-expression branch of 'if' expression may only end with a 'throw'}}
|
|
1
|
|
}
|
|
return i
|
|
}
|
|
|
|
func returnBranches6PoundIf() -> Int {
|
|
// We don't allow multiple expressions.
|
|
let i = if .random() {
|
|
#if true
|
|
print("hello")
|
|
0 // expected-warning {{integer literal is unused}}
|
|
#endif
|
|
} else { // expected-error {{non-expression branch of 'if' expression may only end with a 'throw'}}
|
|
1
|
|
}
|
|
return i
|
|
}
|
|
|
|
func returnBranches6PoundIf2() -> Int {
|
|
// We don't allow multiple expressions.
|
|
let i = if .random() { // expected-error{{expected expression in branch of 'if' expression}}
|
|
#if false
|
|
print("hello")
|
|
0
|
|
#endif
|
|
} else {
|
|
1
|
|
}
|
|
return i
|
|
}
|
|
|
|
func returnBranches7() -> Int {
|
|
let i = if .random() {
|
|
print("hello")
|
|
return 0 // expected-error {{cannot use 'return' to transfer control out of 'if' expression}}
|
|
} else {
|
|
1
|
|
}
|
|
return i
|
|
}
|
|
|
|
func returnBranches8() -> Int {
|
|
let i = if .random() { return 1 } else { 0 } // expected-error {{cannot use 'return' to transfer control out of 'if' expression}}
|
|
return i
|
|
}
|
|
|
|
func returnBranches9() -> Int {
|
|
let i = if .random() {
|
|
print("hello")
|
|
if .random() {}
|
|
} else { // expected-error {{non-expression branch of 'if' expression may only end with a 'throw'}}
|
|
1
|
|
}
|
|
return i
|
|
}
|
|
|
|
func returnBranches10() -> Int {
|
|
let i = if .random() {
|
|
print("hello")
|
|
if .random() {
|
|
0 // expected-warning {{integer literal is unused}}
|
|
} else {
|
|
2 // expected-warning {{integer literal is unused}}
|
|
}
|
|
} else { // expected-error {{non-expression branch of 'if' expression may only end with a 'throw'}}
|
|
1
|
|
}
|
|
return i
|
|
}
|
|
|
|
func returnBranches11() -> Int {
|
|
let i = if .random() {
|
|
print("hello")
|
|
if .random() {
|
|
"" // expected-warning {{string literal is unused}}
|
|
} else {
|
|
0 // expected-warning {{integer literal is unused}}
|
|
}
|
|
} else { // expected-error {{non-expression branch of 'if' expression may only end with a 'throw'}}
|
|
1
|
|
}
|
|
return i
|
|
}
|
|
|
|
func returnBranches12() -> Int {
|
|
if .random() {
|
|
print("hello")
|
|
if .random() {}
|
|
} else {
|
|
1 // expected-warning {{integer literal is unused}}
|
|
}
|
|
}
|
|
|
|
func returnBranches13() -> Int {
|
|
if .random() {
|
|
print("hello")
|
|
if .random() {
|
|
0 // expected-warning {{integer literal is unused}}
|
|
} else {
|
|
2 // expected-warning {{integer literal is unused}}
|
|
}
|
|
} else {
|
|
1 // expected-warning {{integer literal is unused}}
|
|
}
|
|
}
|
|
|
|
func returnBranches14() -> Int {
|
|
if .random() {
|
|
print("hello")
|
|
if .random() {
|
|
"" // expected-warning {{string literal is unused}}
|
|
} else {
|
|
0 // expected-warning {{integer literal is unused}}
|
|
}
|
|
} else {
|
|
1 // expected-warning {{integer literal is unused}}
|
|
}
|
|
}
|
|
|
|
func nestedType() -> Int {
|
|
if .random() {
|
|
struct S {
|
|
var x: Int
|
|
}
|
|
return S(x: 0).x
|
|
} else {
|
|
0 // expected-warning {{integer literal is unused}}
|
|
}
|
|
}
|
|
|
|
func testEmptyBranch() -> Int {
|
|
let x = if .random() {} else { 0 }
|
|
// expected-error@-1:24 {{expected expression in branch of 'if' expression}}
|
|
return x
|
|
}
|
|
|
|
// MARK: Pound if branches
|
|
|
|
func testPoundIfBranch1() -> Int {
|
|
if .random() {
|
|
#if true
|
|
0
|
|
#endif
|
|
} else {
|
|
0
|
|
}
|
|
}
|
|
|
|
func testPoundIfBranch2() -> Int {
|
|
if .random() {
|
|
#if false
|
|
0
|
|
#endif
|
|
} else {
|
|
0 // expected-warning {{integer literal is unused}}
|
|
}
|
|
}
|
|
|
|
func testPoundIfBranch3() -> Int {
|
|
let x = if .random() { // expected-error{{expected expression in branch of 'if' expression}}
|
|
#if false
|
|
0
|
|
#endif
|
|
} else {
|
|
0
|
|
}
|
|
return x
|
|
}
|
|
|
|
func testPoundIfBranch4() -> Int {
|
|
if .random() {
|
|
#if true
|
|
0
|
|
#endif
|
|
} else {
|
|
#if true
|
|
0
|
|
#endif
|
|
}
|
|
}
|
|
|
|
func testPoundIfBranch5() -> Int {
|
|
// Inactive #if regions don't count
|
|
if .random() {
|
|
#if false
|
|
0
|
|
#endif
|
|
0
|
|
} else {
|
|
1
|
|
}
|
|
}
|
|
|
|
func testPoundIfBranch6() -> Int {
|
|
// Inactive #if regions don't count
|
|
let x = if .random() {
|
|
#if false
|
|
0
|
|
#endif
|
|
0
|
|
} else {
|
|
1
|
|
}
|
|
return x
|
|
}
|
|
|
|
func testPoundIfBranch7() -> Int {
|
|
if .random() {
|
|
#if true
|
|
#if true
|
|
#if false
|
|
""
|
|
#else
|
|
0
|
|
#endif
|
|
#elseif true
|
|
""
|
|
#endif
|
|
#endif
|
|
} else {
|
|
0
|
|
}
|
|
}
|
|
|
|
func testPoundIfBranch8() -> Int {
|
|
if .random() {
|
|
#if false
|
|
0
|
|
#else
|
|
#if true
|
|
if .random() { 0 } else { 1 }
|
|
#endif
|
|
#endif
|
|
} else {
|
|
#if true
|
|
if .random() { 0 } else { 1 }
|
|
#endif
|
|
}
|
|
}
|
|
|
|
// MARK: Jumping
|
|
|
|
func break1() -> Int {
|
|
switch true {
|
|
case true:
|
|
let j = if .random() {
|
|
break // expected-error {{cannot use 'break' to transfer control out of 'if' expression}}
|
|
} else {
|
|
0
|
|
}
|
|
return j
|
|
case false:
|
|
return 0
|
|
}
|
|
}
|
|
|
|
func continue1() -> Int {
|
|
for _ in 0 ... 5 {
|
|
let i = if true { continue } else { 1 }
|
|
// expected-error@-1 {{cannot use 'continue' to transfer control out of 'if' expression}}
|
|
return i
|
|
}
|
|
}
|
|
|
|
func return1() -> Int {
|
|
// Make sure we always reject a return.
|
|
let i = if .random() {
|
|
()
|
|
do {
|
|
for _ in [0] {
|
|
while true {
|
|
switch 0 {
|
|
default:
|
|
return 0 // expected-error {{cannot use 'return' to transfer control out of 'if' expression}}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
0
|
|
}
|
|
return i
|
|
}
|
|
|
|
func return2() throws -> Int {
|
|
// In a nested function is okay though.
|
|
let i = if .random() {
|
|
func foo() { return }
|
|
throw Err()
|
|
} else {
|
|
0
|
|
}
|
|
return i
|
|
}
|
|
|
|
func return3() throws -> Int {
|
|
// A nested type is also okay.
|
|
let i = if .random() {
|
|
struct Nested {
|
|
func foo() { return }
|
|
}
|
|
throw Err()
|
|
} else {
|
|
0
|
|
}
|
|
return i
|
|
}
|
|
|
|
func return4() throws -> Int {
|
|
// A nested closure is also okay.
|
|
let i = if .random() {
|
|
let _ = { return }
|
|
throw Err()
|
|
} else {
|
|
0
|
|
}
|
|
return i
|
|
}
|
|
|
|
// https://github.com/swiftlang/swift/issues/75880
|
|
func fallthrough1() throws {
|
|
switch Bool.random() {
|
|
case true:
|
|
let _ = if .random() {
|
|
if .random () {
|
|
fallthrough // expected-error {{cannot use 'fallthrough' to transfer control out of 'if' expression}}
|
|
}
|
|
throw Err()
|
|
} else {
|
|
0
|
|
}
|
|
case false:
|
|
break
|
|
}
|
|
}
|
|
|
|
func fallthrough2() throws -> Int {
|
|
let x = switch Bool.random() {
|
|
case true:
|
|
if .random() {
|
|
if .random () {
|
|
fallthrough // expected-error {{cannot use 'fallthrough' to transfer control out of 'if' expression}}
|
|
}
|
|
throw Err()
|
|
} else {
|
|
0
|
|
}
|
|
case false:
|
|
1
|
|
}
|
|
return x
|
|
}
|
|
|
|
func fallthrough3() -> Int {
|
|
let x = switch Bool.random() {
|
|
case true:
|
|
if .random() {
|
|
fallthrough // expected-error {{cannot use 'fallthrough' to transfer control out of 'if' expression}}
|
|
} else {
|
|
0
|
|
}
|
|
case false:
|
|
1
|
|
}
|
|
return x
|
|
}
|
|
|
|
func fallthrough4() -> Int {
|
|
let x = if .random() {
|
|
fallthrough // expected-error {{'fallthrough' is only allowed inside a switch}}
|
|
} else {
|
|
0
|
|
}
|
|
return x
|
|
}
|
|
|
|
// MARK: Effect specifiers
|
|
|
|
func tryIf1() -> Int {
|
|
try if .random() { 0 } else { 1 }
|
|
// expected-warning@-1 {{'try' has no effect on 'if' expression}}
|
|
}
|
|
|
|
func tryIf2() -> Int {
|
|
let x = try if .random() { 0 } else { 1 }
|
|
// expected-warning@-1 {{'try' has no effect on 'if' expression}}
|
|
return x
|
|
}
|
|
|
|
func tryIf3() -> Int {
|
|
return try if .random() { 0 } else { 1 }
|
|
// expected-warning@-1 {{'try' has no effect on 'if' expression}}
|
|
}
|
|
|
|
func tryIf4() throws -> Int {
|
|
return try if .random() { 0 } else { 1 }
|
|
// expected-warning@-1 {{'try' has no effect on 'if' expression}}
|
|
}
|
|
|
|
func tryIf5() throws -> Int {
|
|
return try if .random() { tryIf4() } else { 1 }
|
|
// expected-warning@-1 {{'try' has no effect on 'if' expression}}
|
|
// expected-warning@-2 {{call can throw but is not marked with 'try'; this is an error in the Swift 6 language mode}}
|
|
// expected-note@-3 {{did you mean to use 'try'?}}
|
|
// expected-note@-4 {{did you mean to handle error as optional value?}}
|
|
// expected-note@-5 {{did you mean to disable error propagation?}}
|
|
}
|
|
|
|
func tryIf6() throws -> Int {
|
|
try if .random() { tryIf4() } else { 1 }
|
|
// expected-warning@-1 {{'try' has no effect on 'if' expression}}
|
|
// expected-warning@-2 {{call can throw but is not marked with 'try'; this is an error in the Swift 6 language mode}}
|
|
// expected-note@-3 {{did you mean to use 'try'?}}
|
|
// expected-note@-4 {{did you mean to handle error as optional value?}}
|
|
// expected-note@-5 {{did you mean to disable error propagation?}}
|
|
}
|
|
|
|
func tryIf7() throws -> Int {
|
|
let x = try if .random() { tryIf4() } else { 1 }
|
|
// expected-warning@-1 {{'try' has no effect on 'if' expression}}
|
|
// expected-warning@-2 {{call can throw but is not marked with 'try'; this is an error in the Swift 6 language mode}}
|
|
// expected-note@-3 {{did you mean to use 'try'?}}
|
|
// expected-note@-4 {{did you mean to handle error as optional value?}}
|
|
// expected-note@-5 {{did you mean to disable error propagation?}}
|
|
return x
|
|
}
|
|
|
|
func tryIf8() throws -> Int {
|
|
return try if .random() { try tryIf4() } else { 1 }
|
|
// expected-warning@-1 {{'try' has no effect on 'if' expression}}
|
|
}
|
|
|
|
func tryIf9() throws -> Int {
|
|
try if .random() { try tryIf4() } else { 1 }
|
|
// expected-warning@-1 {{'try' has no effect on 'if' expression}}
|
|
}
|
|
|
|
func tryIf10() throws -> Int {
|
|
let x = try if .random() { try tryIf4() } else { 1 }
|
|
// expected-warning@-1 {{'try' has no effect on 'if' expression}}
|
|
return x
|
|
}
|
|
|
|
func tryIf11() throws -> Int {
|
|
let x = try if .random() { try tryIf4() } else { tryIf4() }
|
|
// expected-warning@-1 {{'try' has no effect on 'if' expression}}
|
|
// expected-warning@-2 {{call can throw but is not marked with 'try'; this is an error in the Swift 6 language mode}}
|
|
// expected-note@-3 {{did you mean to use 'try'?}}
|
|
// expected-note@-4 {{did you mean to handle error as optional value?}}
|
|
// expected-note@-5 {{did you mean to disable error propagation?}}
|
|
return x
|
|
}
|
|
|
|
func tryIf12() throws -> Int {
|
|
let x = try if .random() { tryIf4() } else { tryIf4() }
|
|
// expected-warning@-1 {{'try' has no effect on 'if' expression}}
|
|
// expected-warning@-2 2{{call can throw but is not marked with 'try'; this is an error in the Swift 6 language mode}}
|
|
// expected-note@-3 2{{did you mean to use 'try'?}}
|
|
// expected-note@-4 2{{did you mean to handle error as optional value?}}
|
|
// expected-note@-5 2{{did you mean to disable error propagation?}}
|
|
return x
|
|
}
|
|
|
|
func tryIf13() throws -> Int {
|
|
let x = try if .random() { // expected-warning {{'try' has no effect on 'if' expression}}
|
|
tryIf4() // expected-warning {{result of call to 'tryIf4()' is unused}}
|
|
// expected-warning@-1 {{call can throw but is not marked with 'try'; this is an error in the Swift 6 language mode}}
|
|
// expected-note@-2 {{did you mean to use 'try'?}}
|
|
// expected-note@-3 {{did you mean to handle error as optional value?}}
|
|
// expected-note@-4 {{did you mean to disable error propagation?}}
|
|
|
|
_ = tryIf4()
|
|
// expected-warning@-1 {{call can throw but is not marked with 'try'; this is an error in the Swift 6 language mode}}
|
|
// expected-note@-2 {{did you mean to use 'try'?}}
|
|
// expected-note@-3 {{did you mean to handle error as optional value?}}
|
|
// expected-note@-4 {{did you mean to disable error propagation?}}
|
|
|
|
_ = try tryIf4() // Okay.
|
|
|
|
// Okay.
|
|
do {
|
|
_ = try tryIf4()
|
|
} catch {}
|
|
|
|
print("hello")
|
|
throw Err()
|
|
} else {
|
|
0
|
|
}
|
|
return x
|
|
}
|
|
|
|
func throwsBool() throws -> Bool { true }
|
|
|
|
func tryIf14() throws -> Int {
|
|
try if throwsBool() { 0 } else { 1 }
|
|
// expected-warning@-1 {{'try' has no effect on 'if' expression}}
|
|
// expected-warning@-2 {{call can throw but is not marked with 'try'; this is an error in the Swift 6 language mode}}
|
|
// expected-note@-3 {{did you mean to use 'try'?}}
|
|
// expected-note@-4 {{did you mean to handle error as optional value?}}
|
|
// expected-note@-5 {{did you mean to disable error propagation?}}
|
|
}
|
|
|
|
func tryIf15() throws -> Int {
|
|
try if try throwsBool() { 0 } else { 1 }
|
|
// expected-warning@-1 {{'try' has no effect on 'if' expression}}
|
|
}
|
|
|
|
func tryIf16() throws -> Int {
|
|
if throwsBool() { 0 } else { 1 }
|
|
// expected-error@-1 {{call can throw but is not marked with 'try'}}
|
|
// expected-note@-2 {{did you mean to use 'try'?}}
|
|
// expected-note@-3 {{did you mean to handle error as optional value?}}
|
|
// expected-note@-4 {{did you mean to disable error propagation?}}
|
|
}
|
|
|
|
func tryIf17() throws -> Int {
|
|
if .random() { tryIf4() } else { 1 }
|
|
// expected-error@-1 {{call can throw but is not marked with 'try'}}
|
|
// expected-note@-2 {{did you mean to use 'try'?}}
|
|
// expected-note@-3 {{did you mean to handle error as optional value?}}
|
|
// expected-note@-4 {{did you mean to disable error propagation?}}
|
|
}
|
|
|
|
func tryIf18() {
|
|
// Make sure we don't warn here.
|
|
do {
|
|
let _ = if .random() { try tryIf4() } else { 1 }
|
|
} catch {}
|
|
}
|
|
|
|
func tryIf19() {
|
|
// Make sure we don't warn here.
|
|
do {
|
|
let _ = if .random() { throw Err() } else { 1 }
|
|
} catch {}
|
|
}
|
|
|
|
func tryIf19() throws -> Int {
|
|
let x = if .random() { throw Err() } else { 1 }
|
|
return x
|
|
}
|
|
|
|
func tryIf20() throws -> Int {
|
|
if .random() { throw Err() } else { 1 }
|
|
}
|
|
|
|
func tryIf21(_ fn: () throws -> Int) rethrows -> Int {
|
|
let x = if .random() { try fn() } else { 1 }
|
|
return x
|
|
}
|
|
|
|
func tryIf22(_ fn: () throws -> Int) rethrows -> Int {
|
|
if .random() { try fn() } else { 1 }
|
|
}
|
|
|
|
func tryIf23(_ fn: () throws -> Int) rethrows -> Int {
|
|
let x = if .random() { try fn() } else { throw Err() }
|
|
// expected-error@-1 {{a function declared 'rethrows' may only throw if its parameter does}}
|
|
return x
|
|
}
|
|
|
|
func tryIf24(_ fn: () throws -> Int) rethrows -> Int {
|
|
let x = if .random() { try fn() } else { try tryIf4() }
|
|
// expected-error@-1 {{a function declared 'rethrows' may only throw if its parameter does}}
|
|
return x
|
|
}
|
|
|
|
func tryIf25(_ fn: () throws -> Int) rethrows -> Int {
|
|
do {
|
|
let x = if .random() { try fn() } else { try tryIf4() }
|
|
return x
|
|
} catch {
|
|
return 0
|
|
}
|
|
}
|
|
|
|
func tryIf26(_ fn: () throws -> Int) rethrows -> Int {
|
|
do {
|
|
let x = if .random() { try fn() } else { throw Err() }
|
|
return x
|
|
} catch {
|
|
return 0
|
|
}
|
|
}
|
|
|
|
func tryIf27(_ fn: () throws -> Int) rethrows -> Int {
|
|
do {
|
|
let x = if .random() { try fn() } else { try tryIf4() }
|
|
return x
|
|
} catch {
|
|
throw error // expected-error {{a function declared 'rethrows' may only throw if its parameter does}}
|
|
}
|
|
}
|
|
|
|
func tryIf28(_ fn: () throws -> Int) rethrows -> Int {
|
|
do {
|
|
let x = if .random() { try fn() } else { throw Err() }
|
|
return x
|
|
} catch {
|
|
throw error // expected-error {{a function declared 'rethrows' may only throw if its parameter does}}
|
|
}
|
|
}
|
|
|
|
func tryIf29(_ fn: () throws -> Int) rethrows -> Int {
|
|
do {
|
|
let x = if .random() { try fn() } else { 0 }
|
|
return x
|
|
} catch {
|
|
throw error // Okay.
|
|
}
|
|
}
|
|
|
|
func awaitIf1() async -> Int {
|
|
await if .random() { 0 } else { 1 }
|
|
// expected-warning@-1 {{'await' has no effect on 'if' expression}}
|
|
}
|
|
|
|
func awaitIf2() async -> Int {
|
|
let x = await if .random() { 0 } else { 1 }
|
|
// expected-warning@-1 {{'await' has no effect on 'if' expression}}
|
|
return x
|
|
}
|
|
|
|
func awaitIf3() async -> Int {
|
|
return await if .random() { 0 } else { 1 }
|
|
// expected-warning@-1 {{'await' has no effect on 'if' expression}}
|
|
}
|
|
|
|
func awaitIf4() async -> Int {
|
|
return await if .random() { 0 } else { 1 }
|
|
// expected-warning@-1 {{'await' has no effect on 'if' expression}}
|
|
}
|
|
|
|
func awaitIf5() async -> Int {
|
|
return await if .random() { awaitIf4() } else { 1 }
|
|
// expected-warning@-1 {{'await' has no effect on 'if' expression}}
|
|
// expected-warning@-2 {{expression is 'async' but is not marked with 'await'; this is an error in the Swift 6 language mode}}
|
|
// expected-note@-3 {{call is 'async'}}
|
|
}
|
|
|
|
func awaitIf6() async -> Int {
|
|
await if .random() { awaitIf4() } else { 1 }
|
|
// expected-warning@-1 {{'await' has no effect on 'if' expression}}
|
|
// expected-warning@-2 {{expression is 'async' but is not marked with 'await'; this is an error in the Swift 6 language mode}}
|
|
// expected-note@-3 {{call is 'async'}}
|
|
}
|
|
|
|
func awaitIf7() async -> Int {
|
|
let x = await if .random() { awaitIf4() } else { 1 }
|
|
// expected-warning@-1 {{'await' has no effect on 'if' expression}}
|
|
// expected-warning@-2 {{expression is 'async' but is not marked with 'await'; this is an error in the Swift 6 language mode}}
|
|
// expected-note@-3 {{call is 'async'}}
|
|
return x
|
|
}
|
|
|
|
func awaitIf8() async -> Int {
|
|
return await if .random() { await awaitIf4() } else { 1 }
|
|
// expected-warning@-1 {{'await' has no effect on 'if' expression}}
|
|
}
|
|
|
|
func awaitIf9() async -> Int {
|
|
await if .random() { await awaitIf4() } else { 1 }
|
|
// expected-warning@-1 {{'await' has no effect on 'if' expression}}
|
|
}
|
|
|
|
func awaitIf10() async -> Int {
|
|
let x = await if .random() { await awaitIf4() } else { 1 }
|
|
// expected-warning@-1 {{'await' has no effect on 'if' expression}}
|
|
return x
|
|
}
|
|
|
|
func awaitIf11() async -> Int {
|
|
let x = await if .random() { await awaitIf4() } else { awaitIf4() }
|
|
// expected-warning@-1 {{'await' has no effect on 'if' expression}}
|
|
// expected-warning@-2 {{expression is 'async' but is not marked with 'await'; this is an error in the Swift 6 language mode}}
|
|
// expected-note@-3 {{call is 'async'}}
|
|
return x
|
|
}
|
|
|
|
func awaitIf12() async -> Int {
|
|
let x = await if .random() { awaitIf4() } else { awaitIf4() }
|
|
// expected-warning@-1 {{'await' has no effect on 'if' expression}}
|
|
// expected-warning@-2 2{{expression is 'async' but is not marked with 'await'; this is an error in the Swift 6 language mode}}
|
|
// expected-note@-3 2{{call is 'async'}}
|
|
return x
|
|
}
|
|
|
|
func awaitIf13() async throws -> Int {
|
|
let x = await if .random() { // expected-warning {{'await' has no effect on 'if' expression}}
|
|
awaitIf4() // expected-warning {{result of call to 'awaitIf4()' is unused}}
|
|
// expected-warning@-1 {{expression is 'async' but is not marked with 'await'; this is an error in the Swift 6 language mode}}
|
|
// expected-note@-2 {{call is 'async'}}
|
|
|
|
_ = awaitIf4()
|
|
// expected-warning@-1 {{expression is 'async' but is not marked with 'await'; this is an error in the Swift 6 language mode}}
|
|
// expected-note@-2 {{call is 'async'}}
|
|
|
|
_ = await awaitIf4() // Okay.
|
|
|
|
// Okay.
|
|
let _ = {
|
|
_ = await awaitIf4()
|
|
}
|
|
|
|
print("hello")
|
|
throw Err()
|
|
} else {
|
|
0
|
|
}
|
|
return x
|
|
}
|
|
|
|
func asyncBool() async -> Bool { true }
|
|
|
|
func awaitIf14() async -> Int {
|
|
await if asyncBool() { 0 } else { 1 }
|
|
// expected-warning@-1 {{'await' has no effect on 'if' expression}}
|
|
// expected-warning@-2 {{expression is 'async' but is not marked with 'await'; this is an error in the Swift 6 language mode}}
|
|
// expected-note@-3 {{call is 'async'}}
|
|
}
|
|
|
|
func awaitIf15() async -> Int {
|
|
await if await asyncBool() { 0 } else { 1 }
|
|
// expected-warning@-1 {{'await' has no effect on 'if' expression}}
|
|
}
|
|
|
|
func awaitIf16() async -> Int {
|
|
if asyncBool() { 0 } else { 1 }
|
|
// expected-error@-1 {{expression is 'async' but is not marked with 'await'}}
|
|
// expected-note@-2 {{call is 'async'}}
|
|
}
|
|
|
|
func awaitIf17() async -> Int {
|
|
if .random() { awaitIf4() } else { 1 }
|
|
// expected-error@-1 {{expression is 'async' but is not marked with 'await'}}
|
|
// expected-note@-2 {{call is 'async'}}
|
|
}
|
|
|
|
func awaitIf18() {
|
|
let _ = {
|
|
let _ = if .random() { await awaitIf4() } else { 1 }
|
|
}
|
|
}
|
|
|
|
func awaitIf19() async -> Int {
|
|
let x = if .random() { await awaitIf4() } else { 1 }
|
|
return x
|
|
}
|
|
|
|
func awaitIf20() async -> Int {
|
|
if .random() { await awaitIf4() } else { 1 }
|
|
}
|
|
|
|
func tryAwaitIf1() async throws -> Int {
|
|
try await if .random() { 0 } else { 1 }
|
|
// expected-warning@-1 {{'try' has no effect on 'if' expression}}
|
|
// expected-warning@-2 {{'await' has no effect on 'if' expression}}
|
|
}
|
|
|
|
func tryAwaitIf2() async throws -> Int {
|
|
try await if .random() { 0 } else { 1 } as Int
|
|
// expected-warning@-1 {{'try' has no effect on 'if' expression}}
|
|
// expected-warning@-2 {{'await' has no effect on 'if' expression}}
|
|
}
|
|
|
|
func tryAwaitIf3() async throws -> Int {
|
|
try await if .random() { tryAwaitIf2() } else { 1 } as Int
|
|
// expected-warning@-1 {{'try' has no effect on 'if' expression}}
|
|
// expected-warning@-2 {{'await' has no effect on 'if' expression}}
|
|
// expected-warning@-3 {{call can throw but is not marked with 'try'; this is an error in the Swift 6 language mode}}
|
|
// expected-note@-4 {{did you mean to use 'try'?}}
|
|
// expected-note@-5 {{did you mean to handle error as optional value?}}
|
|
// expected-note@-6 {{did you mean to disable error propagation?}}
|
|
// expected-warning@-7 {{expression is 'async' but is not marked with 'await'; this is an error in the Swift 6 language mode}}
|
|
// expected-note@-8 {{call is 'async'}}
|
|
}
|
|
|
|
func tryAwaitIf4() async throws -> Int {
|
|
try await if .random() { try tryAwaitIf2() } else { 1 } as Int
|
|
// expected-warning@-1 {{'try' has no effect on 'if' expression}}
|
|
// expected-warning@-2 {{'await' has no effect on 'if' expression}}
|
|
// expected-warning@-3 {{expression is 'async' but is not marked with 'await'; this is an error in the Swift 6 language mode}}
|
|
// expected-note@-4 {{call is 'async'}}
|
|
}
|
|
|
|
func tryAwaitIf5() async throws -> Int {
|
|
try await if .random() { await tryAwaitIf2() } else { 1 } as Int
|
|
// expected-warning@-1 {{'try' has no effect on 'if' expression}}
|
|
// expected-warning@-2 {{'await' has no effect on 'if' expression}}
|
|
// expected-warning@-3 {{call can throw but is not marked with 'try'; this is an error in the Swift 6 language mode}}
|
|
// expected-note@-4 {{did you mean to use 'try'?}}
|
|
// expected-note@-5 {{did you mean to handle error as optional value?}}
|
|
// expected-note@-6 {{did you mean to disable error propagation?}}
|
|
}
|
|
|
|
func tryAwaitIf6() async throws -> Int {
|
|
try await if .random() { try await tryAwaitIf2() } else { 1 } as Int
|
|
// expected-warning@-1 {{'try' has no effect on 'if' expression}}
|
|
// expected-warning@-2 {{'await' has no effect on 'if' expression}}
|
|
}
|
|
|
|
func tryAwaitIf7() async throws -> Int {
|
|
try await if .random() { tryAwaitIf2() } else { 1 }
|
|
// expected-warning@-1 {{'try' has no effect on 'if' expression}}
|
|
// expected-warning@-2 {{'await' has no effect on 'if' expression}}
|
|
// expected-warning@-3 {{call can throw but is not marked with 'try'; this is an error in the Swift 6 language mode}}
|
|
// expected-note@-4 {{did you mean to use 'try'?}}
|
|
// expected-note@-5 {{did you mean to handle error as optional value?}}
|
|
// expected-note@-6 {{did you mean to disable error propagation?}}
|
|
// expected-warning@-7 {{expression is 'async' but is not marked with 'await'; this is an error in the Swift 6 language mode}}
|
|
// expected-note@-8 {{call is 'async'}}
|
|
}
|
|
|
|
func tryAwaitIf8() async throws -> Int {
|
|
try await if .random() { try tryAwaitIf2() } else { 1 }
|
|
// expected-warning@-1 {{'try' has no effect on 'if' expression}}
|
|
// expected-warning@-2 {{'await' has no effect on 'if' expression}}
|
|
// expected-warning@-3 {{expression is 'async' but is not marked with 'await'; this is an error in the Swift 6 language mode}}
|
|
// expected-note@-4 {{call is 'async'}}
|
|
}
|
|
|
|
func tryAwaitIf9() async throws -> Int {
|
|
try await if .random() { await tryAwaitIf2() } else { 1 }
|
|
// expected-warning@-1 {{'try' has no effect on 'if' expression}}
|
|
// expected-warning@-2 {{'await' has no effect on 'if' expression}}
|
|
// expected-warning@-3 {{call can throw but is not marked with 'try'; this is an error in the Swift 6 language mode}}
|
|
// expected-note@-4 {{did you mean to use 'try'?}}
|
|
// expected-note@-5 {{did you mean to handle error as optional value?}}
|
|
// expected-note@-6 {{did you mean to disable error propagation?}}
|
|
}
|
|
|
|
func tryAwaitIf10() async throws -> Int {
|
|
try await if .random() { try await tryAwaitIf2() } else { 1 }
|
|
// expected-warning@-1 {{'try' has no effect on 'if' expression}}
|
|
// expected-warning@-2 {{'await' has no effect on 'if' expression}}
|
|
}
|
|
|
|
func tryAwaitIf11(_ fn: () async throws -> Int) async rethrows -> Int {
|
|
do {
|
|
let x = if .random() { try await fn() } else { try await tryAwaitIf4() }
|
|
return x
|
|
} catch {
|
|
return 0
|
|
}
|
|
}
|
|
|
|
func tryAwaitIf12(_ fn: () async throws -> Int) async rethrows -> Int {
|
|
do {
|
|
let x = if .random() { try await fn() } else { throw Err() }
|
|
return x
|
|
} catch {
|
|
return 0
|
|
}
|
|
}
|
|
|
|
func tryAwaitIf13(_ fn: () async throws -> Int) async rethrows -> Int {
|
|
do {
|
|
let x = if .random() { try await fn() } else { try await tryAwaitIf4() }
|
|
return x
|
|
} catch {
|
|
throw error // expected-error {{a function declared 'rethrows' may only throw if its parameter does}}
|
|
}
|
|
}
|
|
|
|
func tryAwaitIf14(_ fn: () async throws -> Int) async rethrows -> Int {
|
|
do {
|
|
let x = if .random() { try await fn() } else { throw Err() }
|
|
return x
|
|
} catch {
|
|
throw error // expected-error {{a function declared 'rethrows' may only throw if its parameter does}}
|
|
}
|
|
}
|
|
|
|
func tryAwaitIf15(_ fn: () async throws -> Int) async rethrows -> Int {
|
|
do {
|
|
let x = if .random() { try await fn() } else { 0 }
|
|
return x
|
|
} catch {
|
|
throw error // Okay.
|
|
}
|
|
}
|
|
|
|
func asyncLetIf(cond: Bool, _ fn: () async throws -> Int) async throws -> Int {
|
|
async let x = if cond {
|
|
fn()
|
|
} else {
|
|
0
|
|
}
|
|
|
|
return try await x
|
|
}
|
|
|
|
struct AnyEraserP: EraserP {
|
|
init<T: EraserP>(erasing: T) {}
|
|
}
|
|
|
|
@_typeEraser(AnyEraserP)
|
|
protocol EraserP {}
|
|
struct SomeEraserP: EraserP {}
|
|
|
|
// rdar://113435870 - Make sure we allow an implicit init(erasing:) call.
|
|
dynamic func testDynamicOpaqueErase() -> some EraserP {
|
|
if .random() { SomeEraserP() } else { SomeEraserP() }
|
|
}
|
|
|
|
struct NonExhaustiveProperty {
|
|
let i = if .random() { 0 }
|
|
// expected-error@-1 {{'if' must have an unconditional 'else' to be used as expression}}
|
|
}
|
|
|
|
// MARK: Out of place if exprs
|
|
|
|
func inDefaultArg(x: Int = if .random() { 0 } else { 0 }) {}
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
|
|
func inDefaultArg2(x: Int = { (if .random() { 0 } else { 0 }) }()) {}
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
|
|
struct InType {
|
|
let inPropertyInit1 = if .random() { 0 } else { 1 }
|
|
let inPropertyInit2 = (if .random() { 0 } else { 1 })
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
|
|
let inPropertyInit3 = {
|
|
let _ = if .random() { 0 } else { 1 }
|
|
let _ = (if .random() { 0 } else { 1 })
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
|
|
func foo() {
|
|
let _ = if .random() { 0 } else { 1 }
|
|
let _ = (if .random() { 0 } else { 1 })
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
}
|
|
if .random() {
|
|
return if .random() { 0 } else { 1 }
|
|
} else {
|
|
return (if .random() { 0 } else { 1 })
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
}
|
|
}
|
|
|
|
subscript(x: Int = if .random() { 0 } else { 0 }) -> Int {
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
|
|
let _ = if .random() { 0 } else { 1 }
|
|
let _ = (if .random() { 0 } else { 1 })
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
return 0
|
|
}
|
|
}
|
|
|
|
func testCaptureList() {
|
|
let _ = { [x = if .random() { 0 } else { 1 }] in x }
|
|
let _ = { [x = (if .random() { 0 } else { 1 })] in x }
|
|
// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
}
|