1 /*
2 * Copyright (c) 2024, 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 import java.lang.runtime.CodeReflection;
25 import java.util.function.Supplier;
26
27 /*
28 * @test
29 * @summary Smoke test for code reflection with boxing conversions.
30 * @build BoxingConversionTest
31 * @build CodeReflectionTester
32 * @run main CodeReflectionTester BoxingConversionTest
33 */
34
35 public class BoxingConversionTest {
36 @CodeReflection
37 @IR("""
38 func @"test1" (%0 : BoxingConversionTest)void -> {
39 %1 : long = constant @"1";
40 %2 : java.lang.Long = invoke %1 @"java.lang.Long::valueOf(long)java.lang.Long";
41 %3 : Var<java.lang.Long> = var %2 @"x";
42 return;
43 };
44 """)
45 void test1() {
46 Long x = 1L;
47 }
48
49 @CodeReflection
50 @IR("""
51 func @"test2" (%0 : BoxingConversionTest, %1 : java.lang.Long)void -> {
52 %2 : Var<java.lang.Long> = var %1 @"L";
53 %3 : java.lang.Long = var.load %2;
54 %4 : long = invoke %3 @"java.lang.Long::longValue()long";
55 %5 : Var<long> = var %4 @"l";
56 return;
57 };
58 """)
59 void test2(Long L) {
60 long l = L;
61 }
62
63 @CodeReflection
64 @IR("""
65 func @"test3" (%0 : BoxingConversionTest)void -> {
66 %1 : long = constant @"0";
67 %2 : java.lang.Long = invoke %1 @"java.lang.Long::valueOf(long)java.lang.Long";
68 %3 : Var<java.lang.Object> = var %2 @"o";
69 return;
70 };
71 """)
72 void test3() {
73 Object o = 0L;
74 }
75
76 @CodeReflection
77 @IR("""
78 func @"test4" (%0 : BoxingConversionTest, %1 : java.lang.Object)void -> {
79 %2 : Var<java.lang.Object> = var %1 @"o";
80 %3 : java.lang.Object = var.load %2;
81 %4 : java.lang.Long = cast %3 @"java.lang.Long";
82 %5 : long = invoke %4 @"java.lang.Long::longValue()long";
83 %6 : Var<long> = var %5 @"l";
84 return;
85 };
86 """)
87 void test4(Object o) {
88 long l = (long)o;
89 }
90
91 @CodeReflection
92 @IR("""
93 func @"test5" (%0 : BoxingConversionTest, %1 : java.lang.Integer)void -> {
94 %2 : Var<java.lang.Integer> = var %1 @"i2";
95 %3 : java.lang.Integer = var.load %2;
96 %4 : int = constant @"1";
97 %5 : int = invoke %3 @"java.lang.Integer::intValue()int";
98 %6 : int = add %5 %4;
99 %7 : java.lang.Integer = invoke %6 @"java.lang.Integer::valueOf(int)java.lang.Integer";
100 var.store %2 %7;
101 return;
102 };
103 """)
104 void test5(Integer i2) {
105 i2++;
106 }
107
108 @CodeReflection
109 @IR("""
110 func @"test6" (%0 : BoxingConversionTest, %1 : java.lang.Integer)void -> {
111 %2 : Var<java.lang.Integer> = var %1 @"i2";
112 %3 : java.lang.Integer = var.load %2;
113 %4 : int = constant @"3";
114 %5 : int = invoke %3 @"java.lang.Integer::intValue()int";
115 %6 : int = add %5 %4;
116 %7 : java.lang.Integer = invoke %6 @"java.lang.Integer::valueOf(int)java.lang.Integer";
117 var.store %2 %7;
118 return;
119 };
120 """)
121 void test6(Integer i2) {
122 i2 += 3;
123 }
124
125 static class Box {
126 Integer i;
127 }
128
129 @CodeReflection
130 @IR("""
131 func @"test7" (%0 : BoxingConversionTest)void -> {
132 %1 : BoxingConversionTest$Box = new @"func<BoxingConversionTest$Box>";
133 %2 : java.lang.Integer = field.load %1 @"BoxingConversionTest$Box::i()java.lang.Integer";
134 %3 : int = constant @"1";
135 %4 : int = invoke %2 @"java.lang.Integer::intValue()int";
136 %5 : int = add %4 %3;
137 %6 : java.lang.Integer = invoke %5 @"java.lang.Integer::valueOf(int)java.lang.Integer";
138 field.store %1 %6 @"BoxingConversionTest$Box::i()java.lang.Integer";
139 return;
140 };
141 """)
142 void test7() {
143 new Box().i++;
144 }
145
146 @CodeReflection
147 @IR("""
148 func @"test8" (%0 : BoxingConversionTest)void -> {
149 %1 : BoxingConversionTest$Box = new @"func<BoxingConversionTest$Box>";
150 %2 : java.lang.Integer = field.load %1 @"BoxingConversionTest$Box::i()java.lang.Integer";
151 %3 : int = constant @"3";
152 %4 : int = invoke %2 @"java.lang.Integer::intValue()int";
153 %5 : int = add %4 %3;
154 %6 : java.lang.Integer = invoke %5 @"java.lang.Integer::valueOf(int)java.lang.Integer";
155 field.store %1 %6 @"BoxingConversionTest$Box::i()java.lang.Integer";
156 return;
157 };
158 """)
159 void test8() {
160 new Box().i += 3;
161 }
162
163 @CodeReflection
164 @IR("""
165 func @"test9" (%0 : BoxingConversionTest, %1 : int[], %2 : java.lang.Integer)void -> {
166 %3 : Var<int[]> = var %1 @"ia";
167 %4 : Var<java.lang.Integer> = var %2 @"i";
168 %5 : int[] = var.load %3;
169 %6 : int = constant @"0";
170 %7 : int = array.load %5 %6;
171 %8 : java.lang.Integer = var.load %4;
172 %9 : int = invoke %8 @"java.lang.Integer::intValue()int";
173 %10 : int = add %7 %9;
174 array.store %5 %6 %10;
175 return;
176 };
177 """)
178 void test9(int[] ia, Integer i) {
179 ia[0] += i;
180 }
181
182 @CodeReflection
183 @IR("""
184 func @"test10" (%0 : BoxingConversionTest, %1 : boolean, %2 : java.lang.Integer)void -> {
185 %3 : Var<boolean> = var %1 @"cond";
186 %4 : Var<java.lang.Integer> = var %2 @"I";
187 %5 : int = java.cexpression
188 ^cond()boolean -> {
189 %6 : boolean = var.load %3;
190 yield %6;
191 }
192 ^truepart()int -> {
193 %7 : java.lang.Integer = var.load %4;
194 %8 : int = invoke %7 @"java.lang.Integer::intValue()int";
195 yield %8;
196 }
197 ^falsepart()int -> {
198 %9 : int = constant @"2";
199 yield %9;
200 };
201 %10 : Var<int> = var %5 @"res";
202 return;
203 };
204 """)
205 void test10(boolean cond, Integer I) {
206 int res = cond ? I : 2;
207 }
208
209 @CodeReflection
210 @IR("""
211 func @"test11" (%0 : BoxingConversionTest, %1 : boolean, %2 : java.lang.Integer)void -> {
212 %3 : Var<boolean> = var %1 @"cond";
213 %4 : Var<java.lang.Integer> = var %2 @"I";
214 %5 : int = java.cexpression
215 ^cond()boolean -> {
216 %6 : boolean = var.load %3;
217 yield %6;
218 }
219 ^truepart()int -> {
220 %7 : int = constant @"2";
221 yield %7;
222 }
223 ^falsepart()int -> {
224 %8 : java.lang.Integer = var.load %4;
225 %9 : int = invoke %8 @"java.lang.Integer::intValue()int";
226 yield %9;
227 };
228 %10 : Var<int> = var %5 @"res";
229 return;
230 };
231 """)
232 void test11(boolean cond, Integer I) {
233 int res = cond ? 2 : I;
234 }
235
236 @CodeReflection
237 @IR("""
238 func @"test12" (%0 : BoxingConversionTest, %1 : boolean)void -> {
239 %2 : Var<boolean> = var %1 @"cond";
240 %3 : int = java.cexpression
241 ^cond()boolean -> {
242 %4 : boolean = var.load %2;
243 yield %4;
244 }
245 ^truepart()int -> {
246 %5 : int = constant @"1";
247 yield %5;
248 }
249 ^falsepart()int -> {
250 %6 : int = constant @"2";
251 yield %6;
252 };
253 %7 : java.lang.Integer = invoke %3 @"java.lang.Integer::valueOf(int)java.lang.Integer";
254 %8 : Var<java.lang.Integer> = var %7 @"x";
255 return;
256 };
257 """)
258 void test12(boolean cond) {
259 Integer x = cond ? 1 : 2;
260 }
261
262 @CodeReflection
263 @IR("""
264 func @"test13" (%0 : BoxingConversionTest)void -> {
265 %1 : java.util.function.Supplier<java.lang.Integer> = lambda ()java.lang.Integer -> {
266 %2 : int = constant @"1";
267 %3 : java.lang.Integer = invoke %2 @"java.lang.Integer::valueOf(int)java.lang.Integer";
268 return %3;
269 };
270 %4 : Var<java.util.function.Supplier<java.lang.Integer>> = var %1 @"s";
271 return;
272 };
273 """)
274 void test13() {
275 Supplier<Integer> s = () -> { return 1; };
276 }
277
278 @CodeReflection
279 @IR("""
280 func @"test14" (%0 : BoxingConversionTest)void -> {
281 %1 : java.util.function.Supplier<java.lang.Integer> = lambda ()java.lang.Integer -> {
282 %2 : int = constant @"1";
283 %3 : java.lang.Integer = invoke %2 @"java.lang.Integer::valueOf(int)java.lang.Integer";
284 return %3;
285 };
286 %4 : Var<java.util.function.Supplier<java.lang.Integer>> = var %1 @"s";
287 return;
288 };
289 """)
290 void test14() {
291 Supplier<Integer> s = () -> 1;
292 }
293
294 @CodeReflection
295 @IR("""
296 func @"test15" (%0 : BoxingConversionTest, %1 : int, %2 : java.lang.Integer)void -> {
297 %3 : Var<int> = var %1 @"i";
298 %4 : Var<java.lang.Integer> = var %2 @"I";
299 %5 : int = var.load %3;
300 %6 : int = java.switch.expression %5
301 ^constantCaseLabel(%7 : int)boolean -> {
302 %8 : int = constant @"1";
303 %9 : boolean = eq %7 %8;
304 yield %9;
305 }
306 ()int -> {
307 %10 : java.lang.Integer = var.load %4;
308 %11 : int = invoke %10 @"java.lang.Integer::intValue()int";
309 yield %11;
310 }
311 ^defaultCaseLabel()void -> {
312 yield;
313 }
314 ()int -> {
315 %12 : int = constant @"0";
316 yield %12;
317 };
318 %13 : Var<int> = var %6 @"x";
319 return;
320 };
321 """)
322 void test15(int i, Integer I) {
323 int x = switch (i) {
324 case 1 -> I;
325 default -> 0;
326 };
327 }
328
329 @CodeReflection
330 @IR("""
331 func @"test16" (%0 : BoxingConversionTest, %1 : int, %2 : java.lang.Integer)void -> {
332 %3 : Var<int> = var %1 @"i";
333 %4 : Var<java.lang.Integer> = var %2 @"I";
334 %5 : int = var.load %3;
335 %6 : int = java.switch.expression %5
336 ^constantCaseLabel(%7 : int)boolean -> {
337 %8 : int = constant @"1";
338 %9 : boolean = eq %7 %8;
339 yield %9;
340 }
341 ()int -> {
342 %10 : int = constant @"1";
343 yield %10;
344 }
345 ^defaultCaseLabel()void -> {
346 yield;
347 }
348 ()int -> {
349 %11 : java.lang.Integer = var.load %4;
350 %12 : int = invoke %11 @"java.lang.Integer::intValue()int";
351 yield %12;
352 };
353 %13 : Var<int> = var %6 @"x";
354 return;
355 };
356 """)
357 void test16(int i, Integer I) {
358 int x = switch (i) {
359 case 1 -> 1;
360 default -> I;
361 };
362 }
363
364 @CodeReflection
365 @IR("""
366 func @"test17" (%0 : BoxingConversionTest, %1 : int)void -> {
367 %2 : Var<int> = var %1 @"i";
368 %3 : int = var.load %2;
369 %4 : java.lang.Integer = java.switch.expression %3
370 ^constantCaseLabel(%5 : int)boolean -> {
371 %6 : int = constant @"1";
372 %7 : boolean = eq %5 %6;
373 yield %7;
374 }
375 ()java.lang.Integer -> {
376 %8 : int = constant @"1";
377 %9 : java.lang.Integer = invoke %8 @"java.lang.Integer::valueOf(int)java.lang.Integer";
378 yield %9;
379 }
380 ^defaultCaseLabel()void -> {
381 yield;
382 }
383 ()java.lang.Integer -> {
384 %10 : int = constant @"0";
385 %11 : java.lang.Integer = invoke %10 @"java.lang.Integer::valueOf(int)java.lang.Integer";
386 yield %11;
387 };
388 %12 : Var<java.lang.Integer> = var %4 @"x";
389 return;
390 };
391 """)
392 void test17(int i) {
393 Integer x = switch (i) {
394 case 1 -> 1;
395 default -> 0;
396 };
397 }
398
399 @CodeReflection
400 @IR("""
401 func @"test18" (%0 : BoxingConversionTest, %1 : int, %2 : java.lang.Integer)void -> {
402 %3 : Var<int> = var %1 @"i";
403 %4 : Var<java.lang.Integer> = var %2 @"I";
404 %5 : int = var.load %3;
405 %6 : int = java.switch.expression %5
406 ^constantCaseLabel(%7 : int)boolean -> {
407 %8 : int = constant @"1";
408 %9 : boolean = eq %7 %8;
409 yield %9;
410 }
411 ()int -> {
412 %10 : java.lang.Integer = var.load %4;
413 %11 : int = invoke %10 @"java.lang.Integer::intValue()int";
414 java.yield %11;
415 }
416 ^defaultCaseLabel()void -> {
417 yield;
418 }
419 ()int -> {
420 %12 : int = constant @"0";
421 java.yield %12;
422 };
423 %13 : Var<int> = var %6 @"x";
424 return;
425 };
426 """)
427 void test18(int i, Integer I) {
428 int x = switch (i) {
429 case 1 -> { yield I; }
430 default -> { yield 0; }
431 };
432 }
433
434 @CodeReflection
435 @IR("""
436 func @"test19" (%0 : BoxingConversionTest, %1 : int, %2 : java.lang.Integer)void -> {
437 %3 : Var<int> = var %1 @"i";
438 %4 : Var<java.lang.Integer> = var %2 @"I";
439 %5 : int = var.load %3;
440 %6 : int = java.switch.expression %5
441 ^constantCaseLabel(%7 : int)boolean -> {
442 %8 : int = constant @"1";
443 %9 : boolean = eq %7 %8;
444 yield %9;
445 }
446 ()int -> {
447 %10 : int = constant @"1";
448 java.yield %10;
449 }
450 ^defaultCaseLabel()void -> {
451 yield;
452 }
453 ()int -> {
454 %11 : java.lang.Integer = var.load %4;
455 %12 : int = invoke %11 @"java.lang.Integer::intValue()int";
456 java.yield %12;
457 };
458 %13 : Var<int> = var %6 @"x";
459 return;
460 };
461 """)
462 void test19(int i, Integer I) {
463 int x = switch (i) {
464 case 1 -> { yield 1; }
465 default -> { yield I; }
466 };
467 }
468
469 @CodeReflection
470 @IR("""
471 func @"test20" (%0 : BoxingConversionTest, %1 : int)void -> {
472 %2 : Var<int> = var %1 @"i";
473 %3 : int = var.load %2;
474 %4 : java.lang.Integer = java.switch.expression %3
475 ^constantCaseLabel(%5 : int)boolean -> {
476 %6 : int = constant @"1";
477 %7 : boolean = eq %5 %6;
478 yield %7;
479 }
480 ()java.lang.Integer -> {
481 %8 : int = constant @"1";
482 %9 : java.lang.Integer = invoke %8 @"java.lang.Integer::valueOf(int)java.lang.Integer";
483 java.yield %9;
484 }
485 ^defaultCaseLabel()void -> {
486 yield;
487 }
488 ()java.lang.Integer -> {
489 %10 : int = constant @"0";
490 %11 : java.lang.Integer = invoke %10 @"java.lang.Integer::valueOf(int)java.lang.Integer";
491 java.yield %11;
492 };
493 %12 : Var<java.lang.Integer> = var %4 @"x";
494 return;
495 };
496 """)
497 void test20(int i) {
498 Integer x = switch (i) {
499 case 1 -> { yield 1; }
500 default -> { yield 0; }
501 };
502 }
503
504 @CodeReflection
505 @IR("""
506 func @"test21" (%0 : BoxingConversionTest, %1 : int, %2 : java.lang.Integer)void -> {
507 %3 : Var<int> = var %1 @"i";
508 %4 : Var<java.lang.Integer> = var %2 @"I";
509 %5 : int = var.load %3;
510 %6 : java.lang.Integer = var.load %4;
511 %7 : int = invoke %6 @"java.lang.Integer::intValue()int";
512 %8 : int = add %5 %7;
513 %9 : Var<int> = var %8 @"l";
514 return;
515 };
516 """)
517 void test21(int i, Integer I) {
518 int l = i + I;
519 }
520
521 void m(Integer I) { }
522
523 @CodeReflection
524 @IR("""
525 func @"test22" (%0 : BoxingConversionTest, %1 : int)void -> {
526 %2 : Var<int> = var %1 @"i";
527 %3 : int = var.load %2;
528 %4 : java.lang.Integer = invoke %3 @"java.lang.Integer::valueOf(int)java.lang.Integer";
529 invoke %0 %4 @"BoxingConversionTest::m(java.lang.Integer)void";
530 return;
531 };
532 """)
533 void test22(int i) {
534 m(i);
535 }
536
537 void m(int i1, int i2, Integer... I) { }
538
539 @CodeReflection
540 @IR("""
541 func @"test23" (%0 : BoxingConversionTest, %1 : int)void -> {
542 %2 : Var<int> = var %1 @"i";
543 %3 : int = var.load %2;
544 %4 : int = var.load %2;
545 invoke %0 %3 %4 @"BoxingConversionTest::m(int, int, java.lang.Integer[])void";
546 return;
547 };
548 """)
549 void test23(int i) {
550 m(i, i);
551 }
552
553 @CodeReflection
554 @IR("""
555 func @"test24" (%0 : BoxingConversionTest, %1 : int)void -> {
556 %2 : Var<int> = var %1 @"i";
557 %3 : int = var.load %2;
558 %4 : int = var.load %2;
559 %5 : int = var.load %2;
560 %6 : java.lang.Integer = invoke %5 @"java.lang.Integer::valueOf(int)java.lang.Integer";
561 invoke %0 %3 %4 %6 @"BoxingConversionTest::m(int, int, java.lang.Integer[])void";
562 return;
563 };
564 """)
565 void test24(int i) {
566 m(i, i, i);
567 }
568
569 @CodeReflection
570 @IR("""
571 func @"test25" (%0 : BoxingConversionTest, %1 : int)void -> {
572 %2 : Var<int> = var %1 @"i";
573 %3 : int = var.load %2;
574 %4 : int = var.load %2;
575 %5 : int = var.load %2;
576 %6 : java.lang.Integer = invoke %5 @"java.lang.Integer::valueOf(int)java.lang.Integer";
577 %7 : int = var.load %2;
578 %8 : java.lang.Integer = invoke %7 @"java.lang.Integer::valueOf(int)java.lang.Integer";
579 invoke %0 %3 %4 %6 %8 @"BoxingConversionTest::m(int, int, java.lang.Integer[])void";
580 return;
581 };
582 """)
583 void test25(int i) {
584 m(i, i, i, i);
585 }
586
587 static class Box2 {
588 Box2(Integer I) { }
589 Box2(int i1, int i2, Integer... Is) { }
590 }
591
592 @CodeReflection
593 @IR("""
594 func @"test26" (%0 : BoxingConversionTest, %1 : int)void -> {
595 %2 : Var<int> = var %1 @"i";
596 %3 : int = var.load %2;
597 %4 : java.lang.Integer = invoke %3 @"java.lang.Integer::valueOf(int)java.lang.Integer";
598 %5 : BoxingConversionTest$Box2 = new %4 @"func<BoxingConversionTest$Box2, java.lang.Integer>";
599 return;
600 };
601 """)
602 void test26(int i) {
603 new Box2(i);
604 }
605
606 @CodeReflection
607 @IR("""
608 func @"test27" (%0 : BoxingConversionTest, %1 : int)void -> {
609 %2 : Var<int> = var %1 @"i";
610 %3 : int = var.load %2;
611 %4 : int = var.load %2;
612 %5 : BoxingConversionTest$Box2 = new %3 %4 @"func<BoxingConversionTest$Box2, int, int, java.lang.Integer[]>";
613 return;
614 };
615 """)
616 void test27(int i) {
617 new Box2(i, i);
618 }
619
620 @CodeReflection
621 @IR("""
622 func @"test28" (%0 : BoxingConversionTest, %1 : int)void -> {
623 %2 : Var<int> = var %1 @"i";
624 %3 : int = var.load %2;
625 %4 : int = var.load %2;
626 %5 : int = var.load %2;
627 %6 : java.lang.Integer = invoke %5 @"java.lang.Integer::valueOf(int)java.lang.Integer";
628 %7 : BoxingConversionTest$Box2 = new %3 %4 %6 @"func<BoxingConversionTest$Box2, int, int, java.lang.Integer[]>";
629 return;
630 };
631 """)
632 void test28(int i) {
633 new Box2(i, i, i);
634 }
635
636 @CodeReflection
637 @IR("""
638 func @"test29" (%0 : BoxingConversionTest, %1 : int)void -> {
639 %2 : Var<int> = var %1 @"i";
640 %3 : int = var.load %2;
641 %4 : int = var.load %2;
642 %5 : int = var.load %2;
643 %6 : java.lang.Integer = invoke %5 @"java.lang.Integer::valueOf(int)java.lang.Integer";
644 %7 : int = var.load %2;
645 %8 : java.lang.Integer = invoke %7 @"java.lang.Integer::valueOf(int)java.lang.Integer";
646 %9 : BoxingConversionTest$Box2 = new %3 %4 %6 %8 @"func<BoxingConversionTest$Box2, int, int, java.lang.Integer[]>";
647 return;
648 };
649 """)
650 void test29(int i) {
651 new Box2(i, i, i, i);
652 }
653
654 @CodeReflection
655 @IR("""
656 func @"test30" (%0 : java.lang.Integer)void -> {
657 %1 : Var<java.lang.Integer> = var %0 @"i";
658 %2 : java.lang.Integer = var.load %1;
659 %3 : int = invoke %2 @"java.lang.Integer::intValue()int";
660 %4 : int = neg %3;
661 %5 : Var<int> = var %4 @"j";
662 return;
663 };
664 """)
665 static void test30(Integer i) {
666 int j = -i;
667 }
668
669 @CodeReflection
670 @IR("""
671 func @"test31" (%0 : int)void -> {
672 %1 : Var<int> = var %0 @"i";
673 %2 : int = var.load %1;
674 %3 : int = neg %2;
675 %4 : java.lang.Integer = invoke %3 @"java.lang.Integer::valueOf(int)java.lang.Integer";
676 %5 : Var<java.lang.Integer> = var %4 @"j";
677 return;
678 };
679 """)
680 static void test31(int i) {
681 Integer j = -i;
682 }
683
684 @CodeReflection
685 @IR("""
686 func @"test32" (%0 : boolean)void -> {
687 %1 : Var<boolean> = var %0 @"i";
688 %2 : boolean = var.load %1;
689 %3 : boolean = not %2;
690 %4 : java.lang.Boolean = invoke %3 @"java.lang.Boolean::valueOf(boolean)java.lang.Boolean";
691 %5 : Var<java.lang.Boolean> = var %4 @"j";
692 return;
693 };
694 """)
695 static void test32(boolean i) {
696 Boolean j = !i;
697 }
698
699 @CodeReflection
700 @IR("""
701 func @"test33" (%0 : java.lang.Boolean)void -> {
702 %1 : Var<java.lang.Boolean> = var %0 @"i";
703 %2 : java.lang.Boolean = var.load %1;
704 %3 : boolean = invoke %2 @"java.lang.Boolean::booleanValue()boolean";
705 %4 : boolean = not %3;
706 %5 : Var<boolean> = var %4 @"j";
707 return;
708 };
709 """)
710 static void test33(Boolean i) {
711 boolean j = !i;
712 }
713 }