1 /*
2 * Copyright (c) 2015, 2018, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 /*
25 * @test
26 * @bug 8144903 8177466 8191842 8211694 8213725 8239536
27 * @summary Tests for EvaluationState.variables
28 * @library /tools/lib
29 * @modules jdk.compiler/com.sun.tools.javac.api
30 * jdk.compiler/com.sun.tools.javac.main
31 * jdk.jshell
32 * @build Compiler KullaTesting TestingInputStream ExpectedDiagnostic
33 * @run testng VariablesTest
34 */
35
36 import java.nio.file.Path;
37 import java.nio.file.Paths;
38 import java.util.List;
39 import javax.tools.Diagnostic;
40
41 import jdk.jshell.Snippet;
42 import jdk.jshell.TypeDeclSnippet;
43 import jdk.jshell.VarSnippet;
44 import jdk.jshell.Snippet.SubKind;
45 import jdk.jshell.SnippetEvent;
46 import org.testng.annotations.BeforeMethod;
47 import org.testng.annotations.Test;
48
49 import static java.util.stream.Collectors.toList;
50 import static jdk.jshell.Snippet.Status.*;
setUp()51 import static jdk.jshell.Snippet.SubKind.VAR_DECLARATION_SUBKIND;
52 import static org.testng.Assert.assertEquals;
53 import static org.testng.Assert.fail;
54
55 @Test
testVarValue()56 public class VariablesTest extends KullaTesting {
57
58 public void noVariables() {
59 assertNumberOfActiveVariables(0);
60 }
61
62 private void badVarValue(VarSnippet key) {
63 try {
64 getState().varValue(key);
65 fail("Expected exception for: " + key.source());
66 } catch (IllegalArgumentException e) {
67 // ok
68 }
69 }
70
71 public void testVarValue1() {
72 VarSnippet v1 = varKey(assertEval("und1 a;", added(RECOVERABLE_NOT_DEFINED)));
73 badVarValue(v1);
74 VarSnippet v2 = varKey(assertEval("und2 a;",
75 ste(MAIN_SNIPPET, RECOVERABLE_NOT_DEFINED, RECOVERABLE_NOT_DEFINED, false, null),
76 ste(v1, RECOVERABLE_NOT_DEFINED, OVERWRITTEN, false, MAIN_SNIPPET)));
77 badVarValue(v2);
78 TypeDeclSnippet und = classKey(assertEval("class und2 {}",
79 added(VALID),
80 ste(v2, RECOVERABLE_NOT_DEFINED, VALID, true, MAIN_SNIPPET)));
81 assertVarValue(v2, "null");
82 assertDrop(und,
83 DiagCheck.DIAG_OK,
84 DiagCheck.DIAG_ERROR,
85 ste(und, VALID, DROPPED, true, null),
86 ste(v2, VALID, RECOVERABLE_NOT_DEFINED, true, und));
87 badVarValue(v1);
88 badVarValue(v2);
89 }
90
91 public void testVarValue2() {
92 VarSnippet v1 = (VarSnippet) assertDeclareFail("int a = 0.0;", "compiler.err.prob.found.req");
93 badVarValue(v1);
94 VarSnippet v2 = varKey(assertEval("int a = 0;", added(VALID)));
95 assertDrop(v2, ste(MAIN_SNIPPET, VALID, DROPPED, true, null));
96 badVarValue(v2);
97 }
98
99 public void testSignature1() {
100 VarSnippet v1 = varKey(assertEval("und1 a;", added(RECOVERABLE_NOT_DEFINED)));
101 assertVariableDeclSnippet(v1, "a", "und1", RECOVERABLE_NOT_DEFINED, VAR_DECLARATION_SUBKIND, 1, 0);
102 VarSnippet v2 = varKey(assertEval("und2 a;",
103 ste(MAIN_SNIPPET, RECOVERABLE_NOT_DEFINED, RECOVERABLE_NOT_DEFINED, false, null),
104 ste(v1, RECOVERABLE_NOT_DEFINED, OVERWRITTEN, false, MAIN_SNIPPET)));
105 assertVariableDeclSnippet(v2, "a", "und2", RECOVERABLE_NOT_DEFINED, VAR_DECLARATION_SUBKIND, 1, 0);
106 TypeDeclSnippet und = classKey(assertEval("class und2 {}",
107 added(VALID),
108 ste(v2, RECOVERABLE_NOT_DEFINED, VALID, true, MAIN_SNIPPET)));
109 assertVariableDeclSnippet(v2, "a", "und2", VALID, VAR_DECLARATION_SUBKIND, 0, 0);
110 assertDrop(und,
111 DiagCheck.DIAG_OK,
112 DiagCheck.DIAG_ERROR,
113 ste(und, VALID, DROPPED, true, null),
114 ste(v2, VALID, RECOVERABLE_NOT_DEFINED, true, und));
115 assertVariableDeclSnippet(v2, "a", "und2", RECOVERABLE_NOT_DEFINED, VAR_DECLARATION_SUBKIND, 1, 0);
116 }
117
118 public void testSignature2() {
119 VarSnippet v1 = (VarSnippet) assertDeclareFail("int a = 0.0;", "compiler.err.prob.found.req");
120 assertVariableDeclSnippet(v1, "a", "int", REJECTED, SubKind.VAR_DECLARATION_WITH_INITIALIZER_SUBKIND, 0, 1);
121 VarSnippet v2 = varKey(assertEval("int a = 0;",
122 added(VALID)));
123 assertVariableDeclSnippet(v2, "a", "int", VALID, SubKind.VAR_DECLARATION_WITH_INITIALIZER_SUBKIND, 0, 0);
124 assertDrop(v2, ste(MAIN_SNIPPET, VALID, DROPPED, true, null));
125 assertVariableDeclSnippet(v2, "a", "int", DROPPED, SubKind.VAR_DECLARATION_WITH_INITIALIZER_SUBKIND, 0, 0);
126 }
127
128 public void variables() {
129 VarSnippet snx = varKey(assertEval("int x = 10;"));
130 VarSnippet sny = varKey(assertEval("String y = \"hi\";"));
131 VarSnippet snz = varKey(assertEval("long z;"));
132 assertVariables(variable("int", "x"), variable("String", "y"), variable("long", "z"));
133 assertVarValue(snx, "10");
134 assertVarValue(sny, "\"hi\"");
135 assertVarValue(snz, "0");
136 assertActiveKeys();
137 }
138
139 public void variablesArray() {
140 VarSnippet sn = varKey(assertEval("int[] a = new int[12];"));
141 assertEquals(sn.typeName(), "int[]");
142 assertEval("int len = a.length;", "12");
143 assertVariables(variable("int[]", "a"), variable("int", "len"));
144 assertActiveKeys();
145 }
146
147 public void variablesArrayOld() {
148 VarSnippet sn = varKey(assertEval("int a[] = new int[12];"));
149 assertEquals(sn.typeName(), "int[]");
150 assertEval("int len = a.length;", "12");
151 assertVariables(variable("int[]", "a"), variable("int", "len"));
152 assertActiveKeys();
153 }
154
155 public void variablesRedefinition() {
156 Snippet x = varKey(assertEval("int x = 10;"));
157 Snippet y = varKey(assertEval("String y = \"\";", added(VALID)));
158 assertVariables(variable("int", "x"), variable("String", "y"));
159 assertActiveKeys();
160 assertEval("long x;",
161 ste(MAIN_SNIPPET, VALID, VALID, true, null),
162 ste(x, VALID, OVERWRITTEN, false, MAIN_SNIPPET));
163 assertVariables(variable("long", "x"), variable("String", "y"));
164 assertActiveKeys();
165 assertEval("String y;",
166 ste(MAIN_SNIPPET, VALID, VALID, false, null),
167 ste(y, VALID, OVERWRITTEN, false, MAIN_SNIPPET));
168 assertVariables(variable("long", "x"), variable("String", "y"));
169 assertActiveKeys();
170 }
171
172 public void variablesTemporary() {
173 assertEval("int $1 = 10;", added(VALID));
174 assertEval("2 * $1;", added(VALID));
175 assertVariables(variable("int", "$1"), variable("int", "$2"));
176 assertActiveKeys();
177 assertEval("String y;", added(VALID));
178 assertVariables(variable("int", "$1"), variable("int", "$2"), variable("String", "y"));
179 assertActiveKeys();
180 }
181
182 public void variablesTemporaryNull() {
183 assertEval("null;", added(VALID));
184 assertVariables(variable("Object", "$1"));
185 assertEval("(String) null;", added(VALID));
186 assertVariables(variable("Object", "$1"), variable("String", "$2"));
187 assertActiveKeys();
188 assertEval("\"\";", added(VALID));
189 assertVariables(
190 variable("Object", "$1"),
191 variable("String", "$2"),
192 variable("String", "$3"));
193 assertActiveKeys();
194 }
195
196 public void variablesTemporaryArrayOfCapturedType() {
197 assertEval("class Test<T> { T[][] get() { return null; } }", added(VALID));
198 assertEval("Test<? extends String> test() { return new Test<>(); }", added(VALID));
199 assertEval("test().get()", added(VALID));
200 assertVariables(variable("String[][]", "$1"));
201 assertEval("\"\".getClass().getEnumConstants()", added(VALID));
202 assertVariables(variable("String[][]", "$1"), variable("String[]", "$2"));
203 assertActiveKeys();
204 }
205
206 public void variablesClassReplace() {
207 assertEval("import java.util.*;", added(VALID));
208 Snippet var = varKey(assertEval("List<Integer> list = new ArrayList<>();", "[]",
209 added(VALID)));
210 assertVariables(variable("List<Integer>", "list"));
211 assertEval("class List {}",
212 DiagCheck.DIAG_OK,
213 DiagCheck.DIAG_ERROR,
214 added(VALID),
215 ste(var, VALID, RECOVERABLE_NOT_DEFINED, true, MAIN_SNIPPET));
216 assertVariables();
217 assertEval("List list = new List();",
218 DiagCheck.DIAG_OK, DiagCheck.DIAG_IGNORE,
219 ste(MAIN_SNIPPET, RECOVERABLE_NOT_DEFINED, VALID, true, null),
220 ste(var, RECOVERABLE_NOT_DEFINED, OVERWRITTEN, false, MAIN_SNIPPET));
221 assertVariables(variable("List", "list"));
222 assertActiveKeys();
223 }
224
225 public void variablesErrors() {
226 assertDeclareFail("String;", new ExpectedDiagnostic("compiler.err.cant.resolve.location", 0, 6, 0, -1, -1, Diagnostic.Kind.ERROR));
227 assertNumberOfActiveVariables(0);
228 assertActiveKeys();
229 }
230
231 public void variablesUnresolvedActiveFailed() {
232 VarSnippet key = varKey(assertEval("und x;", added(RECOVERABLE_NOT_DEFINED)));
233 assertVariableDeclSnippet(key, "x", "und", RECOVERABLE_NOT_DEFINED, VAR_DECLARATION_SUBKIND, 1, 0);
234 assertUnresolvedDependencies1(key, RECOVERABLE_NOT_DEFINED, "class und");
235 assertNumberOfActiveVariables(1);
236 assertActiveKeys();
237 }
238
239 public void variablesUnresolvedError() {
240 assertDeclareFail("und y = null;", new ExpectedDiagnostic("compiler.err.cant.resolve.location", 0, 3, 0, -1, -1, Diagnostic.Kind.ERROR));
241 assertNumberOfActiveVariables(0);
242 assertActiveKeys();
243 }
244
245 public void variablesMultiByteCharacterType() {
246 assertEval("class \u3042 {}");
247 assertEval("\u3042 \u3042 = null;", added(VALID));
248 assertVariables(variable("\u3042", "\u3042"));
249 assertEval("new \u3042()", added(VALID));
250 assertVariables(variable("\u3042", "\u3042"), variable("\u3042", "$1"));
251
252 assertEval("class \u3042\u3044\u3046\u3048\u304a {}");
253 assertEval("\u3042\u3044\u3046\u3048\u304a \u3042\u3044\u3046\u3048\u304a = null;", added(VALID));
254 assertVariables(variable("\u3042", "\u3042"), variable("\u3042", "$1"),
255 variable("\u3042\u3044\u3046\u3048\u304a", "\u3042\u3044\u3046\u3048\u304a"));
256 assertEval("new \u3042\u3044\u3046\u3048\u304a();");
257 assertVariables(variable("\u3042", "\u3042"), variable("\u3042", "$1"),
258 variable("\u3042\u3044\u3046\u3048\u304a", "\u3042\u3044\u3046\u3048\u304a"),
259 variable("\u3042\u3044\u3046\u3048\u304a", "$2"));
260 assertActiveKeys();
261 }
262
263 @Test(enabled = false) // TODO 8081689
264 public void methodVariablesAreNotVisible() {
265 Snippet foo = varKey(assertEval("int foo() {" +
266 "int x = 10;" +
267 "int y = 2 * x;" +
268 "return x * y;" +
269 "}", added(VALID)));
270 assertNumberOfActiveVariables(0);
271 assertActiveKeys();
272 assertEval("int x = 10;", "10");
273 assertEval("int foo() {" +
274 "int y = 2 * x;" +
275 "return x * y;" +
276 "}",
277 ste(foo, VALID, VALID, false, null));
278 assertVariables(variable("int", "x"));
279 assertActiveKeys();
280 assertEval("foo();", "200");
281 assertVariables(variable("int", "x"), variable("int", "$1"));
282 assertActiveKeys();
283 }
284
285 @Test(enabled = false) // TODO 8081689
286 public void classFieldsAreNotVisible() {
287 Snippet key = classKey(assertEval("class clazz {" +
288 "int x = 10;" +
289 "int y = 2 * x;" +
290 "}"));
291 assertNumberOfActiveVariables(0);
292 assertEval("int x = 10;", "10");
293 assertActiveKeys();
294 assertEval(
295 "class clazz {" +
296 "int y = 2 * x;" +
297 "}",
298 ste(key, VALID, VALID, true, null));
299 assertVariables(variable("int", "x"));
300 assertEval("new clazz().y;", "20");
301 assertVariables(variable("int", "x"), variable("int", "$1"));
302 assertActiveKeys();
303 }
304
305 public void multiVariables() {
306 List<SnippetEvent> abc = assertEval("int a, b, c = 10;",
307 DiagCheck.DIAG_OK, DiagCheck.DIAG_OK,
308 chain(added(VALID)),
309 chain(added(VALID)),
310 chain(added(VALID)));
311 Snippet a = abc.get(0).snippet();
312 Snippet b = abc.get(1).snippet();
313 Snippet c = abc.get(2).snippet();
314 assertVariables(variable("int", "a"), variable("int", "b"), variable("int", "c"));
315 assertEval("double a = 1.4, b = 8.8;", DiagCheck.DIAG_OK, DiagCheck.DIAG_OK,
316 chain(ste(MAIN_SNIPPET, VALID, VALID, true, null), ste(a, VALID, OVERWRITTEN, false, MAIN_SNIPPET)),
317 chain(ste(MAIN_SNIPPET, VALID, VALID, true, null), ste(b, VALID, OVERWRITTEN, false, MAIN_SNIPPET)));
318 assertVariables(variable("double", "a"), variable("double", "b"), variable("int", "c"));
319 assertEval("double c = a + b;",
320 ste(MAIN_SNIPPET, VALID, VALID, true, null),
321 ste(c, VALID, OVERWRITTEN, false, MAIN_SNIPPET));
322 assertVariables(variable("double", "a"), variable("double", "b"), variable("double", "c"));
323 assertActiveKeys();
324 }
325
326 public void syntheticVariables() {
327 assertEval("assert false;");
328 assertNumberOfActiveVariables(0);
329 assertActiveKeys();
330 }
331
332 public void undefinedReplaceVariable() {
333 Snippet key = varKey(assertEval("int d = 234;", "234"));
334 assertVariables(variable("int", "d"));
335 String src = "undefined d;";
336 Snippet undefKey = varKey(assertEval(src,
337 ste(MAIN_SNIPPET, VALID, RECOVERABLE_NOT_DEFINED, true, null),
338 ste(key, VALID, OVERWRITTEN, false, MAIN_SNIPPET)));
339 //assertEquals(getState().source(snippet), src);
340 //assertEquals(snippet, undefKey);
341 assertEquals(getState().status(undefKey), RECOVERABLE_NOT_DEFINED);
342 List<String> unr = getState().unresolvedDependencies((VarSnippet) undefKey).collect(toList());;
343 assertEquals(unr.size(), 1);
344 assertEquals(unr.get(0), "class undefined");
345 assertVariables(variable("undefined", "d"));
346 }
347
348 public void lvti() {
349 assertEval("var d = 234;", "234");
350 assertEval("class Test<T> { T[][] get() { return null; } }", added(VALID));
351 assertEval("Test<? extends String> test() { return new Test<>(); }", added(VALID));
352 assertEval("var t = test().get();", added(VALID));
353 assertEval("<Z extends Runnable & CharSequence> Z get1() { return null; }", added(VALID));
354 assertEval("var i1 = get1();", added(VALID));
355 assertEval("void t1() { i1.run(); i1.length(); }", added(VALID));
356 assertEval("i1 = 1;", DiagCheck.DIAG_ERROR, DiagCheck.DIAG_OK, ste(MAIN_SNIPPET, NONEXISTENT, REJECTED, false, null));
357 assertEval("<Z extends Number & CharSequence> Z get2() { return null; }", added(VALID));
358 assertEval("var i2 = get2();", added(VALID));
359 assertEval("void t2() { i2.length(); }", added(VALID));
360 assertEval("var r1 = new Runnable() { public void run() { } public String get() { return \"good\"; } };", added(VALID));
361 assertEval("Runnable r2 = r1;");
362 assertEval("r1.get()", "\"good\"");
363 assertEval("var v = r1.get();", "\"good\"");
364 assertEval("var r3 = new java.util.ArrayList<String>(42) { public String get() { return \"good\"; } };", added(VALID));
365 assertEval("r3.get()", "\"good\"");
366 assertEval("class O { public class Inner { public String test() { return \"good\"; } } }");
367 assertEval("var r4 = new O().new Inner() { public String get() { return \"good\"; } };");
368 assertEval("r4.get()", "\"good\"");
369 assertEval("class O2 { public class Inner { public Inner(int i) { } public String test() { return \"good\"; } } }");
370 assertEval("var r5 = new O2().new Inner(1) { public String get() { return \"good\"; } };");
371 assertEval("r5.get()", "\"good\"");
372 assertEval("<Z> Z identity(Z z) { return z; }");
373 assertEval("var r6 = identity(new Object() { String s = \"good\"; });");
374 assertEval("r6.s", "\"good\"");
375 assertEval("interface I<B, C> { C get(B b); }");
376 assertEval("<A, B, C> C cascade(A a, I<A, B> c1, I<B, C> c2) { return c2.get(c1.get(a)); }");
377 assertEval("var r7 = cascade(\"good\", a -> new Object() { String s = a; }, b -> new java.util.ArrayList<String>(5) { String s = b.s; });");
378 assertEval("r7.s", "\"good\"");
379 assertEval("var r8 = cascade(\"good\", a -> new Object() { String s = a; public String getS() { return s; } }, b -> new java.util.ArrayList<String>(5) { String s = b.getS(); public String getS() { return s; } });");
380 assertEval("r8.getS()", "\"good\"");
381 assertEval("var r9 = new Object() { class T { class Inner { public String g() { return outer(); } } public String outer() { return \"good\"; } public String test() { return new Inner() {}.g(); } } public String test() { return new T().test(); } };");
382 assertEval("r9.test()", "\"good\"");
383 assertEval("var nested1 = new Object() { class N { public String get() { return \"good\"; } } };");
384 assertEval("nested1.new N().get()", "\"good\"");
385 assertEval("var nested2 = cascade(\"good\", a -> new Object() { abstract class G { abstract String g(); } G g = new G() { String g() { return a; } }; }, b -> new java.util.ArrayList<String>(5) { String s = b.g.g(); });");
386 assertEval("nested2.s", "\"good\"");
387 assertEval("<A, B> B convert(A a, I<A, B> c) { return c.get(a); }");
388 assertEval("var r10 = convert(\"good\", a -> new api.C(12) { public String val = \"\" + i + s + l + a; } );");
389 assertEval("r10.val", "\"12empty[empty]good\"");
390 assertEval("var r11 = convert(\"good\", a -> new api.C(\"a\") { public String val = \"\" + i + s + l + a; } );");
391 assertEval("r11.val", "\"3a[empty]good\"");
392 assertEval("import api.C;");
393 assertEval("var r12 = convert(\"good\", a -> new C(java.util.List.of(\"a\")) { public String val = \"\" + i + s + l + a; } );");
394 assertEval("r12.val", "\"4empty[a]good\"");
395 assertEval("var r13 = convert(\"good\", a -> new api.G<String>(java.util.List.of(\"b\")) { public String val = \"\" + l + a; } );");
396 assertEval("r13.val", "\"[b]good\"");
397 assertEval("var r14 = convert(\"good\", a -> new api.J<String>() { public java.util.List<String> get() { return java.util.List.of(a, \"c\"); } } );");
398 assertEval("r14.get()", "[good, c]");
399 assertEval("var r15a = new java.util.ArrayList<String>();");
400 assertEval("r15a.add(\"a\");");
401 assertEval("var r15b = r15a.get(0);");
402 assertEval("r15b", "\"a\"");
403 }
404
405 public void test8191842() {
406 assertEval("import java.util.stream.*;");
407 assertEval("var list = Stream.of(1, 2, 3).map(j -> new Object() { int i = j; }).collect(Collectors.toList());");
408 assertEval("list.stream().map(a -> String.valueOf(a.i)).collect(Collectors.joining(\", \"));", "\"1, 2, 3\"");
409 }
410
411 public void lvtiRecompileDependentsWithIntersectionTypes() {
412 assertEval("<Z extends Runnable & CharSequence> Z get1() { return null; }", added(VALID));
413 VarSnippet var = varKey(assertEval("var i1 = get1();", added(VALID)));
414 assertEval("import java.util.stream.*;", added(VALID),
415 ste(var, VALID, VALID, true, MAIN_SNIPPET));
416 assertEval("void t1() { i1.run(); i1.length(); }", added(VALID));
417 }
418
419 public void arrayInit() {
420 assertEval("int[] d = {1, 2, 3};");
421 }
422
423 public void testAnonymousVar() {
424 assertEval("new Object() { public String get() { return \"a\"; } }");
425 assertEval("$1.get()", "\"a\"");
426 }
427
428 public void testIntersectionVar() {
429 assertEval("<Z extends Runnable & CharSequence> Z get() { return null; }", added(VALID));
430 assertEval("get();", added(VALID));
431 assertEval("void t1() { $1.run(); $1.length(); }", added(VALID));
432 }
433
434 public void multipleCaptures() {
435 assertEval("class D { D(int foo, String bar) { this.foo = foo; this.bar = bar; } int foo; String bar; } ");
436 assertEval("var d = new D(34, \"hi\") { String z = foo + bar; };");
437 assertEval("d.z", "\"34hi\"");
438 }
439
440 public void multipleAnonymous() {
441 VarSnippet v1 = varKey(assertEval("new Object() { public int i = 42; public int i1 = i; public int m1() { return i1; } };"));
442 VarSnippet v2 = varKey(assertEval("new Object() { public int i = 42; public int i2 = i; public int m2() { return i2; } };"));
443 assertEval(v1.name() + ".i", "42");
444 assertEval(v1.name() + ".i1", "42");
445 assertEval(v1.name() + ".m1()", "42");
446 assertDeclareFail(v1.name() + ".i2",
447 new ExpectedDiagnostic("compiler.err.cant.resolve.location", 0, 5, 2,
448 -1, -1, Diagnostic.Kind.ERROR));
449 assertEval(v2.name() + ".i", "42");
450 assertEval(v2.name() + ".i2", "42");
451 assertEval(v2.name() + ".m2()", "42");
452 assertDeclareFail(v2.name() + ".i1",
453 new ExpectedDiagnostic("compiler.err.cant.resolve.location", 0, 5, 2,
454 -1, -1, Diagnostic.Kind.ERROR));
455 }
456
457 public void displayName() {
458 assertVarDisplayName("var v1 = 234;", "int");
459 assertVarDisplayName("var v2 = new int[] {234};", "int[]");
460 assertEval("<Z extends Runnable & CharSequence> Z get() { return null; }", added(VALID));
461 assertVarDisplayName("var v3 = get();", "CharSequence&Runnable");
462 assertVarDisplayName("var v4a = new java.util.ArrayList<String>();", "java.util.ArrayList<String>");
463 assertEval("v4a.add(\"a\");");
464 assertVarDisplayName("var v4b = v4a.get(0);", "String");
465 assertVarDisplayName("var v5 = new Object() { };", "<anonymous class extending Object>");
466 assertVarDisplayName("var v6 = new Runnable() { public void run() { } };", "<anonymous class implementing Runnable>");
467 }
468
469 public void varType() {
470 assertEval("import java.util.*;");
471 var firstVar = varKey(assertEval("var v1 = List.of(1);", added(VALID)));
472 assertEval("import list.List;", DiagCheck.DIAG_OK, DiagCheck.DIAG_ERROR, added(VALID),
473 ste(firstVar, VALID, RECOVERABLE_NOT_DEFINED, true, MAIN_SNIPPET));
474 assertEval("var v2 = java.util.List.of(1);", added(VALID));
475 assertEval("v2", "[1]");
476 }
477
478 public void varDeclNoInit() {
479 assertVarDeclNoInit("byte", "b", "0");
480 assertVarDeclNoInit("short", "h", "0");
481 assertVarDeclNoInit("int", "i", "0");
482 assertVarDeclNoInit("long", "l", "0");
483 assertVarDeclNoInit("float", "f", "0.0");
484 assertVarDeclNoInit("double", "d", "0.0");
485 assertVarDeclNoInit("boolean", "n", "false");
486 assertVarDeclNoInit("char", "c", "'\\000'");
487 assertVarDeclNoInit("Object", "o", "null");
488 assertVarDeclNoInit("String", "s", "null");
489 }
490
491 public void varDeclRedefNoInit() {
492 assertVarDeclRedefNoInit("byte", "b", "1", "0");
493 assertVarDeclRedefNoInit("short", "h", "2", "0");
494 assertVarDeclRedefNoInit("int", "i", "3", "0");
495 assertVarDeclRedefNoInit("long", "l", "4L", IGNORE_VALUE, "0");
496 assertVarDeclRedefNoInit("float", "f", "3.14f", IGNORE_VALUE, "0.0");
497 assertVarDeclRedefNoInit("double", "d", "3.1415926", "0.0");
498 assertVarDeclRedefNoInit("boolean", "n", "true", "false");
499 assertVarDeclRedefNoInit("char", "c", "'x'", "'\\000'");
500 assertVarDeclRedefNoInit("Object", "o", "new Object()", IGNORE_VALUE, "null");
501 assertVarDeclRedefNoInit("String", "s", "\"hi\"", "null");
502 }
503
504 public void badPkgVarDecl() {
505 Compiler compiler = new Compiler();
506 Path nopkgdirpath = Paths.get("cp", "xyz");
507 compiler.compile(nopkgdirpath,
508 "public class TestZ { public static int V = 0; }\n");
509 assertDeclareFail("import static xyz.TestZ.V;",
510 "compiler.err.cant.access");
511
512
513 VarSnippet v1 = varKey(assertEval("var v = xyz.TestZ.V;", IGNORE_VALUE, null,
514 DiagCheck.DIAG_ERROR, DiagCheck.DIAG_OK, added(RECOVERABLE_NOT_DEFINED)));
515 assertVariableDeclSnippet(v1, "v", "java.lang.Object", RECOVERABLE_NOT_DEFINED, SubKind.VAR_DECLARATION_WITH_INITIALIZER_SUBKIND, 0, 1);
516 assertEval("1+1", "2");
517 }
518
519 private void assertVarDeclRedefNoInit(String typeName, String name, String value, String dvalue) {
520 assertVarDeclRedefNoInit(typeName, name, value, value, dvalue);
521 }
522
523 private void assertVarDeclRedefNoInit(String typeName, String name, String value, String rvalue, String dvalue) {
524 VarSnippet vs = varKey(assertEval(typeName + " " + name + " = " + value + ";", rvalue));
525 assertVarDeclNoInit(typeName, name, dvalue,
526 ste(vs, VALID, VALID, false, null),
527 ste(vs, VALID, OVERWRITTEN, false, MAIN_SNIPPET));
528 }
529
530 private VarSnippet assertVarDeclNoInit(String typeName, String name, String dvalue) {
531 return assertVarDeclNoInit(typeName, name, dvalue, added(VALID));
532 }
533
534 private VarSnippet assertVarDeclNoInit(String typeName, String name, String dvalue, STEInfo mainInfo, STEInfo... updates) {
535 VarSnippet vs = varKey(assertEval(typeName + " " + name + ";", dvalue, mainInfo, updates));
536 assertEquals(vs.typeName(), typeName);
537 assertEval(name, dvalue, added(VALID));
538 return vs;
539 }
540
541 private void assertVarDisplayName(String var, String typeName) {
542 assertEquals(varKey(assertEval(var)).typeName(), typeName);
543 }
544
545 @BeforeMethod
546 @Override
547 public void setUp() {
548 Path path = Paths.get("cp");
549 Compiler compiler = new Compiler();
550 compiler.compile(path,
551 "package api;\n" +
552 "\n" +
553 "import java.util.List;\n" +
554 "\n" +
555 "public class C {\n" +
556 " public int i;\n" +
557 " public String s;\n" +
558 " public List<String> l;\n" +
559 " public C(int i) {\n" +
560 " this.i = i;\n" +
561 " this.s = \"empty\";\n" +
562 " this.l = List.of(\"empty\");\n" +
563 " }\n" +
564 " public C(String s) {\n" +
565 " this.i = 3;\n" +
566 " this.s = s;\n" +
567 " this.l = List.of(\"empty\");\n" +
568 " }\n" +
569 " public C(List<String> l) {\n" +
570 " this.i = 4;\n" +
571 " this.s = \"empty\";\n" +
572 " this.l = l;\n" +
573 " }\n" +
574 "}\n",
575 "package api;\n" +
576 "\n" +
577 "import java.util.List;\n" +
578 "\n" +
579 "public class G<T> {\n" +
580 " public List<T> l;\n" +
581 " public G(List<T> l) {\n" +
582 " this.l = l;\n" +
583 " }\n" +
584 "}\n",
585 "package api;\n" +
586 "\n" +
587 "import java.util.List;\n" +
588 "\n" +
589 "public interface J<T> {\n" +
590 " public List<T> get();\n" +
591 "}\n",
592 "package list;\n" +
593 "\n" +
594 "public class List {\n" +
595 "}\n");
596 String tpath = compiler.getPath(path).toString();
597 setUp(b -> b
598 .remoteVMOptions("--class-path", tpath)
599 .compilerOptions("--class-path", tpath));
600 }
601 }
602