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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
|
// RUN: %target-run-simple-swift | %FileCheck %s
// REQUIRES: executable_test
protocol Protocol {}
extension Protocol {
func foo() {
print("I survived in \(Self.self).\(#function)")
}
}
struct Foo<T: Equatable> {
struct Inner1 where T: Protocol {
let bar: T
}
struct Inner2 where T == String {
func getString() -> T {
return "I survived in \(#function), T := \(T.self)"
}
}
struct Inner3<U: Hashable> {
func isLessThan(lhs: T, rhs: T) -> U where T: Comparable, U == Bool {
return lhs < rhs
}
init() {
print("This is the unconstrained \(#function)")
}
init() where U == T {
print("I survived in \(#function), T := \(T.self), U := \(U.self)")
}
}
}
struct ProtocolAdopter: Protocol, Equatable {}
// CHECK: I survived in ProtocolAdopter.foo()
Foo<ProtocolAdopter>.Inner1(bar: ProtocolAdopter()).bar.foo()
// CHECK: I survived in getString(), T := String
print(Foo<String>.Inner2().getString())
// CHECK: This is the unconstrained init()
// CHECK: false
print(Foo<Int>.Inner3<Bool>().isLessThan(lhs: .zero, rhs: .zero))
// CHECK: I survived in init(), T := Bool, U := Bool
_ = Foo<Bool>.Inner3<Bool>()
protocol RefinedProtocol: Protocol {
associatedtype Assoc = Self
associatedtype Bssoc: RefinedProtocol
func overload()
}
extension RefinedProtocol {
func callOverload() {
overload()
print("Assoc := \(Assoc.self), Bssoc := \(Bssoc.self)")
}
func overload() where Assoc == Bssoc {
print("I survived in \(Self.self).\(#function) (1)")
}
func overload() where Assoc == Self {
print("I survived in \(Self.self).\(#function) (2)")
}
func overload() where Assoc: Sequence, Bssoc == Assoc.Element {
print("I survived in \(Self.self).\(#function) (3)")
}
}
struct RefinedProtocolAdopter1: RefinedProtocol {
typealias Assoc = RefinedProtocolAdopter2
typealias Bssoc = RefinedProtocolAdopter2
}
struct RefinedProtocolAdopter2: RefinedProtocol {
typealias Bssoc = RefinedProtocolAdopter1
}
struct RefinedProtocolAdopter3: RefinedProtocol {
typealias Assoc = Array<Bssoc>
typealias Bssoc = RefinedProtocolAdopter3
}
@inline(never)
func callThroughToOverload<T: RefinedProtocol>(arg: T) {
arg.callOverload()
}
// CHECK: I survived in RefinedProtocolAdopter1.overload() (1)
// CHECK: Assoc := RefinedProtocolAdopter2, Bssoc := RefinedProtocolAdopter2
callThroughToOverload(arg: RefinedProtocolAdopter1())
// CHECK: I survived in RefinedProtocolAdopter2.overload() (2)
// CHECK: Assoc := RefinedProtocolAdopter2, Bssoc := RefinedProtocolAdopter1
callThroughToOverload(arg: RefinedProtocolAdopter2())
// CHECK: I survived in RefinedProtocolAdopter3.overload() (3)
// CHECK: Assoc := Array<RefinedProtocolAdopter3>, Bssoc := RefinedProtocolAdopter3
callThroughToOverload(arg: RefinedProtocolAdopter3())
|
