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
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
|
// Test case for issue #611: https://github.com/typetools/checker-framework/issues/611
// @skip-test Disabled until the issue is fixed.
import org.checkerframework.checker.nullness.qual.*;
public class RefineOverride {
void m(Sub<@Nullable String> snb, Sub<@NonNull String> snn) {
snb.m7(null);
snn.m7(null);
}
class Super<T> {
void m1(@NonNull String s) {}
void m2(@NonNull String s) {}
void m5(@NonNull String s) {}
void m6(@Nullable String s) {}
void m7(T s) {}
void m11(@NonNull String s1, @NonNull String s2) {}
void m12(@NonNull String s1, @Nullable String s2) {}
void m13(@Nullable String s1, @NonNull String s2) {}
void m14(@Nullable String s1, @Nullable String s2) {}
void m15(T s1, T s2) {}
void m16(@NonNull T s1, @NonNull T s2) {}
void m17(@NonNull T s1, @Nullable T s2) {}
void m18(@Nullable T s1, @NonNull T s2) {}
void m19(@Nullable T s1, @Nullable T s2) {}
void m21(@Nullable String[] a) {}
void m22(@NonNull String[] a) {}
void m23(@Nullable String[] a) {}
void m24(@NonNull String[] a) {}
void m25(T[] a) {}
void m26(@Nullable T[] a) {}
void m27(@NonNull T[] a) {}
void m28(@Nullable T[] a) {}
void m29(@NonNull T[] a) {}
}
class Sub<T> extends Super<T> {
@Override
void m1(@Nullable String s) {}
@Override
void m2(@PolyNull String s) {}
// In the following declarations, all previously-valid invocations remain
// valid, so the compiler should permit the overriding.
// Case 1. A single parameter type is changed from anything to @PolyNull
// in an overriding method.
@Override
void m5(@PolyNull String s) {}
// TODO: should be legal
@Override
void m6(@PolyNull String s) {}
// TODO: should be legal
@Override
void m7(@PolyNull T s) {}
// Case 2. Multiple parameter types are changed to @PolyNull in an
// overriding method.
// (The types for m14 might be better written as "@PolyNull(1)
// ... @PolyNull(2)", but all invocations remain valid.
@Override
void m11(@PolyNull String s1, @PolyNull String s2) {}
// TODO: should be legal
@Override
void m12(@PolyNull String s1, @PolyNull String s2) {}
// TODO: should be legal
@Override
void m13(@PolyNull String s1, @PolyNull String s2) {}
// TODO: should be legal
@Override
void m14(@PolyNull String s1, @PolyNull String s2) {}
// TODO: should be legal
@Override
void m15(@PolyNull T s1, @PolyNull T s2) {}
@Override
void m16(@PolyNull T s1, @PolyNull T s2) {}
// TODO: should be legal
@Override
void m17(@PolyNull T s1, @PolyNull T s2) {}
// TODO: should be legal
@Override
void m18(@PolyNull T s1, @PolyNull T s2) {}
// TODO: should be legal
@Override
void m19(@PolyNull T s1, @PolyNull T s2) {}
// Case 3. Expand the element type of an array.
// The new permissible types are not supertypes of the old types,
// but they still expand the set of permitted invocations.
// :: error: (override.param.invalid)
@Override
void m21(@NonNull String[] a) {}
// :: error: Changing incompatibly to forbid old invocations is not permitted.
@Override
void m22(@Nullable String[] a) {}
// TODO: should be legal
@Override
void m23(@PolyNull String[] a) {}
@Override
void m24(@PolyNull String[] a) {}
@Override
void m25(@PolyNull T[] a) {}
// :: error: (override.param.invalid)
@Override
void m26(@NonNull T[] a) {}
// :: error: Changing incompatibly to forbid old invocations is not permitted.
@Override
void m27(@Nullable T[] a) {}
// TODO: should be legal
@Override
void m28(@PolyNull T[] a) {}
@Override
void m29(@PolyNull T[] a) {}
}
class Super2<T> {
void t1(String s) {}
void t2(String s) {}
void t3(@Nullable String s) {}
void t4(String s) {}
void t5(String[] s) {}
void t6(T s) {}
void t7(T s) {}
void t8(T[] s) {}
void t9(T[] s) {}
}
class Sub2<T> extends Super2<T> {
@Override
void t1(String s) {}
@Override
void t2(@Nullable String s) {}
// :: error: (override.param.invalid)
@Override
void t3(String s) {}
@Override
void t4(@PolyNull String s) {}
@Override
void t5(@PolyNull String[] s) {}
@Override
void t6(@Nullable T s) {}
// TODO: should be legal
@Override
void t7(@PolyNull T s) {}
@Override
void t8(@Nullable T[] s) {}
// TODO: should be legal
@Override
void t9(@PolyNull T[] s) {}
}
}
|
