mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
1418 lines
46 KiB
Swift
1418 lines
46 KiB
Swift
// RUN: %target-typecheck-verify-swift -verify-ignore-unrelated
|
|
|
|
func myMap<T1, T2>(_ array: [T1], _ fn: (T1) -> T2) -> [T2] {}
|
|
|
|
var intArray : [Int]
|
|
|
|
_ = myMap(intArray, { String($0) })
|
|
_ = myMap(intArray, { x -> String in String(x) } )
|
|
|
|
// Closures with too few parameters.
|
|
func foo(_ x: (Int, Int) -> Int) {}
|
|
foo({$0}) // expected-error{{contextual closure type '(Int, Int) -> Int' expects 2 arguments, but 1 was used in closure body}}
|
|
foo({ [intArray] in $0}) // expected-error{{contextual closure type '(Int, Int) -> Int' expects 2 arguments, but 1 was used in closure body}}
|
|
|
|
struct X {}
|
|
func mySort(_ array: [String], _ predicate: (String, String) -> Bool) -> [String] {}
|
|
func mySort(_ array: [X], _ predicate: (X, X) -> Bool) -> [X] {}
|
|
var strings : [String]
|
|
_ = mySort(strings, { x, y in x < y })
|
|
|
|
// Closures with inout arguments.
|
|
func f0<T, U>(_ t: T, _ f: (inout T) -> U) -> U {
|
|
var t2 = t
|
|
return f(&t2)
|
|
}
|
|
|
|
struct X2 {
|
|
func g() -> Float { return 0 }
|
|
}
|
|
|
|
_ = f0(X2(), {$0.g()})
|
|
|
|
// Closures with inout arguments and '__shared' conversions.
|
|
|
|
func inoutToSharedConversions() {
|
|
func fooOW<T, U>(_ f : (__owned T) -> U) {}
|
|
fooOW({ (x : Int) in return Int(5) }) // defaut-to-'__owned' allowed
|
|
fooOW({ (x : __owned Int) in return Int(5) }) // '__owned'-to-'__owned' allowed
|
|
fooOW({ (x : __shared Int) in return Int(5) }) // '__shared'-to-'__owned' allowed
|
|
fooOW({ (x : inout Int) in return Int(5) }) // expected-error {{cannot convert value of type '(inout Int) -> Int' to expected argument type '(__owned Int) -> Int'}}
|
|
|
|
func fooIO<T, U>(_ f : (inout T) -> U) {}
|
|
fooIO({ (x : inout Int) in return Int(5) }) // 'inout'-to-'inout' allowed
|
|
fooIO({ (x : Int) in return Int(5) }) // expected-error {{cannot convert value of type '(Int) -> Int' to expected argument type '(inout Int) -> Int'}}
|
|
fooIO({ (x : __shared Int) in return Int(5) }) // expected-error {{cannot convert value of type '(__shared Int) -> Int' to expected argument type '(inout Int) -> Int'}}
|
|
fooIO({ (x : __owned Int) in return Int(5) }) // expected-error {{cannot convert value of type '(__owned Int) -> Int' to expected argument type '(inout Int) -> Int'}}
|
|
|
|
func fooSH<T, U>(_ f : (__shared T) -> U) {}
|
|
fooSH({ (x : __shared Int) in return Int(5) }) // '__shared'-to-'__shared' allowed
|
|
fooSH({ (x : __owned Int) in return Int(5) }) // '__owned'-to-'__shared' allowed
|
|
fooSH({ (x : inout Int) in return Int(5) }) // expected-error {{cannot convert value of type '(inout Int) -> Int' to expected argument type '(__shared Int) -> Int'}}
|
|
fooSH({ (x : Int) in return Int(5) }) // default-to-'__shared' allowed
|
|
}
|
|
|
|
// Autoclosure
|
|
func f1(f: @autoclosure () -> Int) { }
|
|
func f2() -> Int { }
|
|
f1(f: f2) // expected-error{{add () to forward '@autoclosure' parameter}}{{9-9=()}}
|
|
f1(f: 5)
|
|
|
|
// Ternary in closure
|
|
var evenOrOdd : (Int) -> String = {$0 % 2 == 0 ? "even" : "odd"}
|
|
|
|
// <rdar://problem/15367882>
|
|
func foo() {
|
|
not_declared({ $0 + 1 }) // expected-error{{cannot find 'not_declared' in scope}}
|
|
}
|
|
|
|
// <rdar://problem/15536725>
|
|
struct X3<T> {
|
|
init(_: (T) -> ()) {}
|
|
}
|
|
|
|
func testX3(_ x: Int) {
|
|
var x = x
|
|
_ = X3({ x = $0 })
|
|
_ = x
|
|
}
|
|
|
|
// <rdar://problem/13811882>
|
|
func test13811882() {
|
|
var _ : (Int) -> (Int, Int) = {($0, $0)}
|
|
var x = 1
|
|
var _ : (Int) -> (Int, Int) = {($0, x)}
|
|
x = 2
|
|
}
|
|
|
|
|
|
/// <rdar://problem/21544303>
|
|
/// https://github.com/apple/swift/issues/46256
|
|
/// QoI: "Unexpected trailing closure" should have a fixit to insert a `do`
|
|
/// statement
|
|
do {
|
|
var inSubcall = true
|
|
{ // expected-error {{closure expression is unused}} expected-note {{did you mean to use a 'do' statement?}}
|
|
}
|
|
inSubcall = false
|
|
|
|
// These are a problems, but it's not clear what was intended.
|
|
var somethingElse = true {
|
|
// expected-error@-1 {{computed property must have an explicit type}}
|
|
// expected-error@-2 {{variable with getter/setter cannot have an initial value}}
|
|
}
|
|
var somethingElseWithTypeAnno: Bool = true {} // expected-error {{variable with getter/setter cannot have an initial value}}
|
|
inSubcall = false
|
|
|
|
var v2 : Bool = false
|
|
v2 = inSubcall // expected-error {{cannot call value of non-function type 'Bool'}}
|
|
{
|
|
}
|
|
}
|
|
|
|
|
|
// https://github.com/apple/swift/issues/46256
|
|
do {
|
|
let n = 42
|
|
func consume(_ x: Int) {}
|
|
|
|
{ consume($0) }(42)
|
|
;
|
|
|
|
({ $0(42) } { consume($0) }) // expected-error {{cannot call value of non-function type '()'}} expected-note {{callee is here}}
|
|
|
|
{ print(42) } // expected-warning {{braces here form a trailing closure separated from its callee by multiple newlines}} expected-note {{did you mean to use a 'do' statement?}} {{3-3=do }}
|
|
;
|
|
|
|
({ $0(42) } { consume($0) }) // expected-error {{cannot call value of non-function type '()'}} expected-note {{callee is here}}
|
|
|
|
{ print($0) } // expected-warning {{braces here form a trailing closure separated from its callee by multiple newlines}}
|
|
;
|
|
|
|
({ $0(42) } { consume($0) }) // expected-error {{cannot call value of non-function type '()'}} expected-note {{callee is here}}
|
|
|
|
{ [n] in print(42) } // expected-warning {{braces here form a trailing closure separated from its callee by multiple newlines}}
|
|
;
|
|
|
|
({ $0(42) } { consume($0) }) // expected-error {{cannot call value of non-function type '()'}} expected-note {{callee is here}}
|
|
|
|
{ consume($0) }(42) // expected-warning {{braces here form a trailing closure separated from its callee by multiple newlines}}
|
|
;
|
|
|
|
({ $0(42) } { consume($0) }) // expected-error {{cannot call value of non-function type '()'}} expected-note {{callee is here}}
|
|
|
|
{ (x: Int) in consume(x) }(42) // expected-warning {{braces here form a trailing closure separated from its callee by multiple newlines}}
|
|
;
|
|
|
|
// This is technically a valid call, so nothing goes wrong until (42)
|
|
|
|
{ $0(3) } // expected-error {{cannot call value of non-function type '()'}}
|
|
{ consume($0) }(42)
|
|
;
|
|
({ $0(42) }) // expected-error {{cannot call value of non-function type '()'}}
|
|
{ consume($0) }(42)
|
|
;
|
|
{ $0(3) } // expected-error {{cannot call value of non-function type '()'}}
|
|
{ [n] in consume($0) }(42)
|
|
;
|
|
({ $0(42) }) // expected-error {{cannot call value of non-function type '()'}}
|
|
{ [n] in consume($0) }(42)
|
|
;
|
|
|
|
// Equivalent but more obviously unintended.
|
|
|
|
{ $0(3) } // expected-error {{cannot call value of non-function type '()'}} expected-note {{callee is here}}
|
|
|
|
{ consume($0) }(42)
|
|
// expected-warning@-1 {{braces here form a trailing closure separated from its callee by multiple newlines}}
|
|
|
|
({ $0(3) }) // expected-error {{cannot call value of non-function type '()'}} expected-note {{callee is here}}
|
|
|
|
{ consume($0) }(42)
|
|
// expected-warning@-1 {{braces here form a trailing closure separated from its callee by multiple newlines}}
|
|
;
|
|
|
|
// Also a valid call (!!)
|
|
{ $0 { $0 } } { $0 { 1 } } // expected-error {{function is unused}}
|
|
consume(111)
|
|
}
|
|
|
|
|
|
// <rdar://problem/22162441> Crash from failing to diagnose nonexistent method access inside closure
|
|
func r22162441(_ lines: [String]) {
|
|
_ = lines.map { line in line.fooBar() } // expected-error {{value of type 'String' has no member 'fooBar'}}
|
|
_ = lines.map { $0.fooBar() } // expected-error {{value of type 'String' has no member 'fooBar'}}
|
|
}
|
|
|
|
|
|
func testMap() {
|
|
let a = 42
|
|
[1,a].map { $0 + 1.0 } // expected-error {{cannot convert value of type 'Int' to expected element type 'Double'}}
|
|
}
|
|
|
|
// <rdar://problem/22414757> "UnresolvedDot" "in wrong phase" assertion from verifier
|
|
[].reduce { $0 + $1 } // expected-error {{missing argument for parameter #1 in call}}
|
|
|
|
|
|
|
|
|
|
// <rdar://problem/22333281> QoI: improve diagnostic when contextual type of closure disagrees with arguments
|
|
var _: () -> Int = {0}
|
|
|
|
// expected-error @+1 {{contextual type for closure argument list expects 1 argument, which cannot be implicitly ignored}} {{24-24=_ in }}
|
|
var _: (Int) -> Int = {0}
|
|
|
|
// expected-error @+1 {{contextual type for closure argument list expects 1 argument, which cannot be implicitly ignored}} {{24-24= _ in}}
|
|
var _: (Int) -> Int = { 0 }
|
|
|
|
// expected-error @+1 {{contextual type for closure argument list expects 2 arguments, which cannot be implicitly ignored}} {{29-29=_,_ in }}
|
|
var _: (Int, Int) -> Int = {0}
|
|
|
|
// expected-error @+1 {{contextual closure type '(Int, Int) -> Int' expects 2 arguments, but 3 were used in closure body}}
|
|
var _: (Int,Int) -> Int = {$0+$1+$2}
|
|
|
|
// expected-error @+1 {{contextual closure type '(Int, Int, Int) -> Int' expects 3 arguments, but 2 were used in closure body}}
|
|
var _: (Int, Int, Int) -> Int = {$0+$1}
|
|
|
|
|
|
// expected-error @+1 {{contextual closure type '(Int) -> Int' expects 1 argument, but 2 were used in closure body}}
|
|
var _: (Int) -> Int = {a,b in 0}
|
|
|
|
// expected-error @+1 {{contextual closure type '(Int) -> Int' expects 1 argument, but 3 were used in closure body}}
|
|
var _: (Int) -> Int = {a,b,c in 0}
|
|
|
|
// expected-error @+1 {{contextual closure type '(Int, Int, Int) -> Int' expects 3 arguments, but 2 were used in closure body}}
|
|
var _: (Int, Int, Int) -> Int = {a, b in a+b}
|
|
|
|
// <rdar://problem/15998821> Fail to infer types for closure that takes an inout argument
|
|
func r15998821() {
|
|
func take_closure(_ x : (inout Int) -> ()) { }
|
|
|
|
func test1() {
|
|
take_closure { (a : inout Int) in
|
|
a = 42
|
|
}
|
|
}
|
|
|
|
func test2() {
|
|
take_closure { a in
|
|
a = 42
|
|
}
|
|
}
|
|
|
|
func withPtr(_ body: (inout Int) -> Int) {}
|
|
func f() { withPtr { p in return p } }
|
|
|
|
let g = { x in x = 3 }
|
|
take_closure(g)
|
|
}
|
|
|
|
// <rdar://problem/22602657> better diagnostics for closures w/o "in" clause
|
|
var _: (Int,Int) -> Int = {$0+$1+$2} // expected-error {{contextual closure type '(Int, Int) -> Int' expects 2 arguments, but 3 were used in closure body}}
|
|
|
|
|
|
// Crash when re-typechecking bodies of non-single expression closures
|
|
|
|
struct CC {}
|
|
func callCC<U>(_ f: (CC) -> U) -> () {}
|
|
|
|
func typeCheckMultiStmtClosureCrash() {
|
|
callCC {
|
|
_ = $0
|
|
return 1
|
|
}
|
|
}
|
|
|
|
// https://github.com/apple/swift/issues/43444
|
|
|
|
func someFunc(_ foo: ((String) -> String)?,
|
|
bar: @escaping (String) -> String) {
|
|
let _: (String) -> String = foo != nil ? foo! : bar
|
|
let _: (String) -> String = foo ?? bar
|
|
}
|
|
|
|
func verify_NotAC_to_AC_failure(_ arg: () -> ()) {
|
|
func takesAC(_ arg: @autoclosure () -> ()) {}
|
|
takesAC(arg) // expected-error {{add () to forward '@autoclosure' parameter}} {{14-14=()}}
|
|
}
|
|
|
|
// https://github.com/apple/swift/issues/43681
|
|
// Error diagnostic refers to wrong argument
|
|
do {
|
|
class C1<T> {
|
|
func append<Key: AnyObject>(value: T, forKey key: Key) where Key: Hashable {}
|
|
}
|
|
class C2<T> {
|
|
let c1: C1<(AnyObject, T) -> ()> = C1()
|
|
}
|
|
struct S<T> {
|
|
let cs: [C2<T>] = []
|
|
|
|
func subscribe<Object: AnyObject>(object: Object?, method: (Object, T) -> ()) where Object: Hashable {
|
|
let wrappedMethod = { (object: AnyObject, value: T) in }
|
|
cs.forEach { $0.c1.append(value: wrappedMethod, forKey: object) }
|
|
// expected-error@-1 {{value of optional type 'Object?' must be unwrapped to a value of type 'Object'}}
|
|
// expected-note@-2 {{coalesce using '??' to provide a default when the optional value contains 'nil'}}
|
|
// expected-note@-3 {{force-unwrap using '!' to abort execution if the optional value contains 'nil'}}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Similar to https://github.com/apple/swift/issues/43681 but with multiple
|
|
// generic arguments.
|
|
do {
|
|
class C {}
|
|
struct S {
|
|
func genericallyNonOptional<T: AnyObject>(_ a: T, _ b: T, _ c: T) { }
|
|
// expected-note@-1 {{where 'T' = 'Optional<C>'}}
|
|
|
|
func f(_ a: C?, _ b: C?, _ c: C) {
|
|
genericallyNonOptional(a, b, c) // expected-error {{instance method 'genericallyNonOptional' requires that 'Optional<C>' be a class type}}
|
|
// expected-note @-1 {{wrapped type 'C' satisfies this requirement}}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Make sure we cannot infer an () argument from an empty parameter list.
|
|
func acceptNothingToInt (_: () -> Int) {}
|
|
func testAcceptNothingToInt(ac1: @autoclosure () -> Int) {
|
|
acceptNothingToInt({ac1($0)}) // expected-error@:27 {{argument passed to call that takes no arguments}}
|
|
// expected-error@-1{{contextual closure type '() -> Int' expects 0 arguments, but 1 was used in closure body}}
|
|
}
|
|
|
|
// <rdar://problem/23570873> QoI: Poor error calling map without being able to infer "U" (closure result inference)
|
|
struct Thing {
|
|
init?() {}
|
|
}
|
|
|
|
let things = Thing().map { thing in
|
|
_ = thing
|
|
return thing
|
|
}
|
|
|
|
|
|
// <rdar://problem/21675896> QoI: [Closure return type inference] Swift cannot find members for the result of inlined lambdas with branches
|
|
func r21675896(file : String) {
|
|
let x: String = {
|
|
if true {
|
|
return "foo"
|
|
}
|
|
else {
|
|
return file
|
|
}
|
|
}().pathExtension // expected-error {{value of type 'String' has no member 'pathExtension'}}
|
|
}
|
|
|
|
|
|
|
|
|
|
// <rdar://problem/19870975> Incorrect diagnostic for failed member lookups within closures passed as arguments ("(_) -> _")
|
|
func ident<T>(_ t: T) -> T {}
|
|
var c = ident({1.DOESNT_EXIST}) // error: expected-error {{value of type 'Int' has no member 'DOESNT_EXIST'}}
|
|
|
|
// <rdar://problem/20712541> QoI: Int/UInt mismatch produces useless error inside a block
|
|
var afterMessageCount : Int?
|
|
|
|
func uintFunc() -> UInt {}
|
|
func takeVoidVoidFn(_ a : () -> ()) {}
|
|
takeVoidVoidFn { () -> Void in
|
|
afterMessageCount = uintFunc() // expected-error {{cannot assign value of type 'UInt' to type 'Int'}} {{23-23=Int(}} {{33-33=)}}
|
|
}
|
|
|
|
// <rdar://problem/19997471> Swift: Incorrect compile error when calling a function inside a closure
|
|
func f19997471(_ x: String) {} // expected-note {{candidate expects value of type 'String' for parameter #1 (got 'T')}}
|
|
func f19997471(_ x: Int) {} // expected-note {{candidate expects value of type 'Int' for parameter #1 (got 'T')}}
|
|
|
|
func someGeneric19997471<T>(_ x: T) {
|
|
takeVoidVoidFn {
|
|
f19997471(x) // expected-error {{no exact matches in call to global function 'f19997471'}}
|
|
}
|
|
}
|
|
|
|
|
|
// <rdar://problem/20921068> Swift fails to compile: [0].map() { _ in let r = (1,2).0; return r }
|
|
let _ = [0].map {
|
|
_ in
|
|
let r = (1,2).0
|
|
return r
|
|
}
|
|
|
|
|
|
// <rdar://problem/21078316> Less than useful error message when using map on optional dictionary type
|
|
func rdar21078316() {
|
|
var foo : [String : String]?
|
|
var bar : [(String, String)]?
|
|
bar = foo.map { ($0, $1) } // expected-error {{contextual closure type '([String : String]) -> [(String, String)]' expects 1 argument, but 2 were used in closure body}}
|
|
// expected-error@-1{{cannot convert value of type '(Dictionary<String, String>, _)' to closure result type '[(String, String)]'}}
|
|
}
|
|
|
|
|
|
// <rdar://problem/20978044> QoI: Poor diagnostic when using an incorrect tuple element in a closure
|
|
var numbers = [1, 2, 3]
|
|
zip(numbers, numbers).filter { $0.2 > 1 } // expected-error {{value of tuple type 'Zip2Sequence<[Int], [Int]>.Element' (aka '(Int, Int)') has no member '2'}}
|
|
|
|
|
|
|
|
// <rdar://problem/20868864> QoI: Cannot invoke 'function' with an argument list of type 'type'
|
|
func foo20868864(_ callback: ([String]) -> ()) { }
|
|
func rdar20868864(_ s: String) {
|
|
var s = s
|
|
foo20868864 { (strings: [String]) in
|
|
s = strings // expected-error {{cannot assign value of type '[String]' to type 'String'}}
|
|
}
|
|
}
|
|
|
|
// <rdar://problem/22058555> crash in cs diags in withCString
|
|
func r22058555() {
|
|
var firstChar: UInt8 = 0
|
|
"abc".withCString { chars in
|
|
firstChar = chars[0] // expected-error {{cannot assign value of type 'Int8' to type 'UInt8'}} {{17-17=UInt8(}} {{25-25=)}}
|
|
}
|
|
}
|
|
|
|
// <rdar://problem/20789423> Unclear diagnostic for multi-statement closure with no return type
|
|
func r20789423() {
|
|
class C {
|
|
func f(_ value: Int) { }
|
|
}
|
|
|
|
let p: C
|
|
print(p.f(p)()) // expected-error {{cannot convert value of type 'C' to expected argument type 'Int'}}
|
|
// expected-error@-1:11 {{cannot call value of non-function type '()'}}
|
|
|
|
let _f = { (v: Int) in
|
|
print("a")
|
|
return "hi"
|
|
}
|
|
|
|
}
|
|
|
|
/// In the example below, https://github.com/apple/swift/issues/45110 started
|
|
/// preferring `C_45110.test(_:)` over `P_45110.test(it:)`. Prior to Swift 5.1,
|
|
/// we emulated the old behavior. However, that behavior is inconsistent with
|
|
/// the typical approach of preferring overloads from the concrete type over one
|
|
/// from a protocol, so we removed the hack.
|
|
protocol Initable_45110 { init() }
|
|
|
|
protocol P_45110 {
|
|
associatedtype T: Initable_45110
|
|
}
|
|
extension P_45110 {
|
|
func test(it o: (T) -> Bool) -> Bool {
|
|
return o(T.self())
|
|
}
|
|
}
|
|
|
|
struct S_45110 : Initable_45110 {}
|
|
class C_45110 : P_45110 {
|
|
typealias T = S_45110
|
|
|
|
func test(_ o: Any) -> Bool {
|
|
return false
|
|
}
|
|
|
|
func call(_ c: C_45110) -> Bool {
|
|
// Note: the diagnostic about capturing 'self', indicates that we have
|
|
// selected test(_) rather than test(it:)
|
|
return c.test { o in test(o) } // expected-error{{call to method 'test' in closure requires explicit use of 'self' to make capture semantics explicit}} expected-note{{capture 'self' explicitly to enable implicit 'self' in this closure}} expected-note{{reference 'self.' explicitly}}
|
|
}
|
|
}
|
|
|
|
let _ = C_45110().call(C_45110())
|
|
|
|
// <rdar://problem/28909024> Returning incorrect result type from method invocation can result in nonsense diagnostic
|
|
extension Collection {
|
|
func r28909024(_ predicate: (Iterator.Element)->Bool) -> Index {
|
|
return startIndex
|
|
}
|
|
}
|
|
func fn_r28909024(n: Int) {
|
|
return (0..<10).r28909024 { // expected-error {{unexpected non-void return value in void function}} // expected-note {{did you mean to add a return type?}}
|
|
_ in true
|
|
}
|
|
}
|
|
|
|
// https://github.com/apple/swift/issues/45584
|
|
// Unexpected ambiguous expression in closure with generics
|
|
do {
|
|
struct S {
|
|
var dataOffset: Int
|
|
}
|
|
class C<R> {
|
|
init(arg: (R) -> Void) {}
|
|
}
|
|
func f(arg: String) {}
|
|
func g(arg: Int) -> Double {
|
|
return 2
|
|
}
|
|
|
|
C<S>(arg: { (r: S) in f(arg: g(arg: r.dataOffset)) }) // expected-error {{cannot convert value of type 'Double' to expected argument type 'String'}}
|
|
|
|
let _ = { $0[$1] }(1, 1) // expected-error {{value of type 'Int' has no subscripts}}
|
|
// FIXME: Better diagnostic here would be `assigning a variable to itself` but
|
|
// binding ordering change exposed a bug in diagnostics.
|
|
let _ = { $0 = ($0 = {}) } // expected-error {{function produces expected type '()'; did you mean to call it with '()'?}}
|
|
let _ = { $0 = $0 = 42 } // expected-error {{assigning a variable to itself}}
|
|
}
|
|
|
|
// https://github.com/apple/swift/issues/43020
|
|
// The () -> T => () -> () implicit conversion was kicking in anywhere
|
|
// inside a closure result, not just at the top-level.
|
|
let mismatchInClosureResultType : (String) -> ((Int) -> Void) = {
|
|
(String) -> ((Int) -> Void) in
|
|
return { }
|
|
// expected-error@-1 {{contextual type for closure argument list expects 1 argument, which cannot be implicitly ignored}} {{13-13= _ in}}
|
|
}
|
|
|
|
// https://github.com/apple/swift/issues/46108
|
|
// Generic function taking closure with in-out parameter can result in a variety
|
|
// of compiler errors or EXC_BAD_ACCESS
|
|
do {
|
|
func f<T>(_ g: (inout T) -> Int) {}
|
|
f { $0 = 1 } // expected-error {{cannot convert value of type '()' to closure result type 'Int'}}
|
|
|
|
// This test makes sure that having closure with in-out parameter doesn't
|
|
// crash with member lookup.
|
|
struct S {
|
|
var number1: Int
|
|
}
|
|
func set_via_closure<T, U>(_ closure: (inout T, U) -> ()) {} // expected-note {{in call to function 'set_via_closure'}}
|
|
set_via_closure({ $0.number1 = $1 })
|
|
// expected-error@-1 {{generic parameter 'T' could not be inferred}}
|
|
// expected-error@-2 {{cannot infer type of closure parameter '$1' without a type annotation}}
|
|
|
|
func f2<T>(_ item: T, _ update: (inout T) -> Void) {
|
|
var x = item
|
|
update(&x)
|
|
}
|
|
var arg = 42
|
|
f2(arg) { $0 += 3 } // ok
|
|
}
|
|
|
|
/// https://github.com/apple/swift/issues/44585
|
|
/// https://github.com/apple/swift/issues/45663
|
|
/// Inference of `inout`
|
|
do {
|
|
func f<T>(_ closure: (inout T) -> Void) {}
|
|
f({ $0 += 2 }) // ok
|
|
}
|
|
|
|
/// https://github.com/apple/swift/issues/45663
|
|
/// `UnresolvedDotExpr` in single expression closure
|
|
do {
|
|
struct Lense<Whole, Part> {
|
|
let set: (inout Whole, Part) -> ()
|
|
}
|
|
struct S {
|
|
var number1: Int
|
|
func lenses() {
|
|
let _: Lense<S, Int> = Lense(
|
|
set: { $0.number1 = $1 } // ok
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
// https://github.com/apple/swift/issues/46067
|
|
// Segmentation fault and other error for closure with in-out parameter
|
|
do {
|
|
func unfold<A, B>(_ a0: A, next: (inout A) -> B) {}
|
|
unfold((0, 0)) { s in 0 } // ok
|
|
}
|
|
|
|
// https://github.com/apple/swift/issues/46343
|
|
// Swift 3.1 fails to compile 3.0 code involving closures and IUOs
|
|
let _: ((Any?) -> Void) = { (arg: Any!) in }
|
|
// This example was rejected in 3.0 as well, but accepting it is correct.
|
|
let _: ((Int?) -> Void) = { (arg: Int!) in }
|
|
|
|
// rdar://30429709 - We should not attempt an implicit conversion from
|
|
// () -> T to () -> Optional<()>.
|
|
func returnsArray() -> [Int] { return [] }
|
|
|
|
returnsArray().compactMap { $0 }.compactMap { }
|
|
// expected-warning@-1 {{expression of type 'Int' is unused}}
|
|
// expected-warning@-2 {{result of call to 'compactMap' is unused}}
|
|
|
|
// rdar://problem/30271695
|
|
_ = ["hi"].compactMap { $0.isEmpty ? nil : $0 }
|
|
|
|
// rdar://problem/32432145 - compiler should emit fixit to remove "_ in" in closures if 0 parameters is expected
|
|
|
|
func r32432145(_ a: () -> ()) {}
|
|
|
|
r32432145 { _ in let _ = 42 }
|
|
// expected-error@-1 {{contextual closure type '() -> ()' expects 0 arguments, but 1 was used in closure body}} {{13-17=}}
|
|
|
|
r32432145 { _ in
|
|
// expected-error@-1 {{contextual closure type '() -> ()' expects 0 arguments, but 1 was used in closure body}} {{13-17=}}
|
|
print("answer is 42")
|
|
}
|
|
|
|
r32432145 { _,_ in
|
|
// expected-error@-1 {{contextual closure type '() -> ()' expects 0 arguments, but 2 were used in closure body}} {{13-19=}}
|
|
print("answer is 42")
|
|
}
|
|
|
|
// rdar://problem/30106822 - Swift ignores type error in closure and presents a bogus error about the caller
|
|
[1, 2].first { $0.foo = 3 }
|
|
// expected-error@-1 {{value of type 'Int' has no member 'foo'}}
|
|
|
|
// rdar://problem/32433193
|
|
// https://github.com/apple/swift/issues/47606
|
|
// Higher-order function diagnostic mentions the wrong contextual type
|
|
// conversion problem
|
|
|
|
protocol P_47606 {
|
|
associatedtype Value
|
|
func map<U>(_ t : @escaping (Self.Value) -> U) -> S_47606<U>
|
|
}
|
|
|
|
struct S_47606<T> : P_47606 {
|
|
typealias Value = T
|
|
func map<U>(_ t : @escaping (T) -> U) -> S_47606<U> { fatalError() }
|
|
}
|
|
|
|
func exFalso_47606<T>() -> T {}
|
|
|
|
extension P_47606 {
|
|
func foo() -> S_47606<Int> {
|
|
let tt : S_47606<Int> = exFalso_47606()
|
|
return tt.map { x in (idx: x) }
|
|
// expected-error@-1 {{cannot convert value of type '(idx: Int)' to closure result type 'Int'}}
|
|
}
|
|
}
|
|
|
|
// rdar://problem/33296619
|
|
let u = rdar33296619().element //expected-error {{cannot find 'rdar33296619' in scope}}
|
|
|
|
[1].forEach { _ in
|
|
_ = "\(u)" // No diagnostic because `u` is already diagnosed and marked as invalid
|
|
}
|
|
|
|
[1].forEach { _ in
|
|
_ = 1 + "hi" // expected-error {{binary operator '+' cannot be applied to operands of type 'Int' and 'String'}}
|
|
// expected-note@-1 {{overloads for '+' exist with these partially matching parameter lists: (Int, Int), (String, String)}}
|
|
}
|
|
|
|
// https://github.com/apple/swift/issues/48236
|
|
do {
|
|
class C {
|
|
var property: String?
|
|
}
|
|
|
|
func test(cs: [C?]) -> [String?] {
|
|
return cs.map({ c in
|
|
let a = c.propertyWithTypo ?? "default"
|
|
// expected-error@-1 {{value of type 'C?' has no member 'propertyWithTypo'}}
|
|
let b = "\(a)"
|
|
return b
|
|
})
|
|
}
|
|
}
|
|
|
|
// Ensure that we still do the appropriate pointer conversion here.
|
|
_ = "".withCString { UnsafeMutableRawPointer(mutating: $0) }
|
|
|
|
// rdar://problem/34077439 - Crash when pre-checking bails out and
|
|
// leaves us with unfolded SequenceExprs inside closure body.
|
|
_ = { (offset) -> T in // expected-error {{cannot find type 'T' in scope}}
|
|
return offset ? 0 : 0
|
|
}
|
|
|
|
// https://github.com/apple/swift/issues/47778
|
|
do {
|
|
struct S<T> {
|
|
func map<R>(fn: (T) -> R) {}
|
|
}
|
|
|
|
S<()>().map{ return 0 }
|
|
S<()>().map{ _ in return 0 }
|
|
S<Void>().map{ return 0 }
|
|
S<Void>().map{ _ in return 0 }
|
|
}
|
|
|
|
// rdar://problem/33429010
|
|
|
|
struct I_33429010 : IteratorProtocol {
|
|
func next() -> Int? {
|
|
fatalError()
|
|
}
|
|
}
|
|
|
|
extension Sequence {
|
|
public func rdar33429010<Result>(into initialResult: Result,
|
|
_ nextPartialResult: (_ partialResult: inout Result, Iterator.Element) throws -> ()
|
|
) rethrows -> Result {
|
|
return initialResult
|
|
}
|
|
}
|
|
|
|
extension Int {
|
|
public mutating func rdar33429010_incr(_ inc: Int) {
|
|
self += inc
|
|
}
|
|
}
|
|
|
|
func rdar33429010_2() {
|
|
let iter = I_33429010()
|
|
var acc: Int = 0 // expected-warning {{}}
|
|
let _: Int = AnySequence { iter }.rdar33429010(into: acc, { $0 + $1 })
|
|
// expected-warning@-1 {{result of operator '+' is unused}}
|
|
let _: Int = AnySequence { iter }.rdar33429010(into: acc, { $0.rdar33429010_incr($1) })
|
|
}
|
|
|
|
class P_33429010 {
|
|
var name: String = "foo"
|
|
}
|
|
|
|
class C_33429010 : P_33429010 {
|
|
}
|
|
|
|
func rdar33429010_3() {
|
|
let arr = [C_33429010()]
|
|
let _ = arr.map({ ($0.name, $0 as P_33429010) }) // Ok
|
|
}
|
|
|
|
func rdar36054961() {
|
|
func bar(dict: [String: (inout String, Range<String.Index>, String) -> Void]) {}
|
|
bar(dict: ["abc": { str, range, _ in
|
|
str.replaceSubrange(range, with: str[range].reversed())
|
|
}])
|
|
}
|
|
|
|
protocol P_37790062 {
|
|
associatedtype T
|
|
var elt: T { get }
|
|
}
|
|
|
|
func rdar37790062() {
|
|
struct S<T> {
|
|
init(_ a: () -> T, _ b: () -> T) {}
|
|
}
|
|
|
|
class C1 : P_37790062 {
|
|
typealias T = Int
|
|
var elt: T { return 42 }
|
|
}
|
|
|
|
class C2 : P_37790062 {
|
|
typealias T = (String, Int, Void)
|
|
var elt: T { return ("question", 42, ()) }
|
|
}
|
|
|
|
func foo() -> Int { return 42 }
|
|
func bar() -> Void {}
|
|
func baz() -> (String, Int) { return ("question", 42) }
|
|
func bzz<T>(_ a: T) -> T { return a }
|
|
func faz<T: P_37790062>(_ a: T) -> T.T { return a.elt }
|
|
|
|
_ = S({ foo() }, { bar() }) // expected-warning {{result of call to 'foo()' is unused}}
|
|
_ = S({ baz() }, { bar() }) // expected-warning {{result of call to 'baz()' is unused}}
|
|
_ = S({ bzz(("question", 42)) }, { bar() }) // expected-warning {{result of call to 'bzz' is unused}}
|
|
_ = S({ bzz(String.self) }, { bar() }) // expected-warning {{result of call to 'bzz' is unused}}
|
|
_ = S({ bzz(((), (()))) }, { bar() }) // expected-warning {{result of call to 'bzz' is unused}}
|
|
_ = S({ bzz(C1()) }, { bar() }) // expected-warning {{result of call to 'bzz' is unused}}
|
|
_ = S({ faz(C2()) }, { bar() }) // expected-warning {{result of call to 'faz' is unused}}
|
|
}
|
|
|
|
// <rdar://problem/39489003>
|
|
typealias KeyedItem<K, T> = (key: K, value: T)
|
|
|
|
protocol Node {
|
|
associatedtype T
|
|
associatedtype E
|
|
associatedtype K
|
|
var item: E {get set}
|
|
var children: [(key: K, value: T)] {get set}
|
|
}
|
|
|
|
extension Node {
|
|
func getChild(for key:K)->(key: K, value: T) {
|
|
return children.first(where: { (item:KeyedItem) -> Bool in
|
|
return item.key == key
|
|
// expected-error@-1 {{binary operator '==' cannot be applied to two 'Self.K' operands}}
|
|
})!
|
|
}
|
|
}
|
|
|
|
// Make sure we don't allow this anymore
|
|
func takesTwo(_: (Int, Int) -> ()) {}
|
|
func takesTwoInOut(_: (Int, inout Int) -> ()) {}
|
|
|
|
takesTwo { _ in } // expected-error {{contextual closure type '(Int, Int) -> ()' expects 2 arguments, but 1 was used in closure body}}
|
|
takesTwoInOut { _ in } // expected-error {{contextual closure type '(Int, inout Int) -> ()' expects 2 arguments, but 1 was used in closure body}}
|
|
|
|
// <rdar://problem/20371273> Type errors inside anonymous functions don't provide enough information
|
|
func f20371273() {
|
|
let x: [Int] = [1, 2, 3, 4]
|
|
let y: UInt = 4
|
|
_ = x.filter { ($0 + y) > 42 } // expected-error {{cannot convert value of type 'UInt' to expected argument type 'Int'}}
|
|
}
|
|
|
|
// rdar://problem/42337247
|
|
|
|
func overloaded(_ handler: () -> Int) {} // expected-note {{found this candidate}}
|
|
func overloaded(_ handler: () -> Void) {} // expected-note {{found this candidate}}
|
|
|
|
overloaded { } // empty body => inferred as returning ()
|
|
|
|
overloaded { print("hi") } // single-expression closure => typechecked with body
|
|
|
|
overloaded { print("hi"); print("bye") } // multiple expression closure without explicit returns; can default to any return type
|
|
// expected-error@-1 {{ambiguous use of 'overloaded'}}
|
|
|
|
func not_overloaded(_ handler: () -> Int) {}
|
|
|
|
not_overloaded { } // empty body
|
|
// expected-error@-1 {{cannot convert value of type '()' to closure result type 'Int'}}
|
|
|
|
not_overloaded { print("hi") } // single-expression closure
|
|
// expected-error@-1 {{cannot convert value of type '()' to closure result type 'Int'}}
|
|
|
|
// no error in -typecheck, but dataflow diagnostics will complain about missing return
|
|
not_overloaded { print("hi"); print("bye") } // multiple expression closure
|
|
|
|
func apply(_ fn: (Int) throws -> Int) rethrows -> Int {
|
|
return try fn(0)
|
|
}
|
|
|
|
enum E : Error {
|
|
case E
|
|
}
|
|
|
|
func test() -> Int? {
|
|
return try? apply({ _ in throw E.E })
|
|
}
|
|
|
|
var fn: () -> [Int] = {}
|
|
// expected-error@-1 {{cannot convert value of type '[Int]' to closure result type '()'}}
|
|
|
|
fn = {}
|
|
// expected-error@-1 {{cannot assign value of type '() -> ()' to type '() -> [Int]'}}
|
|
|
|
func test<Instances : Collection>(
|
|
_ instances: Instances,
|
|
_ fn: (Instances.Index, Instances.Index) -> Bool
|
|
) { fatalError() }
|
|
|
|
test([1]) { _, _ in fatalError(); () }
|
|
|
|
// rdar://problem/40537960 - Misleading diagnostic when using closure with wrong type
|
|
|
|
protocol P_40537960 {}
|
|
func rdar_40537960() {
|
|
struct S {
|
|
var v: String
|
|
}
|
|
|
|
struct L : P_40537960 {
|
|
init(_: String) {}
|
|
}
|
|
|
|
struct R<T : P_40537960> {
|
|
init(_: P_40537960) {}
|
|
}
|
|
|
|
struct A<T: Collection, P: P_40537960> { // expected-note {{'P' declared as parameter to type 'A'}}
|
|
typealias Data = T.Element
|
|
init(_: T, fn: (Data) -> R<P>) {}
|
|
}
|
|
|
|
var arr: [S] = []
|
|
_ = A(arr, fn: { L($0.v) })
|
|
// expected-error@-1 {{generic parameter 'P' could not be inferred}}
|
|
// expected-note@-2 {{explicitly specify the generic arguments to fix this issue}} {{8-8=<[S], <#P: P_40537960#>>}}
|
|
}
|
|
|
|
// rdar://problem/45659733
|
|
func rdar_45659733() {
|
|
func foo<T : BinaryInteger>(_: AnyHashable, _: T) {}
|
|
func bar(_ a: Int, _ b: Int) {
|
|
_ = (a ..< b).map { i in foo(i, i) } // Ok
|
|
}
|
|
|
|
struct S<V> {
|
|
func map<T>(
|
|
get: @escaping (V) -> T,
|
|
set: @escaping (inout V, T) -> Void
|
|
) -> S<T> {
|
|
fatalError()
|
|
}
|
|
|
|
subscript<T>(
|
|
keyPath: WritableKeyPath<V, T?>,
|
|
default defaultValue: T
|
|
) -> S<T> {
|
|
return map(
|
|
get: { $0[keyPath: keyPath] ?? defaultValue },
|
|
set: { $0[keyPath: keyPath] = $1 }
|
|
) // Ok, make sure that we deduce result to be S<T>
|
|
}
|
|
}
|
|
}
|
|
|
|
func rdar45771997() {
|
|
struct S {
|
|
mutating func foo() {}
|
|
}
|
|
|
|
let _: Int = { (s: inout S) in s.foo() }
|
|
// expected-error@-1 {{cannot convert value of type '(inout S) -> ()' to specified type 'Int'}}
|
|
}
|
|
|
|
struct rdar30347997 {
|
|
func withUnsafeMutableBufferPointer(body : (inout Int) -> ()) {}
|
|
func foo() {
|
|
withUnsafeMutableBufferPointer { // expected-error {{cannot convert value of type '(Int) -> ()' to expected argument type '(inout Int) -> ()'}}
|
|
(b : Int) in
|
|
}
|
|
}
|
|
}
|
|
|
|
struct rdar43866352<Options> {
|
|
func foo() {
|
|
let callback: (inout Options) -> Void
|
|
callback = { (options: Options) in } // expected-error {{cannot assign value of type '(Options) -> ()' to type '(inout Options) -> Void'}}
|
|
}
|
|
}
|
|
|
|
extension Hashable {
|
|
var self_: Self {
|
|
return self
|
|
}
|
|
}
|
|
|
|
do {
|
|
struct S<
|
|
C : Collection,
|
|
I : Hashable,
|
|
R : Numeric
|
|
> {
|
|
init(_ arr: C,
|
|
id: KeyPath<C.Element, I>,
|
|
content: @escaping (C.Element) -> R) {}
|
|
}
|
|
|
|
func foo(_ arr: [Int]) {
|
|
_ = S(arr, id: \.self_) {
|
|
// expected-error@-1 {{contextual type for closure argument list expects 1 argument, which cannot be implicitly ignored}} {{30-30=_ in }}
|
|
return 42
|
|
}
|
|
}
|
|
}
|
|
|
|
// Don't allow result type of a closure to end up as a noescape type
|
|
|
|
// The funny error is because we infer the type of badResult as () -> ()
|
|
// via the 'T -> U => T -> ()' implicit conversion.
|
|
let badResult = { (fn: () -> ()) in fn }
|
|
// expected-error@-1 {{function is unused}}
|
|
|
|
// rdar://problem/55102498 - closure's result type can't be inferred if the last parameter has a default value
|
|
func test_trailing_closure_with_defaulted_last() {
|
|
func foo<T>(fn: () -> T, value: Int = 0) {}
|
|
foo { 42 } // Ok
|
|
foo(fn: { 42 }) // Ok
|
|
}
|
|
|
|
// Test that even in multi-statement closure case we still pick up `(Action) -> Void` over `Optional<(Action) -> Void>`.
|
|
// Such behavior used to rely on ranking of partial solutions but with delayed constraint generation of closure bodies
|
|
// it's no longer the case, so we need to make sure that even in case of complete solutions we still pick the right type.
|
|
|
|
protocol Action { }
|
|
protocol StateType { }
|
|
|
|
typealias Fn = (Action) -> Void
|
|
typealias Middleware<State> = (@escaping Fn, @escaping () -> State?) -> (@escaping Fn) -> Fn
|
|
|
|
class Foo<State: StateType> {
|
|
var state: State!
|
|
var fn: Fn!
|
|
|
|
init(middleware: [Middleware<State>]) {
|
|
self.fn = middleware
|
|
.reversed()
|
|
.reduce({ action in },
|
|
{ (fun, middleware) in // Ok, to type-check result type has to be `(Action) -> Void`
|
|
let dispatch: (Action) -> Void = { _ in }
|
|
let getState = { [weak self] in self?.state }
|
|
return middleware(dispatch, getState)(fun)
|
|
})
|
|
}
|
|
}
|
|
|
|
// Make sure that `String...` is translated into `[String]` in the body
|
|
func test_explicit_variadic_is_interpreted_correctly() {
|
|
_ = { (T: String...) -> String in T[0] + "" } // Ok
|
|
}
|
|
|
|
// rdar://problem/59208419 - closure result type is incorrectly inferred to be a supertype
|
|
func test_correct_inference_of_closure_result_in_presence_of_optionals() {
|
|
class A {}
|
|
class B : A {}
|
|
|
|
func foo(_: B) -> Int? { return 42 }
|
|
|
|
func bar<T: A>(_: (A) -> T?) -> T? {
|
|
return .none
|
|
}
|
|
|
|
guard let v = bar({ $0 as? B }),
|
|
let _ = foo(v) // Ok, v is inferred as `B`
|
|
else {
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
// rdar://problem/59741308 - inference fails with tuple element has to joined to supertype
|
|
func rdar_59741308() {
|
|
class Base {
|
|
func foo(_: Int) {}
|
|
}
|
|
|
|
class A : Base {}
|
|
class B : Base {}
|
|
|
|
func test() {
|
|
// Note that `0`, and `1` here are going to be type variables
|
|
// which makes join impossible until it's already to late for
|
|
// it to be useful.
|
|
[(A(), 0), (B(), 1)].forEach { base, value in
|
|
base.foo(value) // Ok
|
|
}
|
|
}
|
|
}
|
|
|
|
func r60074136() {
|
|
func takesClosure(_ closure: ((Int) -> Void) -> Void) {}
|
|
|
|
takesClosure { ((Int) -> Void) -> Void in // expected-warning {{unnamed parameters must be written with the empty name '_'; this is an error in the Swift 6 language mode}}
|
|
}
|
|
}
|
|
|
|
func rdar52204414() {
|
|
let _: () -> Void = { return 42 }
|
|
// expected-error@-1 {{cannot convert value of type 'Int' to closure result type 'Void'}}
|
|
let _ = { () -> Void in return 42 }
|
|
// expected-error@-1 {{declared closure result 'Void' is incompatible with return type 'Int'}} {{19-23=Int}}
|
|
}
|
|
|
|
// https://github.com/apple/swift/issues/54719
|
|
// Trailing closure is used as an argument to the last (positionally) parameter.
|
|
//
|
|
// Note that this was accepted prior to Swift 5.3. SE-0286 changed the
|
|
// order of argument resolution and made it ambiguous.
|
|
|
|
func overloaded_with_default(a: () -> Int, b: Int = 0, c: Int = 0) {} // expected-note{{found this candidate}}
|
|
func overloaded_with_default(b: Int = 0, c: Int = 0, a: () -> Int) {} // expected-note{{found this candidate}}
|
|
|
|
overloaded_with_default { 0 } // expected-error{{ambiguous use of 'overloaded_with_default'}}
|
|
|
|
func overloaded_with_default_and_autoclosure<T>(_ a: @autoclosure () -> T, b: Int = 0) {}
|
|
func overloaded_with_default_and_autoclosure<T>(b: Int = 0, c: @escaping () -> T?) {}
|
|
|
|
overloaded_with_default_and_autoclosure { 42 } // Ok
|
|
overloaded_with_default_and_autoclosure(42) // Ok
|
|
|
|
/// https://github.com/apple/swift/issues/55261
|
|
/// "error: type of expression is ambiguous without a type annotation" in many cases
|
|
/// where methods are missing.
|
|
do {
|
|
let _ = { a, b in }
|
|
// expected-error@-1 {{cannot infer type of closure parameter 'a' without a type annotation}}
|
|
// expected-error@-2 {{cannot infer type of closure parameter 'b' without a type annotation}}
|
|
|
|
_ = .a { b in } // expected-error {{cannot infer contextual base in reference to member 'a'}}
|
|
|
|
struct S {}
|
|
|
|
func test(s: S) {
|
|
S.doesntExist { b in } // expected-error {{type 'S' has no member 'doesntExist'}}
|
|
s.doesntExist { b in } // expected-error {{value of type 'S' has no member 'doesntExist'}}
|
|
s.doesntExist1 { v in } // expected-error {{value of type 'S' has no member 'doesntExist1'}}
|
|
.doesntExist2() { $0 }
|
|
}
|
|
}
|
|
|
|
// Make sure we can infer generic arguments in an explicit result type.
|
|
let explicitUnboundResult1 = { () -> Array in [0] }
|
|
let explicitUnboundResult2: (Array<Bool>) -> Array<Int> = {
|
|
(arr: Array) -> Array in [0]
|
|
}
|
|
// FIXME: Should we prioritize the contextual result type and infer Array<Int>
|
|
// rather than using a type variable in these cases?
|
|
// expected-error@+1 {{unable to infer closure type without a type annotation}}
|
|
let explicitUnboundResult3: (Array<Bool>) -> Array<Int> = {
|
|
(arr: Array) -> Array in [true]
|
|
}
|
|
|
|
// rdar://problem/71525503 - Assertion failed: (!shouldHaveDirectCalleeOverload(call) && "Should we have resolved a callee for this?")
|
|
func test_inout_with_invalid_member_ref() {
|
|
struct S {
|
|
static func createS(_ arg: inout Int) -> S { S() }
|
|
}
|
|
class C {
|
|
static subscript(s: (Int) -> Void) -> Bool { get { return false } }
|
|
}
|
|
|
|
let _: Bool = C[{ .createS(&$0) }]
|
|
// expected-error@-1 {{value of tuple type 'Void' has no member 'createS'}}
|
|
// expected-error@-2 {{cannot pass immutable value as inout argument: '$0' is immutable}}
|
|
}
|
|
|
|
// rdar://problem/74435602 - failure to infer a type for @autoclosure parameter.
|
|
func rdar_74435602(error: Error?) {
|
|
func accepts_autoclosure<T>(_ expression: @autoclosure () throws -> T) {}
|
|
|
|
accepts_autoclosure({
|
|
if let failure = error {
|
|
throw failure
|
|
}
|
|
})
|
|
}
|
|
|
|
// https://github.com/apple/swift/issues/56639
|
|
|
|
let _: (@convention(block) () -> Void)? = Bool.random() ? nil : {} // OK
|
|
let _: (@convention(thin) () -> Void)? = Bool.random() ? nil : {} // OK
|
|
let _: (@convention(c) () -> Void)? = Bool.random() ? nil : {} // OK on type checking, diagnostics are deferred to SIL
|
|
|
|
let _: (@convention(block) () -> Void)? = Bool.random() ? {} : {} // OK
|
|
let _: (@convention(thin) () -> Void)? = Bool.random() ? {} : {} // OK
|
|
let _: (@convention(c) () -> Void)? = Bool.random() ? {} : {} // OK on type checking, diagnostics are deferred to SIL
|
|
|
|
// Make sure that diagnostic is attached to the closure even when body is empty (implicitly returns `Void`)
|
|
var emptyBodyMismatch: () -> Int {
|
|
return { // expected-error {{cannot convert value of type '()' to closure result type 'Int'}}
|
|
return
|
|
}
|
|
}
|
|
|
|
// rdar://76250381 - crash when passing an argument to a closure that takes no arguments
|
|
struct R_76250381<Result, Failure: Error> {
|
|
func test(operation: @escaping () -> Result) -> Bool {
|
|
return try self.crash { group in // expected-error {{contextual closure type '() -> Result' expects 0 arguments, but 1 was used in closure body}}
|
|
operation(&group) // expected-error {{argument passed to call that takes no arguments}}
|
|
}
|
|
}
|
|
|
|
func crash(_: @escaping () -> Result) -> Bool {
|
|
return false
|
|
}
|
|
}
|
|
|
|
// https://github.com/apple/swift/issues/55926
|
|
(0..<10).map { x, y in }
|
|
// expected-error@-1 {{contextual closure type '(Range<Int>.Element) -> ()' (aka '(Int) -> ()') expects 1 argument, but 2 were used in closure body}}
|
|
(0..<10).map { x, y, z in }
|
|
// expected-error@-1 {{contextual closure type '(Range<Int>.Element) -> ()' (aka '(Int) -> ()') expects 1 argument, but 3 were used in closure body}}
|
|
(0..<10).map { x, y, z, w in }
|
|
// expected-error@-1 {{contextual closure type '(Range<Int>.Element) -> ()' (aka '(Int) -> ()') expects 1 argument, but 4 were used in closure body}}
|
|
|
|
// rdar://77022842 - crash due to a missing argument to a ternary operator
|
|
func rdar77022842(argA: Bool? = nil, argB: Bool? = nil) {
|
|
if let a = argA ?? false, if let b = argB ?? {
|
|
// expected-error@-1 {{initializer for conditional binding must have Optional type, not 'Bool'}}
|
|
// expected-error@-2 {{cannot convert value of type 'Bool?' to expected argument type '(() -> ())?'}}
|
|
// expected-error@-3 {{cannot convert value of type 'Void' to expected condition type 'Bool'}}
|
|
// expected-error@-4 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
|
|
// expected-error@-5 {{'if' must have an unconditional 'else' to be used as expression}}
|
|
} // expected-error {{expected '{' after 'if' condition}}
|
|
}
|
|
|
|
// rdar://76058892 - spurious ambiguity diagnostic
|
|
func rdar76058892() {
|
|
struct S {
|
|
var test: Int = 0
|
|
}
|
|
|
|
func test(_: Int) {}
|
|
func test(_: () -> String) {}
|
|
|
|
func experiment(arr: [S]?) {
|
|
test { // expected-error {{contextual closure type '() -> String' expects 0 arguments, but 1 was used in closure body}}
|
|
if let arr = arr {
|
|
arr.map($0.test) // expected-note {{anonymous closure parameter '$0' is used here}} // expected-error {{generic parameter 'T' could not be inferred}}
|
|
// expected-error@-1 {{generic parameter 'E' could not be inferred}}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// rdar://78917861 - Invalid generic type parameter inference
|
|
|
|
func rdar78917861() {
|
|
class Cell {}
|
|
class MyCell : Cell {}
|
|
|
|
class DataCollection<D, C: Cell> {
|
|
}
|
|
|
|
class MyCollection {
|
|
typealias DataType = String
|
|
typealias CellType = MyCell
|
|
|
|
var data: DataCollection<DataType, CellType>
|
|
|
|
init() {
|
|
self.data = DataCollection<DataType, CellType>()
|
|
}
|
|
}
|
|
|
|
class Test {
|
|
let collection = MyCollection()
|
|
|
|
lazy var prop: DataCollection = {
|
|
collection.data // Ok
|
|
// Since contextual type `DataCollection` doesn't specify generic parameters they have to be inferred
|
|
// but that has to wait until the closure is resolved because types can flow both ways
|
|
}()
|
|
}
|
|
}
|
|
|
|
// rdar://81228501 - type-checker crash due to applied invalid solution
|
|
func test(arr: [[Int]]) {
|
|
struct A {
|
|
init(arg: [Int]) {}
|
|
}
|
|
|
|
arr.map { ($0 as? [Int]).map { A($0) } } // expected-error {{missing argument label 'arg:' in call}} {{36-36=arg: }}
|
|
}
|
|
|
|
func closureWithCaseArchetype<T>(_: T.Type) {
|
|
let _ = { (any: Any) throws -> Any? in
|
|
switch any {
|
|
case let type as T:
|
|
return type
|
|
|
|
default:
|
|
return any
|
|
}
|
|
}
|
|
}
|
|
|
|
// rdar://112426330 - invalid diagnostic when closure argument is omitted
|
|
do {
|
|
func test<T>(_: T, _: (T) -> Void) {}
|
|
|
|
test(42) { // expected-error {{contextual type for closure argument list expects 1 argument, which cannot be implicitly ignored}} {{13-13= _ in}}
|
|
print("")
|
|
}
|
|
|
|
func context(_: (Int) -> Void) {}
|
|
func context(_: () -> Void) {}
|
|
|
|
context {
|
|
test(42) { // expected-error {{contextual type for closure argument list expects 1 argument, which cannot be implicitly ignored}} {{15-15= _ in}}
|
|
print("")
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
do {
|
|
func test(_: Int, _: Int) {}
|
|
// expected-note@-1 {{closure passed to parameter of type 'Int' that does not accept a closure}}
|
|
func test(_: Int, _: String) {}
|
|
// expected-note@-1 {{closure passed to parameter of type 'String' that does not accept a closure}}
|
|
|
|
test(42) { // expected-error {{no exact matches in call to local function 'test'}}
|
|
print($0)
|
|
}
|
|
}
|
|
|
|
// Currently legal.
|
|
let _: () -> Int = { return fatalError() }
|
|
|
|
// Make sure that `Void` assigned to closure result doesn't get eagerly propagated into the body
|
|
do {
|
|
class C {
|
|
func f(_: Any) -> Int! { fatalError() }
|
|
static func f(_: Any) -> Int! { fatalError() }
|
|
}
|
|
|
|
class G<T> {
|
|
func g<U>(_ u: U, _: (U, T) -> ()) {}
|
|
|
|
func g<U: C>(_ u: U) {
|
|
g(u) { $0.f($1) } // expected-warning {{result of call to 'f' is unused}}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Make sure that closure gets both Void? and Void attempted
|
|
// otherwise it won't be possible to type-check the second closure.
|
|
do {
|
|
struct Semaphore {
|
|
func signal() -> Int {}
|
|
}
|
|
|
|
func compute(_ completion: (Semaphore?) -> Void?) {}
|
|
|
|
func test() {
|
|
compute { $0?.signal() }
|
|
// expected-warning@-1 {{result of call to 'signal()' is unused}}
|
|
|
|
true
|
|
? compute({ $0?.signal() }) // expected-warning {{result of call to 'signal()' is unused}}
|
|
: compute({
|
|
let sem = $0!
|
|
sem.signal() // expected-warning {{result of call to 'signal()' is unused}}
|
|
})
|
|
}
|
|
}
|
|
|
|
// rdar://143474313 - invalid error: member 'init(item:)' in 'Test.Item?' produces result of type 'Test.Item', but context expects 'Test.Item?'
|
|
do {
|
|
struct List {
|
|
struct Item {
|
|
}
|
|
|
|
var items: [Item] = []
|
|
}
|
|
|
|
struct Test {
|
|
struct Item {
|
|
init(item: List.Item) {
|
|
}
|
|
}
|
|
|
|
let list: List
|
|
|
|
var items: [Test.Item] { .init(list.items.compactMap { .init(item: $0) }) } // Ok
|
|
}
|
|
}
|
|
|
|
// This should type check
|
|
func rdar143338891() {
|
|
func takesAny(_: Any?) {}
|
|
|
|
class Test {
|
|
func test() {
|
|
_ = { [weak self] in takesAny(self) }
|
|
}
|
|
}
|
|
}
|
|
|
|
do {
|
|
struct V {
|
|
init(value: @autoclosure @escaping () -> any Hashable) { }
|
|
init(other: @autoclosure @escaping () -> String) { }
|
|
}
|
|
|
|
let _ = V(value: { [Int]() }) // expected-error {{add () to forward '@autoclosure' parameter}} {{31-31=()}}
|
|
let _ = V(other: { [Int]() }) // expected-error {{cannot convert value of type '[Int]' to closure result type 'String'}}
|
|
}
|
|
|
|
// https://github.com/swiftlang/swift/issues/81770
|
|
do {
|
|
func test(_: Int) {}
|
|
func test(_: Int = 42, _: (Int) -> Void) {}
|
|
|
|
test {
|
|
if let _ = $0.missing { // expected-error {{value of type 'Int' has no member 'missing'}}
|
|
}
|
|
}
|
|
|
|
test {
|
|
if let _ = (($0.missing)) { // expected-error {{value of type 'Int' has no member 'missing'}}
|
|
}
|
|
}
|
|
|
|
test { // expected-error {{invalid conversion from throwing function of type '(Int) throws -> _' to non-throwing function type '(Int) -> Void'}}
|
|
try $0.missing // expected-error {{value of type 'Int' has no member 'missing'}}
|
|
}
|
|
}
|
|
|
|
// Generic requirement failures associated with closure parameters should be diagnosed.
|
|
protocol Input {
|
|
associatedtype Value
|
|
var value: Value { get }
|
|
}
|
|
|
|
protocol Idable {
|
|
associatedtype ID
|
|
}
|
|
|
|
struct TestInput<ItemID: Hashable, Value: Collection<ItemID>> : Input { // expected-note {{where 'Value' = 'Item.ID'}}
|
|
var value: Value
|
|
}
|
|
|
|
struct Container<I: Input> {
|
|
var data: (I) -> Void
|
|
}
|
|
|
|
func test_generic_closure_parameter_requirement_failure<Item: Idable>(
|
|
for itemType: Item.Type = Item.self,
|
|
_ payload: @escaping (_ itemID: Item.ID) -> Void
|
|
) where Item.ID : Sendable {
|
|
Container(data: { (input: TestInput) in payload(input.value) })
|
|
// expected-error@-1 {{generic struct 'TestInput' requires that 'Item.ID' conform to 'Collection'}}
|
|
}
|
|
|
|
// Since implicit result implies `()` it should be allowed to be converted to e.g. `Void` and `Any`
|
|
func test_implicit_result_conversions() {
|
|
func test_optional(_ x: Int) {
|
|
let _: Any? = {
|
|
switch x {
|
|
case 0:
|
|
return 1
|
|
default:
|
|
return
|
|
}
|
|
}()
|
|
}
|
|
|
|
func testAny(_: () -> Any) {}
|
|
|
|
testAny { } // Ok
|
|
testAny { return } // Ok
|
|
testAny {
|
|
_ = 42
|
|
return // Ok
|
|
}
|
|
}
|