1 /*
2 * @test /nodynamiccopyright/
3 * @bug 8194743
4 * @library /tools/javac/lib
5 * @summary Permit additional statements before this/super in constructors
6 * @modules jdk.compiler/com.sun.tools.javac.tree
7 * jdk.compiler/com.sun.tools.javac.util
8 * @enablePreview
9 * @compile/fail/ref=SuperInitFails.out -XDrawDiagnostics SuperInitFails.java
10 */
11 import java.util.concurrent.atomic.AtomicReference;
12 public class SuperInitFails extends AtomicReference<Object> implements Iterable<Object> {
13
14 private int x;
15
16 /// GOOD EXAMPLES
17
18 public SuperInitFails() { // this should be OK
19 }
20
21 public SuperInitFails(Object x) {
22 this.x = x.hashCode(); // this should be OK
23 }
24
25 public SuperInitFails(byte x) {
26 super(); // this should be OK
27 }
28
29 public SuperInitFails(char x) {
30 this((int)x); // this should be OK
31 }
32
33 /// FAIL EXAMPLES
34
35 {
36 this(1); // this should FAIL
37 }
38
39 {
40 super(); // this should FAIL
41 }
42
43 void normalMethod1() {
44 super(); // this should FAIL
45 }
46
47 void normalMethod2() {
48 this(); // this should FAIL
49 }
50
51 void normalMethod3() {
52 Runnable r = () -> super(); // this should FAIL
53 }
54
55 void normalMethod4() {
56 Runnable r = () -> this(); // this should FAIL
57 }
58
59 public SuperInitFails(short x) {
60 hashCode(); // this should FAIL
61 super();
62 }
63
64 public SuperInitFails(float x) {
65 this.hashCode(); // this should FAIL
66 super();
67 }
68
69 public SuperInitFails(int x) {
70 super.hashCode(); // this should FAIL
71 super();
72 }
73
74 public SuperInitFails(long x) {
75 SuperInitFails.this.hashCode(); // this should FAIL
76 super();
77 }
78
79 public SuperInitFails(double x) {
80 SuperInitFails.super.hashCode(); // this should FAIL
81 super();
82 }
83
84 public SuperInitFails(byte[] x) {
85 {
86 super(); // this should FAIL
87 }
88 }
89
90 public SuperInitFails(char[] x) {
91 if (x.length == 0)
92 return; // this should FAIL
93 super();
94 }
95
96 public SuperInitFails(short[] x) {
97 this.x++; // this should FAIL
98 super();
99 }
100
101 public SuperInitFails(float[] x) {
102 System.identityHashCode(this); // this should FAIL
103 super();
104 }
105
106 public SuperInitFails(int[] x) {
107 this(this); // this should FAIL
108 }
109
110 public SuperInitFails(long[] x) {
111 this(Object.this); // this should FAIL
112 }
113
114 public SuperInitFails(double[] x) {
115 Iterable.super.spliterator(); // this should FAIL
116 super();
117 }
118
119 public SuperInitFails(byte[][] x) {
120 super(new Object() {
121 {
122 super(); // this should FAIL
123 }
124 });
125 }
126
127 public SuperInitFails(char[][] x) {
128 new Inner1(); // this should FAIL
129 super();
130 }
131
132 class Inner1 {
133 }
134
135 record Record1(int value) {
136 Record1(float x) { // this should FAIL
137 }
138 }
139
140 record Record2(int value) {
141 Record2(float x) { // this should FAIL
142 super();
143 }
144 }
145
146 @Override
147 public java.util.Iterator<Object> iterator() {
148 return null;
149 }
150
151 public SuperInitFails(float[][] x) {
152 Runnable r = () -> {
153 super(); // this should FAIL
154 };
155 }
156
157 public SuperInitFails(int[][] z) {
158 super((Runnable)() -> System.err.println(x)); // this should FAIL
159 }
160
161 public SuperInitFails(long[][] z) {
162 super(new Inner1()); // this should FAIL
163 }
164
165 public static class Inner2 {
166 int x;
167 }
168 public static class Inner3 extends Inner2 {
169 int y;
170 Inner3(byte z) {
171 x = z; // this should FAIL
172 super();
173 }
174 Inner3(short z) {
175 this.x = z; // this should FAIL
176 super();
177 }
178 Inner3(char z) {
179 Inner3.this.x = z; // this should FAIL
180 super();
181 }
182 Inner3(int z) {
183 super.x = z; // this should FAIL
184 super();
185 }
186 }
187
188 public SuperInitFails(double[][] x) {
189 Runnable r = () -> this.x = 7; // this should FAIL
190 super();
191 }
192
193 public int xx;
194
195 SuperInitFails(short[][] ignore) {
196 int i = new SuperInitFails(){
197 void foo() {
198 System.err.println(xx); // this one is OK, reading field `xx` in the anonymous class
199 }
200 }.xx; // this one is OK too, field of a fully constructed class
201 super(null);
202 }
203
204 public static class Inner4 {
205 Inner4() {
206 Runnable r = () -> {
207 class A {
208 A() {
209 return; // this should FAIL
210 super();
211 }
212 A(int x) {
213 {
214 this(); // this should FAIL
215 }
216 }
217 A(char x) {
218 super();
219 this(); // this should FAIL
220 }
221 }
222 };
223 super();
224 };
225 }
226
227 static class Inner5 {
228 int x = 4;
229 static String m1(Runnable r) { return null; }
230 static String m2(Object r) { return null; }
231 Inner5() {
232 m1(() -> System.out.println(x)).toString();
233 m2(x).toString();
234 super();
235 }
236 }
237
238 static class Inner6 {
239 Inner6() {
240 class Bar {
241 Bar() {
242 Object o = Bar.this;
243 super();
244 }
245 }
246 super();
247 }
248 }
249
250 static class Inner7 {
251 private int x;
252
253 public Inner7(byte y) {
254 x = y;
255 this((int)y);
256 }
257 public Inner7(int x) {
258 this.x = x;
259 super();
260 }
261 }
262
263 static class Inner8 {
264 final int x;
265
266 Inner8() {
267 this(x = 3); // error
268 }
269 Inner8(int i) {
270 x = 4;
271 }
272 }
273
274 static class Inner9 {
275 interface Parent {
276 boolean check = true;
277 }
278
279 class Medium implements Parent {}
280
281 class Inner9Test extends Medium {
282 Inner9Test() {
283 boolean check1 = Inner9Test.super.check;
284 boolean check2 = super.check;
285 super();
286 }
287 }
288 }
289
290 static class Inner10 {
291 static boolean testMethod() { return true; }
292 Inner10() {}
293 Inner10(int a) {
294 Inner10.this.testMethod();
295 this();
296 }
297 }
298
299 static class Inner11 {
300 class Inner11_1 {
301 static <T> void m() {}
302 }
303
304 class Inner11_2 extends Inner11_1 {
305 Inner11_2() {
306 Inner11_1.super.<String>m();
307 super();
308 }
309 }
310 }
311
312 static class Inner12 {
313 static final boolean check = true;
314 Inner12() {}
315 Inner12(int a) {
316 boolean b = Inner12.this.check; //compilation error expected here
317 this();
318 }
319 }
320
321 static class Inner13 {
322 static final boolean check = true;
323 class Inner13_1 {
324 Inner13_1(int a) {
325 boolean b = Inner13.this.check;
326 this();
327 }
328 Inner13_1() {}
329 }
330 }
331 }