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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
// RUN: %target-typecheck-verify-swift
// RUN: not %target-swift-frontend -typecheck %s -debug-generic-signatures 2>&1 | %FileCheck %s
// -----
protocol Foo {
associatedtype Bar : Foo
}
struct Ouroboros : Foo {
typealias Bar = Ouroboros
}
// -----
protocol P {
associatedtype A : P
}
struct X<T: P> {
}
func f<T : P>(_ z: T) {
_ = X<T.A>()
}
// -----
protocol PP2 {
associatedtype A : P2 = Self
}
protocol P2 : PP2 {
associatedtype A = Self
}
struct X2<T: P2> {
}
struct Y2 : P2 {
typealias A = Y2
}
func f<T : P2>(_ z: T) {
_ = X2<T.A>()
}
// -----
protocol P3 {
associatedtype A: P4 = Self
}
protocol P4 : P3 {}
// CHECK-LABEL: .DeclaredP@
// CHECK-NEXT: Requirement signature: <Self where Self : P4>
protocol DeclaredP : P3, P4 {}
struct Y3 : DeclaredP {
}
struct X3<T:P4> {}
func f2<T:P4>(_ a: T) {
_ = X3<T.A>()
}
f2(Y3())
// -----
protocol Alpha {
associatedtype Beta: Gamma
}
protocol Gamma {
associatedtype Delta: Alpha
}
// CHECK-LABEL: .Epsilon@
// CHECK-NEXT: Generic signature: <T, U where T : Alpha, T == U.[Gamma]Delta, U == T.[Alpha]Beta>
struct Epsilon<T: Alpha,
U: Gamma>
where T.Beta == U,
U.Delta == T {}
// -----
protocol AsExistentialA {
var delegate : AsExistentialB? { get }
}
protocol AsExistentialB {
func aMethod(_ object : AsExistentialA)
}
protocol AsExistentialAssocTypeA {
var delegate : AsExistentialAssocTypeB? { get } // expected-error {{use of protocol 'AsExistentialAssocTypeB' as a type must be written 'any AsExistentialAssocTypeB'}}
}
protocol AsExistentialAssocTypeB {
func aMethod(_ object : AsExistentialAssocTypeA)
associatedtype Bar
}
protocol AsExistentialAssocTypeAgainA {
var delegate : AsExistentialAssocTypeAgainB? { get }
associatedtype Bar
}
protocol AsExistentialAssocTypeAgainB {
func aMethod(_ object : AsExistentialAssocTypeAgainA) // expected-error {{use of protocol 'AsExistentialAssocTypeAgainA' as a type must be written 'any AsExistentialAssocTypeAgainA'}}
}
// https://github.com/apple/swift/issues/43164
protocol A {
associatedtype B1: B
associatedtype C1: C
mutating func addObserver(_ observer: B1, forProperty: C1)
}
protocol C {
}
protocol B {
associatedtype BA: A
associatedtype BC: C
func observeChangeOfProperty(_ property: BC, observable: BA)
}
|
