mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
c99c02b5a6
mode (take 2)
Allow untyped placeholder to take arbitrary type, but default to Void.
Add _undefined<T>() function, which is like fatalError() but has
arbitrary return type. In playground mode, merely warn about outstanding
placeholders instead of erroring out, and transform placeholders into
calls to _undefined(). This way, code with outstanding placeholders will
only crash when it attempts to evaluate such placeholders.
When generating constraints for an iterated sequence of type T, emit
T convertible to $T1
$T1 conforms to SequenceType
instead of
T convertible to SequenceType
This ensures that an untyped placeholder in for-each sequence position
doesn't get inferred to have type SequenceType. (The conversion is still
necessary because the sequence may have IUO type.) The new constraint
system precipitates changes in CSSimplify and CSDiag, and ends up fixing
18741539 along the way.
(NOTE: There is a small regression in diagnosis of issues like the
following:
class C {}
class D: C {}
func f(a: [C]!) { for _: D in a {} }
It complains that [C]! doesn't conform to SequenceType when it should be
complaining that C is not convertible to D.)
<rdar://problem/21167372>
(Originally Swift SVN r31481)
43 lines
991 B
Swift
43 lines
991 B
Swift
// RUN: %target-parse-verify-swift
|
|
|
|
func takeIntToInt(f: (Int) -> Int) { }
|
|
func takeIntIntToInt(f: (Int, Int) -> Int) { }
|
|
|
|
// Simple closures
|
|
func simple() {
|
|
takeIntToInt({(x: Int) -> Int in
|
|
return x + 1
|
|
})
|
|
takeIntIntToInt({(x: Int, y: Int) -> Int in
|
|
return x + y
|
|
})
|
|
}
|
|
|
|
// Closures with variadic argument lists
|
|
func variadic() {
|
|
var f = {(start: Int, rest: Int...) -> Int in
|
|
var result = start
|
|
for x in rest {
|
|
result += x
|
|
}
|
|
return result
|
|
}
|
|
f(1)
|
|
f(1, 2)
|
|
f(1, 3)
|
|
|
|
let D = { (Ss ...) in 1 } // expected-error{{'...' cannot be applied to a subpattern which is not explicitly typed}}, expected-error{{unable to infer closure type in the current context}}
|
|
}
|
|
|
|
// Closures with attributes in the parameter list.
|
|
func attrs() {
|
|
_ = {(inout z: Int) -> Int in z }
|
|
}
|
|
|
|
// Closures with argument and parameter names.
|
|
func argAndParamNames() -> Int {
|
|
let f1: (x: Int, y: Int) -> Int = { (a x, b y) in x + y }
|
|
f1(x: 1, y: 2)
|
|
return f1(x: 1, y: 2)
|
|
}
|