mirror of
https://github.com/apple/swift.git
synced 2025-12-21 12:14:44 +01:00
82ac9328ae
* Use fancy arrows (`→`) because they are distinct from and shorter than `->`, and fancier. * We have two ways of demarcating locators: `@ <locator>` and `[[<locator>]];`. Stick to the first, which is shorter and clearer. * 'attempting type variable' → 'attempting binding'. *Bindings* are attempted, not type variables. * `considering ->` → `considering:`. I think a colon is semantically more fit and makes things easier to read if the considered constraint has arrows in its description or types. It’s also shorter this way.
84 lines
2.5 KiB
Swift
84 lines
2.5 KiB
Swift
// RUN: %target-typecheck-verify-swift -debug-constraints -disable-availability-checking 2>%t.err
|
|
// RUN: %FileCheck %s < %t.err
|
|
|
|
protocol P<Output> {
|
|
associatedtype Output
|
|
}
|
|
|
|
struct S<Output> : P {
|
|
init(_: Output) {}
|
|
}
|
|
|
|
@resultBuilder
|
|
struct Builder {
|
|
static func buildExpression<T>(_ e: T) -> T { e }
|
|
|
|
static func buildBlock<T1>(_ t1: T1) -> some P<T1> {
|
|
return S(t1)
|
|
}
|
|
|
|
static func buildBlock<T1, T2>(_ t1: T1, _ t2: T2) -> some P<(T1, T2)> {
|
|
return S((t1, t2))
|
|
}
|
|
|
|
static func buildBlock<T1, T2, T3>(_ t1: T1, _ t2: T2, _ t3: T3) -> some P<(T1, T2, T3)> {
|
|
return S((t1, t2, t3))
|
|
}
|
|
|
|
static func buildOptional<T>(_ value: T?) -> T? { return value }
|
|
}
|
|
|
|
do {
|
|
func test<T, U>(_: T, @Builder _: () -> some P<U>) {}
|
|
|
|
// CHECK: ---Initial constraints for the given expression---
|
|
// CHECK: (integer_literal_expr type='[[LITERAL_VAR:\$T[0-9]+]]' {{.*}}
|
|
// CHECK: (attempting type variable binding [[CLOSURE:\$T[0-9]+]] := () -> {{.*}}
|
|
// CHECK-NOT: (attempting type variable binding [[LITERAL_VAR]] := {{.*}}
|
|
// CHECK: (attempting conjunction element pattern binding element @ 0
|
|
// CHECK: (applying conjunction result to outer context
|
|
// CHECK: (attempting type variable binding [[LITERAL_VAR]] := Int
|
|
test(42) {
|
|
1
|
|
""
|
|
}
|
|
}
|
|
|
|
do {
|
|
func test<T, U>(_: T, @Builder _: (T) -> some P<U>) {}
|
|
|
|
// CHECK: ---Initial constraints for the given expression---
|
|
// CHECK: (integer_literal_expr type='[[LITERAL_VAR:\$T[0-9]+]]' {{.*}}
|
|
// CHECK: (attempting type variable binding [[LITERAL_VAR]] := Int
|
|
// CHECK: (attempting conjunction element pattern binding element @ 0
|
|
test(42) { v in
|
|
v
|
|
""
|
|
}
|
|
}
|
|
|
|
do {
|
|
func test<T: BinaryInteger, U>(@Builder _: (Bool) -> some P<T>, transform: (T?) -> U) {}
|
|
|
|
// CHECK: ---Initial constraints for the given expression---
|
|
// CHECK: (attempting type variable {{.*}} := () -> {{.*}}
|
|
// CHECK: (attempting conjunction element pattern binding element @ 0 :
|
|
// CHECK-NEXT: (pattern_named 'x')
|
|
// CHECK: (attempting conjunction element syntactic element
|
|
// CHECK-NEXT: (call_expr {{.*}}
|
|
// CHECK: (attempting type variable {{.*}} := (Bool) -> {{.*}}
|
|
// CHECK: (attempting conjunction element pattern binding element @ 0
|
|
// CHECK: (pattern_named implicit '$__builder{{.*}}')
|
|
// CHECK: (applying conjunction result to outer context
|
|
// CHECK: (attempting type variable {{.*}} := (Int?) -> {{.*}}
|
|
// CHECK: (attempting disjunction choice {{.*}} bound to decl {{.*}}.Int.init(_:)
|
|
let _ = {
|
|
let x = 42
|
|
test { cond in
|
|
x
|
|
} transform: { v in
|
|
Int(v ?? 0)
|
|
}
|
|
}
|
|
}
|