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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
// RUN: %empty-directory(%t)
// RUN: %target-typecheck-verify-swift -I %S/Inputs/implementation-only-override -DERRORS -enable-library-evolution -enable-objc-interop
// RUN: %target-swift-emit-module-interface(%t/Library.swiftinterface) %s -I %S/Inputs/implementation-only-override -enable-objc-interop
// RUN: %target-swift-typecheck-module-from-interface(%t/Library.swiftinterface) -I %S/Inputs/implementation-only-override
// RUN: %FileCheck %s < %t/Library.swiftinterface
// RUN: %FileCheck -check-prefix=NEGATIVE %s < %t/Library.swiftinterface
// CHECK: import FooKit
// NEGATIVE-NOT: SECRET
// NEGATIVE-NOT: subscript
import FooKit
@_implementationOnly import FooKit_SECRET
// CHECK-LABEL: class GoodChild : FooKit.Parent {
// CHECK-NEXT: @objc override dynamic public init()
// CHECK-NEXT: @objc deinit
// CHECK-NEXT: }
public class GoodChild: Parent {
public override init() {}
// FIXME: @_implementationOnly on an initializer doesn't exactly make sense,
// since they're not inherited.
@_implementationOnly public override init(SECRET: Int32) {}
@_implementationOnly public required init(requiredSECRET: Int32) {}
@_implementationOnly public override func methodSECRET() {} // expected-note {{overridden declaration is here}}
@_implementationOnly public override func methodWithSECRETType() -> SECRETType? { nil } // expected-note {{overridden declaration is here}}
@_implementationOnly public override var roPropSECRET: Parent? { nil } // expected-note {{overridden declaration is here}}
@_implementationOnly public override var rwPropSECRET: Parent? { // expected-note {{overridden declaration is here}}
get { nil }
set {}
}
@_implementationOnly public override subscript(_ index: Int32) -> Parent? { nil } // expected-note {{overridden declaration is here}}
@_implementationOnly public override var redefinedPropSECRET: Parent? { // expected-note {{overridden declaration is here}}
get { nil }
set {}
}
}
// CHECK-LABEL: class QuietChild : FooKit.Parent {
// CHECK-NEXT: @objc deinit
// CHECK-NEXT: }
public class QuietChild: Parent {
internal override init() {}
internal override init(SECRET: Int32) {}
internal required init(requiredSECRET: Int32) {}
}
// CHECK-LABEL: class GoodGenericChild<Toy> : FooKit.Parent {
// CHECK-NEXT: @objc override dynamic public init()
// CHECK-NEXT: @objc deinit
// CHECK-NEXT: }
public class GoodGenericChild<Toy>: Parent {
public override init() {}
// FIXME: @_implementationOnly on an initializer doesn't exactly make sense,
// since they're not inherited.
@_implementationOnly public override init(SECRET: Int32) {}
@_implementationOnly public required init(requiredSECRET: Int32) {}
@_implementationOnly public override func methodSECRET() {}
@_implementationOnly public override func methodWithSECRETType() -> SECRETType? { nil }
@_implementationOnly public override var roPropSECRET: Parent? { nil }
@_implementationOnly public override var rwPropSECRET: Parent? {
get { nil }
set {}
}
@_implementationOnly public override subscript(_ index: Int32) -> Parent? { nil }
@_implementationOnly public override var redefinedPropSECRET: Parent? {
get { nil }
set {}
}
}
internal class PrivateChild: Parent {
override func methodSECRET() {}
override func methodWithSECRETType() -> SECRETType? { nil }
override var roPropSECRET: Parent? { nil }
override var rwPropSECRET: Parent? {
get { nil }
set {}
}
override subscript(_ index: Int32) -> Parent? { nil }
override var redefinedPropSECRET: Parent? {
get { nil }
set {}
}
}
internal class PrivateGrandchild: GoodChild {
override func methodSECRET() {}
override func methodWithSECRETType() -> SECRETType? { nil }
override var roPropSECRET: Parent? { nil }
override var rwPropSECRET: Parent? {
get { nil }
set {}
}
override subscript(_ index: Int32) -> Parent? { nil }
override var redefinedPropSECRET: Parent? {
get { nil }
set {}
}
}
// CHECK-LABEL: class SubscriptChild : FooKit.SubscriptParent {
// CHECK-NEXT: @objc deinit
// CHECK-NEXT: }
public class SubscriptChild: SubscriptParent {
@_implementationOnly public override subscript(_ index: Int32) -> Parent? {
get { nil }
set {}
}
}
#if ERRORS
public class NaughtyChild: Parent {
@_implementationOnly public func nonOverridingMethod() {} // expected-error {{'@_implementationOnly' can only be used on overrides}} {{3-24=}}
@_implementationOnly public var nonOverridingProperty: Int { 0 } // expected-error {{'@_implementationOnly' can only be used on overrides}} {{3-24=}}
public override init() {} // okay
public override init(SECRET: Int32) {} // expected-error {{override of initializer imported as implementation-only must be declared '@_implementationOnly'}} {{3-3=@_implementationOnly }}
public required init(requiredSECRET: Int32) {} // expected-error {{override of initializer imported as implementation-only must be declared '@_implementationOnly'}} {{3-3=@_implementationOnly }}
public override func methodSECRET() {} // expected-error {{override of instance method imported as implementation-only must be declared '@_implementationOnly'}} {{3-3=@_implementationOnly }}
public override func methodWithSECRETType() -> SECRETType? { nil } // expected-error {{override of instance method imported as implementation-only must be declared '@_implementationOnly'}} {{3-3=@_implementationOnly }} expected-error {{cannot use class 'SECRETType' here; 'FooKit_SECRET' has been imported as implementation-only}} {{none}}
public override var roPropSECRET: Parent? { nil } // expected-error {{override of property imported as implementation-only must be declared '@_implementationOnly'}} {{3-3=@_implementationOnly }}
public override var rwPropSECRET: Parent? { // expected-error {{override of property imported as implementation-only must be declared '@_implementationOnly'}} {{3-3=@_implementationOnly }}
get { nil }
set {}
}
public override subscript(_ index: Int32) -> Parent? { nil } // expected-error {{override of subscript imported as implementation-only must be declared '@_implementationOnly'}} {{3-3=@_implementationOnly }}
public override var redefinedPropSECRET: Parent? { // FIXME: the setter here is from the implementation-only import, so we'd like to complain about this too.
get { nil }
set {}
}
}
public class NaughtyChildByType: Parent {
@_implementationOnly public override var roPropSECRET: NaughtyChildByType? { nil } // expected-error {{'@_implementationOnly' override must have the same type as the declaration it overrides ('Parent?')}} {{none}}
@_implementationOnly public override subscript(_ index: Int32) -> NaughtyChildByType? { nil } // expected-error {{'@_implementationOnly' override must have the same type as the declaration it overrides ('(Int32) -> Parent?')}} {{none}}
}
public class NaughtyConcreteChildByType: GenericParent<Parent> {
@_implementationOnly public override var roPropSECRET: NaughtyChildByType? { nil } // expected-error {{'@_implementationOnly' override must have the same type as the declaration it overrides ('Parent?')}} {{none}}
@_implementationOnly public override subscript(_ index: Int32) -> NaughtyChildByType? { nil } // expected-error {{'@_implementationOnly' override must have the same type as the declaration it overrides ('(Int32) -> Parent?')}} {{none}}
}
public class NaughtyGrandchild: GoodChild {
public override func methodSECRET() {} // expected-error {{override of '@_implementationOnly' instance method should also be declared '@_implementationOnly'}} {{3-3=@_implementationOnly }}
public override func methodWithSECRETType() -> SECRETType? { nil } // expected-error {{override of '@_implementationOnly' instance method should also be declared '@_implementationOnly'}} {{3-3=@_implementationOnly }} expected-error {{cannot use class 'SECRETType' here; 'FooKit_SECRET' has been imported as implementation-only}} {{none}}
public override var roPropSECRET: Parent? { nil } // expected-error {{override of '@_implementationOnly' property should also be declared '@_implementationOnly'}} {{3-3=@_implementationOnly }}
public override var rwPropSECRET: Parent? { // expected-error {{override of '@_implementationOnly' property should also be declared '@_implementationOnly'}} {{3-3=@_implementationOnly }}
get { nil }
set {}
}
public override subscript(_ index: Int32) -> Parent? { nil } // expected-error {{override of '@_implementationOnly' subscript should also be declared '@_implementationOnly'}} {{3-3=@_implementationOnly }}
public override var redefinedPropSECRET: Parent? { // expected-error {{override of '@_implementationOnly' property should also be declared '@_implementationOnly'}} {{3-3=@_implementationOnly }}
get { nil }
set {}
}
}
#endif // ERRORS
|
