mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
406 lines
17 KiB
Swift
406 lines
17 KiB
Swift
// RUN: %empty-directory(%t)
|
|
// RUN: %target-build-swift -Onone %s -o %t/a.out
|
|
// RUN: %target-build-swift -O %s -o %t/a.out.optimized
|
|
// RUN: %target-codesign %t/a.out
|
|
// RUN: %target-codesign %t/a.out.optimized
|
|
//
|
|
// RUN: %target-run %t/a.out | %FileCheck --check-prefix CHECK %s
|
|
// RUN: %target-run %t/a.out.optimized | %FileCheck --check-prefix CHECK %s
|
|
|
|
// RUN: %target-build-swift -Onone %s -o %t/a.out
|
|
// RUN: %target-build-swift -O %s -o %t/a.out.optimized
|
|
// RUN: %target-codesign %t/a.out
|
|
// RUN: %target-codesign %t/a.out.optimized
|
|
//
|
|
// RUN: %target-run %t/a.out | %FileCheck --check-prefix CHECK %s
|
|
// RUN: %target-run %t/a.out.optimized | %FileCheck --check-prefix CHECK %s
|
|
|
|
// REQUIRES: executable_test
|
|
|
|
// FIXME: rdar://problem/19648117 Needs splitting objc parts out
|
|
|
|
#if canImport(Foundation)
|
|
import Foundation
|
|
#endif
|
|
|
|
func allToInt<T>(_ x: T) -> Int {
|
|
return x as! Int
|
|
}
|
|
|
|
func allToIntOrZero<T>(_ x: T) -> Int {
|
|
if x is Int {
|
|
return x as! Int
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func anyToInt(_ x: Any) -> Int {
|
|
return x as! Int
|
|
}
|
|
|
|
func anyToIntOrZero(_ x: Any) -> Int {
|
|
if x is Int {
|
|
return x as! Int
|
|
}
|
|
return 0
|
|
}
|
|
|
|
protocol Class : class {}
|
|
|
|
class C : Class {
|
|
|
|
func print() { Swift.print("C!") }
|
|
}
|
|
class D : C {
|
|
override func print() { Swift.print("D!") }
|
|
}
|
|
|
|
class E : C {
|
|
override func print() { Swift.print("E!") }
|
|
}
|
|
|
|
class X : Class {
|
|
}
|
|
|
|
func allToC<T>(_ x: T) -> C {
|
|
return x as! C
|
|
}
|
|
|
|
func allToCOrE<T>(_ x: T) -> C {
|
|
if x is C {
|
|
return x as! C
|
|
}
|
|
return E()
|
|
}
|
|
|
|
func anyToC(_ x: Any) -> C {
|
|
return x as! C
|
|
}
|
|
|
|
func anyToCOrE(_ x: Any) -> C {
|
|
if x is C {
|
|
return x as! C
|
|
}
|
|
return E()
|
|
}
|
|
|
|
func allClassesToC<T : Class>(_ x: T) -> C {
|
|
return x as! C
|
|
}
|
|
|
|
func allClassesToCOrE<T : Class>(_ x: T) -> C {
|
|
if x is C {
|
|
return x as! C
|
|
}
|
|
return E()
|
|
}
|
|
|
|
func anyClassToC(_ x: Class) -> C {
|
|
return x as! C
|
|
}
|
|
|
|
func anyClassToCOrE(_ x: Class) -> C {
|
|
if x is C {
|
|
return x as! C
|
|
}
|
|
return E()
|
|
}
|
|
|
|
func allToAll<T, U>(_ t: T, _: U.Type) -> Bool {
|
|
return t is U
|
|
}
|
|
|
|
func allMetasToAllMetas<T, U>(_: T.Type, _: U.Type) -> Bool {
|
|
return T.self is U.Type
|
|
}
|
|
|
|
print(allToInt(22)) // CHECK: 22
|
|
print(anyToInt(44)) // CHECK: 44
|
|
allToC(C()).print() // CHECK: C!
|
|
allToC(D()).print() // CHECK: D!
|
|
anyToC(C()).print() // CHECK: C!
|
|
anyToC(D()).print() // CHECK: D!
|
|
allClassesToC(C()).print() // CHECK: C!
|
|
allClassesToC(D()).print() // CHECK: D!
|
|
anyClassToC(C()).print() // CHECK: C!
|
|
anyClassToC(D()).print() // CHECK: D!
|
|
|
|
print(allToIntOrZero(55)) // CHECK: 55
|
|
print(allToIntOrZero("fifty-five")) // CHECK: 0
|
|
print(anyToIntOrZero(88)) // CHECK: 88
|
|
print(anyToIntOrZero("eighty-eight")) // CHECK: 0
|
|
allToCOrE(C()).print() // CHECK: C!
|
|
allToCOrE(D()).print() // CHECK: D!
|
|
allToCOrE(143).print() // CHECK: E!
|
|
allToCOrE(X()).print() // CHECK: E!
|
|
anyToCOrE(C()).print() // CHECK: C!
|
|
anyToCOrE(D()).print() // CHECK: D!
|
|
anyToCOrE(143).print() // CHECK: E!
|
|
anyToCOrE(X()).print() // CHECK: E!
|
|
allClassesToCOrE(C()).print() // CHECK: C!
|
|
allClassesToCOrE(D()).print() // CHECK: D!
|
|
allClassesToCOrE(X()).print() // CHECK: E!
|
|
anyClassToCOrE(C()).print() // CHECK: C!
|
|
anyClassToCOrE(D()).print() // CHECK: D!
|
|
anyClassToCOrE(X()).print() // CHECK: E!
|
|
|
|
protocol P {}
|
|
struct PS: P {}
|
|
enum PE: P {}
|
|
class PC: P {}
|
|
class PCSub: PC {}
|
|
|
|
// `is` checks
|
|
func nongenericAnyIsPType(type: Any.Type) -> Bool {
|
|
// `is P.Type` tests whether the argument conforms to `P`
|
|
// Note: this can only be true for a concrete type, never a protocol
|
|
return type is P.Type
|
|
}
|
|
func nongenericAnyIsPProtocol(type: Any.Type) -> Bool {
|
|
// `P.Protocol` is the metatype for `P` (the type of `P.self`)
|
|
// `is P.Protocol` tests whether the argument is a subtype of `P`
|
|
// In particular, it is true for `P.self`
|
|
return type is P.Protocol
|
|
}
|
|
func nongenericAnyIsPAndAnyObjectType(type: Any.Type) -> Bool {
|
|
return type is (P & AnyObject).Type
|
|
}
|
|
func nongenericAnyIsPAndAnyObjectProtocol(type: Any.Type) -> Bool {
|
|
return type is (P & AnyObject).Protocol
|
|
}
|
|
func nongenericAnyIsPAndPCSubType(type: Any.Type) -> Bool {
|
|
return type is (P & PCSub).Type
|
|
}
|
|
func genericAnyIs<T>(type: Any.Type, to: T.Type, expected: Bool) -> Bool {
|
|
// If we're testing against a runtime that doesn't have the fix this tests,
|
|
// just pretend we got it right.
|
|
if #available(SwiftStdlib 5.2, *) {
|
|
// Remember: If `T` is bound to `P`, then `T.Type` is `P.Protocol`
|
|
return type is T.Type
|
|
} else {
|
|
return expected
|
|
}
|
|
}
|
|
// `as?` checks
|
|
func nongenericAnyAsConditionalPType(type: Any.Type) -> Bool {
|
|
return (type as? P.Type) != nil
|
|
}
|
|
func nongenericAnyAsConditionalPProtocol(type: Any.Type) -> Bool {
|
|
return (type as? P.Protocol) != nil
|
|
}
|
|
func nongenericAnyAsConditionalPAndAnyObjectType(type: Any.Type) -> Bool {
|
|
return (type as? (P & AnyObject).Type) != nil
|
|
}
|
|
func nongenericAnyAsConditionalPAndAnyObjectProtocol(type: Any.Type) -> Bool {
|
|
return (type as? (P & AnyObject).Protocol) != nil
|
|
}
|
|
func nongenericAnyAsConditionalPAndPCSubType(type: Any.Type) -> Bool {
|
|
return (type as? (P & PCSub).Type) != nil
|
|
}
|
|
func genericAnyAsConditional<T>(type: Any.Type, to: T.Type, expected: Bool) -> Bool {
|
|
// If we're testing against a runtime that doesn't have the fix this tests,
|
|
// just pretend we got it right.
|
|
if #available(SwiftStdlib 5.3, *) {
|
|
return (type as? T.Type) != nil
|
|
} else {
|
|
return expected
|
|
}
|
|
}
|
|
// `as!` checks
|
|
func blackhole<T>(_ : T) { }
|
|
|
|
func nongenericAnyAsUnconditionalPType(type: Any.Type) -> Bool {
|
|
blackhole(type as! P.Type)
|
|
return true
|
|
}
|
|
func nongenericAnyAsUnconditionalPProtocol(type: Any.Type) -> Bool {
|
|
blackhole(type as! P.Protocol)
|
|
return true
|
|
}
|
|
func nongenericAnyAsUnconditionalPAndAnyObjectType(type: Any.Type) -> Bool {
|
|
blackhole(type as! (P & AnyObject).Type)
|
|
return true
|
|
}
|
|
func nongenericAnyAsUnconditionalPAndPCSubType(type: Any.Type) -> Bool {
|
|
blackhole(type as! (P & PCSub).Type)
|
|
return true
|
|
}
|
|
func genericAnyAsUnconditional<T>(type: Any.Type, to: T.Type, expected: Bool) -> Bool {
|
|
if #available(SwiftStdlib 5.3, *) {
|
|
blackhole(type as! T.Type)
|
|
}
|
|
return true
|
|
}
|
|
|
|
// CHECK-LABEL: casting types to protocols with generics:
|
|
print("casting types to protocols with generics:")
|
|
print(#line, nongenericAnyIsPType(type: P.self)) // CHECK: [[@LINE]] false
|
|
print(#line, nongenericAnyIsPProtocol(type: P.self)) // CHECK: [[@LINE]] true
|
|
print(#line, genericAnyIs(type: P.self, to: P.self, expected: true)) // CHECK: [[@LINE]] true
|
|
print(#line, nongenericAnyIsPType(type: PS.self)) // CHECK: [[@LINE]] true
|
|
print(#line, PS() is P) // CHECK: [[@LINE]] true
|
|
// One candidate for a Swift type theory holds that
|
|
// `A is a subtype of B iff A.self is metatype<B>`
|
|
// In that theory, `PS() is P` above would imply that
|
|
// `PS.self is P.Protocol` below must also be true.
|
|
// But that theory is not the one that Swift currently
|
|
// implements.
|
|
print(#line, nongenericAnyIsPProtocol(type: PS.self)) // CHECK: [[@LINE]] false
|
|
print(#line, genericAnyIs(type: PS.self, to: P.self, expected: false)) // CHECK: [[@LINE]] false
|
|
print(#line, nongenericAnyIsPType(type: PE.self)) // CHECK: [[@LINE]] true
|
|
print(#line, nongenericAnyIsPProtocol(type: PE.self)) // CHECK: [[@LINE]] false
|
|
print(#line, genericAnyIs(type: PE.self, to: P.self, expected: false)) // CHECK: [[@LINE]] false
|
|
print(#line, nongenericAnyIsPType(type: PC.self)) // CHECK: [[@LINE]] true
|
|
print(#line, nongenericAnyIsPProtocol(type: PC.self)) // CHECK: [[@LINE]] false
|
|
print(#line, genericAnyIs(type: PC.self, to: P.self, expected: false)) // CHECK: [[@LINE]] false
|
|
print(#line, nongenericAnyIsPType(type: PCSub.self)) // CHECK: [[@LINE]] true
|
|
print(#line, nongenericAnyIsPProtocol(type: PCSub.self)) // CHECK: [[@LINE]] false
|
|
print(#line, genericAnyIs(type: PCSub.self, to: P.self, expected: false)) // CHECK: [[@LINE]] false
|
|
|
|
// CHECK-LABEL: conditionally casting types to protocols with generics:
|
|
print(#line, "conditionally casting types to protocols with generics:")
|
|
print(#line, nongenericAnyAsConditionalPType(type: P.self)) // CHECK: [[@LINE]] false
|
|
print(#line, nongenericAnyAsConditionalPProtocol(type: P.self)) // CHECK: [[@LINE]] true
|
|
print(#line, genericAnyAsConditional(type: P.self, to: P.self, expected: true)) // CHECK: [[@LINE]] true
|
|
print(#line, nongenericAnyAsConditionalPType(type: PS.self)) // CHECK: [[@LINE]] true
|
|
print(#line, nongenericAnyAsConditionalPProtocol(type: PS.self)) // CHECK: [[@LINE]] false
|
|
print(#line, genericAnyAsConditional(type: PS.self, to: P.self, expected: false)) // CHECK: [[@LINE]] false
|
|
print(#line, nongenericAnyAsConditionalPType(type: PE.self)) // CHECK: [[@LINE]] true
|
|
print(#line, nongenericAnyAsConditionalPProtocol(type: PE.self)) // CHECK: [[@LINE]] false
|
|
print(#line, genericAnyAsConditional(type: PE.self, to: P.self, expected: false)) // CHECK: [[@LINE]] false
|
|
print(#line, nongenericAnyAsConditionalPType(type: PC.self)) // CHECK: [[@LINE]] true
|
|
print(#line, nongenericAnyAsConditionalPProtocol(type: PC.self)) // CHECK: [[@LINE]] false
|
|
print(#line, genericAnyAsConditional(type: PC.self, to: P.self, expected: false)) // CHECK: [[@LINE]] false
|
|
print(#line, nongenericAnyAsConditionalPType(type: PCSub.self)) // CHECK: [[@LINE]] true
|
|
print(#line, nongenericAnyAsConditionalPProtocol(type: PCSub.self)) // CHECK: [[@LINE]] false
|
|
print(#line, genericAnyAsConditional(type: PCSub.self, to: P.self, expected: false)) // CHECK: [[@LINE]] false
|
|
|
|
// CHECK-LABEL: unconditionally casting types to protocols with generics:
|
|
print(#line, "unconditionally casting types to protocols with generics:")
|
|
//print(#line, nongenericAnyAsUnconditionalPType(type: P.self)) // expected to trap
|
|
print(#line, nongenericAnyAsUnconditionalPProtocol(type: P.self)) // CHECK: [[@LINE]] true
|
|
print(#line, genericAnyAsUnconditional(type: P.self, to: P.self, expected: true)) // CHECK: [[@LINE]] true
|
|
print(#line, nongenericAnyAsUnconditionalPType(type: PS.self)) // CHECK: [[@LINE]] true
|
|
print(#line, genericAnyAsUnconditional(type: PS.self, to: P.self, expected: true)) // CHECK: [[@LINE]] true
|
|
print(#line, nongenericAnyAsUnconditionalPType(type: PE.self)) // CHECK: [[@LINE]] true
|
|
print(#line, genericAnyAsUnconditional(type: PE.self, to: P.self, expected: true)) // CHECK: [[@LINE]] true
|
|
print(#line, nongenericAnyAsUnconditionalPType(type: PC.self)) // CHECK: [[@LINE]] true
|
|
print(#line, genericAnyAsUnconditional(type: PC.self, to: P.self, expected: true)) // CHECK: [[@LINE]] true
|
|
print(#line, nongenericAnyAsUnconditionalPType(type: PCSub.self)) // CHECK: [[@LINE]] true
|
|
print(#line, genericAnyAsUnconditional(type: PCSub.self, to: P.self, expected: true)) // CHECK: [[@LINE]] true
|
|
|
|
// CHECK-LABEL: casting types to protocol & AnyObject existentials:
|
|
print(#line, "casting types to protocol & AnyObject existentials:")
|
|
print(#line, nongenericAnyIsPAndAnyObjectType(type: PS.self)) // CHECK: [[@LINE]] false
|
|
print(#line, genericAnyIs(type: PS.self, to: (P & AnyObject).self, expected: false)) // CHECK: [[@LINE]] false
|
|
print(#line, nongenericAnyIsPAndAnyObjectType(type: PE.self)) // CHECK: [[@LINE]] false
|
|
print(#line, genericAnyIs(type: PE.self, to: (P & AnyObject).self, expected: false)) // CHECK: [[@LINE]] false
|
|
print(#line, nongenericAnyIsPAndAnyObjectType(type: PC.self)) // CHECK: [[@LINE]] true
|
|
print(#line, nongenericAnyIsPAndAnyObjectProtocol(type: PC.self)) // CHECK: [[@LINE]] false
|
|
print(#line, genericAnyIs(type: PC.self, to: (P & AnyObject).self, expected: false)) // CHECK: [[@LINE]] false
|
|
print(#line, nongenericAnyIsPAndAnyObjectType(type: PCSub.self)) // CHECK: [[@LINE]] true
|
|
print(#line, nongenericAnyIsPAndAnyObjectProtocol(type: PCSub.self)) // CHECK: [[@LINE]] false
|
|
print(#line, genericAnyIs(type: PCSub.self, to: (P & AnyObject).self, expected: false)) // CHECK: [[@LINE]] false
|
|
print(#line, nongenericAnyAsConditionalPAndAnyObjectType(type: PS.self)) // CHECK: [[@LINE]] false
|
|
print(#line, genericAnyAsConditional(type: PS.self, to: (P & AnyObject).self, expected: false)) // CHECK: [[@LINE]] false
|
|
print(#line, nongenericAnyAsConditionalPAndAnyObjectType(type: PE.self)) // CHECK: [[@LINE]] false
|
|
print(#line, genericAnyAsConditional(type: PE.self, to: (P & AnyObject).self, expected: false)) // CHECK: [[@LINE]] false
|
|
print(#line, nongenericAnyAsConditionalPAndAnyObjectType(type: PC.self)) // CHECK: [[@LINE]] true
|
|
print(#line, nongenericAnyAsConditionalPAndAnyObjectProtocol(type: PC.self)) // CHECK: [[@LINE]] false
|
|
print(#line, genericAnyAsConditional(type: PC.self, to: (P & AnyObject).self, expected: false)) // CHECK: [[@LINE]] false
|
|
print(#line, nongenericAnyAsConditionalPAndAnyObjectType(type: PCSub.self)) // CHECK: [[@LINE]] true
|
|
print(#line, genericAnyAsConditional(type: PCSub.self, to: (P & AnyObject).self, expected: false)) // CHECK: [[@LINE]] false
|
|
|
|
// CHECK-LABEL: casting types to protocol & class existentials:
|
|
print(#line, "casting types to protocol & class existentials:")
|
|
print(#line, nongenericAnyIsPAndPCSubType(type: PS.self)) // CHECK: [[@LINE]] false
|
|
print(#line, genericAnyIs(type: PS.self, to: (P & PCSub).self, expected: false)) // CHECK: [[@LINE]] false
|
|
print(#line, nongenericAnyIsPAndPCSubType(type: PE.self)) // CHECK: [[@LINE]] false
|
|
print(#line, genericAnyIs(type: PE.self, to: (P & PCSub).self, expected: false)) // CHECK: [[@LINE]] false
|
|
// FIXME: reenable this when https://github.com/apple/swift/issues/53970 is fixed
|
|
//print(#line, nongenericAnyIsPAndPCSubType(type: PC.self)) // C HECK: [[@LINE]] false
|
|
print(#line, genericAnyIs(type: PC.self, to: (P & PCSub).self, expected: false)) // CHECK: [[@LINE]] false
|
|
print(#line, nongenericAnyIsPAndPCSubType(type: PCSub.self)) // CHECK: [[@LINE]] true
|
|
print(#line, genericAnyIs(type: PCSub.self, to: (P & PCSub).self, expected: false)) // CHECK: [[@LINE]] false
|
|
print(#line, nongenericAnyAsConditionalPAndPCSubType(type: PS.self)) // CHECK: [[@LINE]] false
|
|
print(#line, genericAnyAsConditional(type: PS.self, to: (P & PCSub).self, expected: false)) // CHECK: [[@LINE]] false
|
|
print(#line, nongenericAnyAsConditionalPAndPCSubType(type: PE.self)) // CHECK: [[@LINE]] false
|
|
print(#line, genericAnyAsConditional(type: PE.self, to: (P & PCSub).self, expected: false)) // CHECK: [[@LINE]] false
|
|
// FIXME: reenable this when https://github.com/apple/swift/issues/53970 is fixed
|
|
// print(#line, nongenericAnyAsConditionalPAndPCSubType(type: PC.self)) // C HECK: [[@LINE]] false
|
|
print(#line, genericAnyAsConditional(type: PC.self, to: (P & PCSub).self, expected: false)) // CHECK: [[@LINE]] false
|
|
print(#line, nongenericAnyAsConditionalPAndPCSubType(type: PCSub.self)) // CHECK: [[@LINE]] true
|
|
print(#line, genericAnyAsConditional(type: PCSub.self, to: (P & PCSub).self, expected: false)) // CHECK: [[@LINE]] false
|
|
|
|
|
|
// CHECK-LABEL: type comparisons:
|
|
print(#line, "type comparisons:\n")
|
|
print(#line, allMetasToAllMetas(Int.self, Int.self)) // CHECK: [[@LINE]] true
|
|
print(#line, allMetasToAllMetas(Int.self, Float.self)) // CHECK: [[@LINE]] false
|
|
print(#line, allMetasToAllMetas(C.self, C.self)) // CHECK: [[@LINE]] true
|
|
print(#line, allMetasToAllMetas(D.self, C.self)) // CHECK: [[@LINE]] true
|
|
print(#line, allMetasToAllMetas(C.self, D.self)) // CHECK: [[@LINE]] false
|
|
print(#line, C.self is D.Type) // CHECK: [[@LINE]] false
|
|
print(#line, (D.self as C.Type) is D.Type) // CHECK: [[@LINE]] true
|
|
|
|
let t: Any.Type = type(of: 1 as Any)
|
|
print(#line, t is Int.Type) // CHECK: [[@LINE]] true
|
|
print(#line, t is Float.Type) // CHECK: [[@LINE]] false
|
|
print(#line, t is C.Type) // CHECK: [[@LINE]] false
|
|
|
|
let u: Any.Type = type(of: (D() as Any))
|
|
print(#line, u is C.Type) // CHECK: [[@LINE]] true
|
|
print(#line, u is D.Type) // CHECK: [[@LINE]] true
|
|
print(#line, u is E.Type) // CHECK: [[@LINE]] false
|
|
print(#line, u is Int.Type) // CHECK: [[@LINE]] false
|
|
|
|
// FIXME: Can't spell AnyObject.Protocol
|
|
// CHECK-LABEL: AnyObject casts:
|
|
print(#line, "AnyObject casts:")
|
|
print(#line, allToAll(C(), AnyObject.self)) // CHECK: [[@LINE]] true
|
|
|
|
// On Darwin, the object will be the ObjC-runtime-class object;
|
|
// out of Darwin, this should not succeed.
|
|
print(#line, allToAll(type(of: C()), AnyObject.self))
|
|
// CHECK-objc: true
|
|
// CHECK-native: false
|
|
|
|
// Bridging
|
|
// NSNumber on Darwin, __SwiftValue on Linux.
|
|
print(#line, allToAll(0, AnyObject.self)) // CHECK: [[@LINE]] true
|
|
|
|
// This will get bridged using __SwiftValue.
|
|
struct NotBridged { var x: Int }
|
|
print(#line, allToAll(NotBridged(x: 0), AnyObject.self)) // CHECK: [[@LINE]] true
|
|
|
|
#if canImport(Foundation)
|
|
// This requires Foundation (for NSCopying):
|
|
print(#line, allToAll(NotBridged(x: 0), NSCopying.self)) // CHECK-objc: [[@LINE]] true
|
|
#endif
|
|
|
|
// On Darwin, these casts fail (intentionally) even though __SwiftValue does
|
|
// technically conform to these protocols through NSObject.
|
|
// Off Darwin, it should not conform at all.
|
|
print(#line, allToAll(NotBridged(x: 0), CustomStringConvertible.self)) // CHECK: [[@LINE]] false
|
|
print(#line, allToAll(NotBridged(x: 0), (AnyObject & CustomStringConvertible).self)) // CHECK: [[@LINE]] false
|
|
|
|
#if canImport(Foundation)
|
|
// This requires Foundation (for NSArray):
|
|
//
|
|
// rdar://problem/19482567
|
|
//
|
|
|
|
func swiftOptimizesThisFunctionIncorrectly() -> Bool {
|
|
let anArray = [] as NSArray
|
|
|
|
if let whyThisIsNeverExecutedIfCalledFromFunctionAndNotFromMethod = anArray as? [NSObject] {
|
|
return true
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
let result = swiftOptimizesThisFunctionIncorrectly()
|
|
print(#line, "Bridge cast result: \(result)") // CHECK-NEXT-objc: Bridge cast result: true
|
|
#endif
|