1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
|
// RUN: %target-typecheck-verify-swift -debug-constraints 2>%t.err
// RUN: %FileCheck %s < %t.err
// This test ensures that we are filtering out overloads based on argument
// labels, arity, etc., before those terms are visited.
func foo(_: Int) { }
func foo(_: Int, _: Int) { }
func foo(_: Int, _: Int, _: Int) { }
func testModuleScope(i: Int) {
// CHECK: (disabled disjunction term {{.*}} (Int) -> ()
// CHECK-NEXT: (disabled disjunction term {{.*}} (Int, Int, Int) -> ()
// CHECK: (introducing single enabled disjunction term {{.*}} (Int, Int) -> ()
foo(i, i)
}
struct X {
subscript(_: Int) -> Int { return 0 }
subscript(_: Int, _: Int) -> Double { return 0 }
subscript(_: Int, _: Int, _: Int) -> String { return "" }
init(_: Int) { }
init(_: Int, _: Int) { }
init(_: Int, _: Int, _: Int) { }
}
func testSubscript(x: X, i: Int) {
// CHECK: disabled disjunction term {{.*}}X.subscript(_:)
// CHECK-NEXT: disabled disjunction term {{.*}}X.subscript(_:_:_:)
// CHECK-NEXT: introducing single enabled disjunction term {{.*}} bound to decl overload_filtering.(file).X.subscript(_:_:)
_ = x[i, i]
}
func testUnresolvedMember(i: Int) -> X {
// CHECK: disabled disjunction term {{.*}} bound to decl overload_filtering.(file).X.init(_:)
// CHECK-NEXT: disabled disjunction term {{.*}} bound to decl overload_filtering.(file).X.init(_:_:_:)
// CHECK-NEXT: (removed constraint: disjunction
// CHECK-NEXT: > [[A:\$T[0-9]+]] bound to decl overload_filtering
// CHECK-NEXT: > [disabled] [[A]] bound to decl overload_filtering
// CHECK-NEXT: > [disabled] [[A]] bound to decl overload_filtering
// CHECK-NEXT: introducing single enabled disjunction term {{.*}} bound to decl overload_filtering.(file).X.init(_:_:)
return .init(i, i)
}
func test_member_filtering() {
struct S {
// Result types here are different intentionally,
// if there were the same simplification logic would
// trigger and disable overloads during constraint
// generation.
func foo(_: Int) -> S { S() }
func foo(_: String) -> Int { 42 }
func bar(v: String) {}
func bar(_: Int) {}
func bar(a: Double, b: Int) {}
}
func test(s: S) {
// CHECK: disabled disjunction term {{.*}} bound to decl overload_filtering.(file).test_member_filtering().S.bar(v:)
// CHECK-NEXT: disabled disjunction term {{.*}} bound to decl overload_filtering.(file).test_member_filtering().S.bar(a:b:)
// CHECK-NEXT: (removed constraint: disjunction
// CHECK-NEXT: > [[B:\$T[0-9]+]] bound to decl overload_filtering
// CHECK-NEXT: > [disabled] [[B]] bound to decl overload_filtering
// CHECK-NEXT: > [disabled] [[B]] bound to decl overload_filtering
// CHECK-NEXT: introducing single enabled disjunction term {{.*}} bound to decl overload_filtering.(file).test_member_filtering().S.bar
s.foo(42).bar(42)
}
}
|
