1 /*
2 * Copyright (c) 2014, 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 * @library /testlibrary/selection_resolution/
27 * @run main Template
28 */
29
30 import java.util.function.BiConsumer;
31 import java.util.function.Consumer;
32 import java.util.Arrays;
33 import java.util.Collection;
34 import java.util.Collections;
35 import java.util.EnumSet;
36 import java.util.HashSet;
37 import java.util.LinkedList;
38
39 /**
40 * Templates are sets of transformations that are applied to a
41 * SelectionResolutionTestCase.Builder as part of building up a test
42 * case. Templates should contain a collection of different
43 * transforms, all of which represent an "interesting" case in a
44 * general category of cases.
45 *
46 */
47 public class Template {
48
49 public enum Kind { CLASS, INTERFACE; }
50
51 public final Collection<Consumer<SelectionResolutionTestCase.Builder>> cases;
52 public final String name;
53
54 /**
55 * Create a template from a collection of lambdas that modify a Builder.
56 *
57 * @param name The name of the template.
58 * @param cases The cases in the template.
59 */
60 public Template(final String name,
61 final Collection<Consumer<SelectionResolutionTestCase.Builder>> cases) {
62 this.cases = cases;
63 this.name = name;
64 }
65
66 /**
67 * Build a template out of a set of lambdas that modify a Builder.
68 *
69 * @param name The name of the template.
70 * @param cases The cases in the template.
71 */
72 public Template(final String name,
73 final Consumer<SelectionResolutionTestCase.Builder>... cases) {
74 this(name, Arrays.asList(cases));
75 }
76
77 /**
78 * Build a template out of a set of lambdas that modify a Builder.
79 * Also include all cases from another template.
80 *
81 * @param name The name of the template.
82 * @param include Include all cases from this template.
83 * @param cases The cases in the template.
84 */
85 public Template(final String name,
86 final Template include,
87 final Consumer<SelectionResolutionTestCase.Builder>... cases) {
88 this(name, new LinkedList(include.cases));
89 this.cases.addAll(Arrays.asList(cases));
90 }
91
92 /**
93 * Build a template out of a set of lambdas that modify a Builder.
94 * Also include all cases from another template.
95 *
96 * @param name The name of the template.
97 * @param include Include all cases from this template.
98 * @param cases The cases in the template.
99 */
100 public Template(final String name,
101 final Template... others) {
102 this(name, new LinkedList());
103
104 for(final Template template : others) {
105 cases.addAll(template.cases);
106 }
107 }
108
109 /**
110 * Run all cases in the template. This will run each action in
111 * the template and then call the next action on a separate copy
112 * of the builder parameter.
113 *
114 * @param The next action to perform of the Builder.
115 * @param The Builder to modify.
116 */
117 public void runCases(final Consumer<SelectionResolutionTestCase.Builder> next,
118 final SelectionResolutionTestCase.Builder builder) {
119 for(final Consumer<SelectionResolutionTestCase.Builder> thiscase : cases) {
120 final SelectionResolutionTestCase.Builder localbuilder = builder.copy();
121 thiscase.accept(localbuilder);
122 next.accept(localbuilder);
123 }
124 }
125
126 public void printCases(final SelectionResolutionTestCase.Builder builder) {
127 int i = 1;
128 System.err.println("Template " + name + ":\n");
129 for(final Consumer<SelectionResolutionTestCase.Builder> thiscase : cases) {
130 final SelectionResolutionTestCase.Builder localbuilder = builder.copy();
131 thiscase.accept(localbuilder);
132 System.err.println("Case " + i++);
133 System.err.println(localbuilder);
134 }
135 }
136
137 /* Create an empty class in the given package */
138 public static final ClassData emptyClass(final ClassData.Package pck) {
139 return new ClassData(pck, null);
140 }
141
142 /* These are functions that are used to build callsite templates */
143 public static void callsiteIsMethodref(final SelectionResolutionTestCase.Builder builder) {
144 builder.callsite = builder.methodref;
145 }
146
147 public static void callsiteSubclassMethodref(final SelectionResolutionTestCase.Builder builder) {
148 final int callsite =
149 builder.addClass(Template.emptyClass(ClassData.Package.SAME));
150 builder.hier.addInherit(callsite, builder.methodref);
151 builder.callsite = callsite;
152 }
153
154 public static void callsiteUnrelatedMethodref(final SelectionResolutionTestCase.Builder builder) {
155 final int callsite =
156 builder.addClass(Template.emptyClass(ClassData.Package.SAME));
157 builder.callsite = callsite;
158 }
159
160 public static void methodrefIsExpected(final SelectionResolutionTestCase.Builder builder) {
161 builder.methodref = builder.expected;
162 }
163
164 public static final Template MethodrefEqualsExpected =
165 new Template("MethodrefEqualsExpected",
166 Template::methodrefIsExpected);
167
168 /*****************************
169 * Set Invoke Template *
170 *****************************/
171
172 public static final Template SetInvoke(final SelectionResolutionTestCase.InvokeInstruction invoke) {
173 return new Template("SetInvoke(" + invoke + ")",
174 Collections.singleton((builder) -> {
175 builder.invoke = invoke;
176 }));
177 }
178
179 /*****************************
180 * Result Combo Template *
181 *****************************/
182 public static Template ResultCombo(final EnumSet<Kind> kinds,
183 final EnumSet<MethodData.Access> accesses,
184 final EnumSet<MethodData.Context> contexts,
185 final EnumSet<ClassData.Package> packages) {
186 final LinkedList<Consumer<SelectionResolutionTestCase.Builder>> cases =
187 new LinkedList<>();
188
189 for (final Kind kind : kinds) {
190 for (final MethodData.Access acc : accesses) {
191 for (final MethodData.Context ctx : contexts) {
192 if (!(acc == MethodData.Access.PRIVATE &&
193 ctx == MethodData.Context.ABSTRACT)) {
194 for (final ClassData.Package pck : packages) {
195 cases.add((builder) -> {
196 final MethodData meth = new MethodData(acc, ctx);
197 final ClassData cls = new ClassData(pck, meth);
198 switch(kind) {
199 case CLASS:
200 builder.expected = builder.addClass(cls);
201 break;
202 case INTERFACE:
203 builder.expected = builder.addInterface(cls);
204 break;
205 }
206 });
207 }
208 }
209 }
210 }
211 }
212
213 return new Template("ResultCombo", cases);
214 }
215
216 public static Template ResolutionOverride(final EnumSet<Kind> kinds,
217 final EnumSet<MethodData.Access> accesses,
218 final EnumSet<MethodData.Context> contexts,
219 final EnumSet<ClassData.Package> packages) {
220 final LinkedList<Consumer<SelectionResolutionTestCase.Builder>> cases =
221 new LinkedList<>();
222
223 for (final Kind kind : kinds) {
224 for (final MethodData.Access acc : accesses) {
225 for (final MethodData.Context ctx : contexts) {
226 if (!(acc == MethodData.Access.PRIVATE &&
227 ctx == MethodData.Context.ABSTRACT)) {
228 for (final ClassData.Package pck : packages) {
229 cases.add((builder) -> {
230 final MethodData meth = new MethodData(acc, ctx);
231 final ClassData cls = new ClassData(pck, meth);
232 int override = -1;
233 switch(kind) {
234 case CLASS:
235 override = builder.addClass(cls);
236 break;
237 case INTERFACE:
238 override = builder.addInterface(cls);
239 break;
240 }
241 builder.hier.addInherit(override, builder.expected);
242 });
243 }
244 }
245 }
246 }
247 }
248
249 return new Template("ResultCombo", cases);
250 }
251
252 /******************************
253 * Resolution Templates *
254 ******************************/
255
256 private static MethodData getMethodData(final MethodData.Access acc,
257 final MethodData.Context ctx) {
258 if (!(acc == MethodData.Access.PUBLIC ||
259 acc == MethodData.Access.PLACEHOLDER) &&
260 ctx != MethodData.Context.STATIC) {
261 return null;
262 } else {
263 return new MethodData(MethodData.Access.PUBLIC, ctx);
264 }
265 }
266
267 public static final Template MethodrefNotEqualsExpectedClass =
268 new Template("MethodrefNotEqualsExpectedClass",
269 /* Case 1: Inherit from super.
270 *
271 * C2[](res)
272 * C1[C2]() = mref
273 */
274 (final SelectionResolutionTestCase.Builder builder) -> {
275 final int C2 = builder.expected;
276 final int C1 = builder.addClass(emptyClass(ClassData.Package.SAME));
277 builder.hier.addInherit(C1, C2);
278 builder.methodref = C1;
279 },
280 /* Case 2: Inherit from super.
281 *
282 * C2[](res), I[](def)
283 * C1[C2,I]() = mref
284 */
285 (final SelectionResolutionTestCase.Builder builder) -> {
286 final ClassData.Package pck =
287 builder.classdata.get(builder.expected).packageId;
288 final MethodData.Context ctx =
289 builder.classdata.get(builder.expected).methoddata.context;
290 final MethodData.Access acc =
291 builder.classdata.get(builder.expected).methoddata.access;
292 final MethodData mdata = getMethodData(acc, ctx);
293 final ClassData withDef = new ClassData(pck, mdata);
294 final int C2 = builder.expected;
295 final int C1 = builder.addClass(emptyClass(ClassData.Package.SAME));
296 final int I = builder.addInterface(withDef);
297 builder.hier.addInherit(C1, C2);
298 builder.hier.addInherit(C1, I);
299 builder.methodref = C1;
300 },
301 /* Case 3: Inherit from super's super.
302 *
303 * C3[](res)
304 * C2[](), I[](def)
305 * C1[C2,I]() = mref
306 */
307 (final SelectionResolutionTestCase.Builder builder) -> {
308 final ClassData.Package pck =
309 builder.classdata.get(builder.expected).packageId;
310 final MethodData.Context ctx =
311 builder.classdata.get(builder.expected).methoddata.context;
312 final MethodData.Access acc =
313 builder.classdata.get(builder.expected).methoddata.access;
314 final MethodData mdata = getMethodData(acc, ctx);
315 final ClassData withDef = new ClassData(pck, mdata);
316 final int C3 = builder.expected;
317 final int C2 = builder.addClass(emptyClass(pck));
318 final int C1 = builder.addClass(emptyClass(ClassData.Package.SAME));
319 final int I = builder.addInterface(withDef);
320 builder.hier.addInherit(C2, C3);
321 builder.hier.addInherit(C1, C2);
322 builder.hier.addInherit(C1, I);
323 builder.methodref = C1;
324 });
325
326 public static final Template IfaceMethodrefNotEqualsExpected =
327 new Template("IfaceMethodrefNotEqualsExpected",
328 /* Case 1: Inherit from super.
329 *
330 * I2[](res)
331 * I1[I2]() = mref
332 */
333 (final SelectionResolutionTestCase.Builder builder) -> {
334 final ClassData.Package pck =
335 builder.classdata.get(builder.expected).packageId;
336 final int I2 = builder.expected;
337 final int I1 = builder.addInterface(emptyClass(pck));
338 builder.hier.addInherit(I1, I2);
339 builder.methodref = I1;
340 },
341 /* Case 2: Inherit from super, skip private.
342 *
343 * I2[](res)
344 * I2[I3](priv)
345 * I1[I2]() = mref
346 */
347 (final SelectionResolutionTestCase.Builder builder) -> {
348 final ClassData.Package pck =
349 builder.classdata.get(builder.expected).packageId;
350 final MethodData meth =
351 new MethodData(MethodData.Access.PRIVATE,
352 MethodData.Context.INSTANCE);
353 final ClassData withPrivDef = new ClassData(pck, meth);
354 final int I3 = builder.expected;
355 final int I2 = builder.addInterface(withPrivDef);
356 final int I1 = builder.addInterface(emptyClass(pck));
357 builder.hier.addInherit(I1, I2);
358 builder.hier.addInherit(I2, I3);
359 builder.methodref = I1;
360 },
361 /* Case 3: Inherit from super, skip static.
362 *
363 * I2[](res)
364 * I2[I3](stat)
365 * I1[I2]() = mref
366 */
367 (final SelectionResolutionTestCase.Builder builder) -> {
368 final ClassData.Package pck =
369 builder.classdata.get(builder.expected).packageId;
370 final MethodData meth =
371 new MethodData(MethodData.Access.PUBLIC,
372 MethodData.Context.STATIC);
373 final ClassData withStatDef = new ClassData(pck, meth);
374 final int I3 = builder.expected;
375 final int I2 = builder.addInterface(withStatDef);
376 final int I1 = builder.addInterface(emptyClass(pck));
377 builder.hier.addInherit(I1, I2);
378 builder.hier.addInherit(I2, I3);
379 builder.methodref = I1;
380 },
381 /* Case 4: Maximally-specific.
382 *
383 * I3[](def)
384 * I2[I3](res)
385 * I1[I2]() = mref
386 */
387 (final SelectionResolutionTestCase.Builder builder) -> {
388 final ClassData.Package pck =
389 builder.classdata.get(builder.expected).packageId;
390 final MethodData.Context ctx =
391 builder.classdata.get(builder.expected).methoddata.context;
392 final MethodData.Access acc =
393 builder.classdata.get(builder.expected).methoddata.access;
394 final MethodData mdata = getMethodData(acc, ctx);
395 final ClassData withDef = new ClassData(pck, mdata);
396 final int I3 = builder.addInterface(withDef);
397 final int I2 = builder.expected;
398 final int I1 = builder.addInterface(emptyClass(pck));
399 builder.hier.addInherit(I1, I2);
400 builder.hier.addInherit(I2, I3);
401 builder.methodref = I1;
402 },
403 /* Case 5: Diamond, expected at top.
404 *
405 * I4[](res)
406 * I2[I4](), I3[I4]()
407 * I1[I2,I3]() = mref
408 */
409 (final SelectionResolutionTestCase.Builder builder) -> {
410 final ClassData.Package pck =
411 builder.classdata.get(builder.expected).packageId;
412 final int I4 = builder.expected;
413 final int I3 = builder.addInterface(emptyClass(pck));
414 final int I2 = builder.addInterface(emptyClass(pck));
415 final int I1 = builder.addInterface(emptyClass(pck));
416 builder.hier.addInherit(I1, I2);
417 builder.hier.addInherit(I1, I3);
418 builder.hier.addInherit(I2, I4);
419 builder.hier.addInherit(I3, I4);
420 builder.methodref = I1;
421 },
422 /* Case 6: Diamond, skip private.
423 *
424 * I4[](res)
425 * I2[I4](priv), I3[I4]()
426 * I1[I2,I3]() = mref
427 */
428 (final SelectionResolutionTestCase.Builder builder) -> {
429 final ClassData.Package pck =
430 builder.classdata.get(builder.expected).packageId;
431 final MethodData.Context ctx =
432 builder.classdata.get(builder.expected).methoddata.context;
433 final MethodData.Access acc =
434 builder.classdata.get(builder.expected).methoddata.access;
435 final MethodData mdata = getMethodData(acc, ctx);
436 final MethodData meth =
437 new MethodData(MethodData.Access.PRIVATE,
438 MethodData.Context.INSTANCE);
439 final ClassData withPrivDef = new ClassData(pck, meth);
440 final int I4 = builder.expected;
441 final int I3 = builder.addInterface(emptyClass(pck));
442 final int I2 = builder.addInterface(withPrivDef);
443 final int I1 = builder.addInterface(emptyClass(pck));
444 builder.hier.addInherit(I1, I2);
445 builder.hier.addInherit(I1, I3);
446 builder.hier.addInherit(I2, I4);
447 builder.hier.addInherit(I3, I4);
448 builder.methodref = I1;
449 },
450 /* Case 7: Diamond, skip static.
451 *
452 * I4[](res)
453 * I2[I4](stat), I3[I4]()
454 * I1[I2,I3]() = mref
455 */
456 (final SelectionResolutionTestCase.Builder builder) -> {
457 final ClassData.Package pck =
458 builder.classdata.get(builder.expected).packageId;
459 final MethodData.Context ctx =
460 builder.classdata.get(builder.expected).methoddata.context;
461 final MethodData.Access acc =
462 builder.classdata.get(builder.expected).methoddata.access;
463 final MethodData mdata = getMethodData(acc, ctx);
464 final MethodData meth =
465 new MethodData(MethodData.Access.PUBLIC,
466 MethodData.Context.STATIC);
467 final ClassData withStatDef = new ClassData(pck, meth);
468 final int I4 = builder.expected;
469 final int I3 = builder.addInterface(emptyClass(pck));
470 final int I2 = builder.addInterface(withStatDef);
471 final int I1 = builder.addInterface(emptyClass(pck));
472 builder.hier.addInherit(I1, I2);
473 builder.hier.addInherit(I1, I3);
474 builder.hier.addInherit(I2, I4);
475 builder.hier.addInherit(I3, I4);
476 builder.methodref = I1;
477 },
478 /* Case 8: Diamond, maximally-specific.
479 *
480 * I4[](def)
481 * I2[I4](res), I3[I4]()
482 * I1[I2,I3]() = mref
483 */
484 (final SelectionResolutionTestCase.Builder builder) -> {
485 final ClassData.Package pck =
486 builder.classdata.get(builder.expected).packageId;
487 final MethodData.Context ctx =
488 builder.classdata.get(builder.expected).methoddata.context;
489 final MethodData.Access acc =
490 builder.classdata.get(builder.expected).methoddata.access;
491 final MethodData mdata = getMethodData(acc, ctx);
492 final ClassData withDef = new ClassData(pck, mdata);
493 final int I4 = builder.addInterface(withDef);
494 final int I3 = builder.addInterface(emptyClass(pck));
495 final int I2 = builder.expected;
496 final int I1 = builder.addInterface(emptyClass(pck));
497 builder.hier.addInherit(I1, I2);
498 builder.hier.addInherit(I1, I3);
499 builder.hier.addInherit(I2, I4);
500 builder.hier.addInherit(I3, I4);
501 builder.methodref = I1;
502 },
503 /* Case 9: Diamond, maximally-specific, skipping private.
504 *
505 * I4[](def)
506 * I2[I4](res), I3[I4](priv)
507 * I1[I2,I3]() = mref
508 */
509 (final SelectionResolutionTestCase.Builder builder) -> {
510 final ClassData.Package pck =
511 builder.classdata.get(builder.expected).packageId;
512 final MethodData.Context ctx =
513 builder.classdata.get(builder.expected).methoddata.context;
514 final MethodData.Access acc =
515 builder.classdata.get(builder.expected).methoddata.access;
516 final MethodData mdata = getMethodData(acc, ctx);
517 final ClassData withDef = new ClassData(pck, mdata);
518 final MethodData meth =
519 new MethodData(MethodData.Access.PRIVATE,
520 MethodData.Context.INSTANCE);
521 final ClassData withPrivDef = new ClassData(pck, meth);
522 final int I4 = builder.addInterface(withDef);
523 final int I3 = builder.addInterface(withPrivDef);
524 final int I2 = builder.expected;
525 final int I1 = builder.addInterface(emptyClass(pck));
526 builder.hier.addInherit(I1, I2);
527 builder.hier.addInherit(I1, I3);
528 builder.hier.addInherit(I2, I4);
529 builder.hier.addInherit(I3, I4);
530 builder.methodref = I1;
531 },
532 /* Case 10: Diamond, maximally-specific, skipping static.
533 *
534 * I4[](def)
535 * I2[I4](res), I3[I4](stat)
536 * I1[I2,I3]() = mref
537 */
538 (final SelectionResolutionTestCase.Builder builder) -> {
539 final ClassData.Package pck =
540 builder.classdata.get(builder.expected).packageId;
541 final MethodData.Context ctx =
542 builder.classdata.get(builder.expected).methoddata.context;
543 final MethodData.Access acc =
544 builder.classdata.get(builder.expected).methoddata.access;
545 final MethodData mdata = getMethodData(acc, ctx);
546 final ClassData withDef = new ClassData(pck, mdata);
547 final MethodData meth =
548 new MethodData(MethodData.Access.PUBLIC,
549 MethodData.Context.STATIC);
550 final ClassData withStatDef = new ClassData(pck, meth);
551 final int I4 = builder.addInterface(withDef);
552 final int I3 = builder.addInterface(withStatDef);
553 final int I2 = builder.expected;
554 final int I1 = builder.addInterface(emptyClass(pck));
555 builder.hier.addInherit(I1, I2);
556 builder.hier.addInherit(I1, I3);
557 builder.hier.addInherit(I2, I4);
558 builder.hier.addInherit(I3, I4);
559 builder.methodref = I1;
560 });
561
562 public static final Template MethodrefNotEqualsExpectedIface =
563 new Template("MethodrefNotEqualsExpectedIface",
564 /* Case 1: Inherit from superinterface.
565 *
566 * I[](res)
567 * C[I]() = mref
568 */
569 (final SelectionResolutionTestCase.Builder builder) -> {
570 final ClassData.Package pck =
571 builder.classdata.get(builder.expected).packageId;
572 final int I = builder.expected;
573 final int C = builder.addClass(emptyClass(pck));
574 builder.hier.addInherit(C, I);
575 builder.methodref = C;
576 },
577 /* Case 2: Diamond, expected at top.
578 *
579 * I3[](res)
580 * I1[I3](), I2[I3]()
581 * C[I1,I2]() = mref
582 */
583 (final SelectionResolutionTestCase.Builder builder) -> {
584 final ClassData.Package pck =
585 builder.classdata.get(builder.expected).packageId;
586 final int I3 = builder.expected;
587 final int I2 = builder.addInterface(emptyClass(pck));
588 final int I1 = builder.addInterface(emptyClass(pck));
589 final int C = builder.addClass(emptyClass(pck));
590 builder.hier.addInherit(C, I1);
591 builder.hier.addInherit(C, I2);
592 builder.hier.addInherit(I1, I3);
593 builder.hier.addInherit(I2, I3);
594 builder.methodref = C;
595 },
596 /* Case 3: Diamond, skipping private.
597 *
598 * I3[](def)
599 * I1[I3](priv), I2[I3]()
600 * C[I1,I2]() = mref
601 */
602 (final SelectionResolutionTestCase.Builder builder) -> {
603 final ClassData.Package pck =
604 builder.classdata.get(builder.expected).packageId;
605 final MethodData.Context ctx =
606 builder.classdata.get(builder.expected).methoddata.context;
607 final MethodData.Access acc =
608 builder.classdata.get(builder.expected).methoddata.access;
609 final MethodData meth =
610 new MethodData(MethodData.Access.PRIVATE,
611 MethodData.Context.INSTANCE);
612 final ClassData withPrivDef = new ClassData(pck, meth);
613 final int I3 = builder.expected;
614 final int I2 = builder.addInterface(emptyClass(pck));
615 final int I1 = builder.addInterface(withPrivDef);
616 final int C = builder.addClass(emptyClass(pck));
617 builder.hier.addInherit(C, I1);
618 builder.hier.addInherit(C, I2);
619 builder.hier.addInherit(I1, I3);
620 builder.hier.addInherit(I2, I3);
621 builder.methodref = C;
622 },
623 /* Case 4: Diamond, skipping static.
624 *
625 * I3[](def)
626 * I1[I3](stat), I2[I3]()
627 * C[I1,I2]() = mref
628 */
629 (final SelectionResolutionTestCase.Builder builder) -> {
630 final ClassData.Package pck =
631 builder.classdata.get(builder.expected).packageId;
632 final MethodData.Context ctx =
633 builder.classdata.get(builder.expected).methoddata.context;
634 final MethodData.Access acc =
635 builder.classdata.get(builder.expected).methoddata.access;
636 final MethodData meth =
637 new MethodData(MethodData.Access.PUBLIC,
638 MethodData.Context.STATIC);
639 final ClassData withStatDef = new ClassData(pck, meth);
640 final int I3 = builder.expected;
641 final int I2 = builder.addInterface(emptyClass(pck));
642 final int I1 = builder.addInterface(withStatDef);
643 final int C = builder.addClass(emptyClass(pck));
644 builder.hier.addInherit(C, I1);
645 builder.hier.addInherit(C, I2);
646 builder.hier.addInherit(I1, I3);
647 builder.hier.addInherit(I2, I3);
648 builder.methodref = C;
649 },
650 /* Case 5: Diamond, maximally-specific.
651 *
652 * I3[](def)
653 * I1[I3](res), I2[I3]()
654 * C[I1,I2]() = mref
655 */
656 (final SelectionResolutionTestCase.Builder builder) -> {
657 final ClassData.Package pck =
658 builder.classdata.get(builder.expected).packageId;
659 final MethodData.Context ctx =
660 builder.classdata.get(builder.expected).methoddata.context;
661 final MethodData.Access acc =
662 builder.classdata.get(builder.expected).methoddata.access;
663 final MethodData mdata = getMethodData(acc, ctx);
664 final ClassData withDef = new ClassData(pck, mdata);
665 final int I3 = builder.addInterface(withDef);
666 final int I2 = builder.addInterface(emptyClass(pck));
667 final int I1 = builder.expected;
668 final int C = builder.addClass(emptyClass(pck));
669 builder.hier.addInherit(C, I1);
670 builder.hier.addInherit(C, I2);
671 builder.hier.addInherit(I1, I3);
672 builder.hier.addInherit(I2, I3);
673 builder.methodref = C;
674 },
675 /* Case 6: Diamond, maximally-specific, skipping private.
676 *
677 * I3[](def)
678 * I1[I3](res), I2[I3](priv)
679 * C[I1,I2]() = mref
680 */
681 (final SelectionResolutionTestCase.Builder builder) -> {
682 final ClassData.Package pck =
683 builder.classdata.get(builder.expected).packageId;
684 final MethodData.Context ctx =
685 builder.classdata.get(builder.expected).methoddata.context;
686 final MethodData.Access acc =
687 builder.classdata.get(builder.expected).methoddata.access;
688 final MethodData mdata = getMethodData(acc, ctx);
689 final ClassData withDef = new ClassData(pck, mdata);
690 final MethodData meth =
691 new MethodData(MethodData.Access.PRIVATE,
692 MethodData.Context.INSTANCE);
693 final ClassData withPrivDef = new ClassData(pck, meth);
694 final int I3 = builder.addInterface(withDef);
695 final int I2 = builder.addInterface(withPrivDef);
696 final int I1 = builder.expected;
697 final int C = builder.addClass(emptyClass(pck));
698 builder.hier.addInherit(C, I1);
699 builder.hier.addInherit(C, I2);
700 builder.hier.addInherit(I1, I3);
701 builder.hier.addInherit(I2, I3);
702 builder.methodref = C;
703 },
704 /* Case 7: Diamond, maximally-specific, skipping static.
705 *
706 * I3[](def)
707 * I1[I3](res), I2[I3](stat)
708 * C[I1,I2]() = mref
709 */
710 (final SelectionResolutionTestCase.Builder builder) -> {
711 final ClassData.Package pck =
712 builder.classdata.get(builder.expected).packageId;
713 final MethodData.Context ctx =
714 builder.classdata.get(builder.expected).methoddata.context;
715 final MethodData.Access acc =
716 builder.classdata.get(builder.expected).methoddata.access;
717 final MethodData mdata = getMethodData(acc, ctx);
718 final ClassData withDef = new ClassData(pck, mdata);
719 final MethodData meth =
720 new MethodData(MethodData.Access.PUBLIC,
721 MethodData.Context.STATIC);
722 final ClassData withStatDef = new ClassData(pck, meth);
723 final int I3 = builder.addInterface(withDef);
724 final int I2 = builder.addInterface(withStatDef);
725 final int I1 = builder.expected;
726 final int C = builder.addClass(emptyClass(pck));
727 builder.hier.addInherit(C, I1);
728 builder.hier.addInherit(C, I2);
729 builder.hier.addInherit(I1, I3);
730 builder.hier.addInherit(I2, I3);
731 builder.methodref = C;
732 },
733 /* Case 8: Diamond, with superclass, expected at top.
734 *
735 * I2[](res)
736 * C2[I2](), I1[I2]()
737 * C1[I1,C2]() = mref
738 */
739 (final SelectionResolutionTestCase.Builder builder) -> {
740 final ClassData.Package pck =
741 builder.classdata.get(builder.expected).packageId;
742 final int I2 = builder.expected;
743 final int I1 = builder.addInterface(emptyClass(pck));
744 final int C2 = builder.addInterface(emptyClass(pck));
745 final int C1 = builder.addClass(emptyClass(pck));
746 builder.hier.addInherit(C1, I1);
747 builder.hier.addInherit(C1, C2);
748 builder.hier.addInherit(I1, I2);
749 builder.hier.addInherit(C2, I2);
750 builder.methodref = C1;
751 },
752 /* Case 9: Diamond with superclass, maximally-specific.
753 *
754 * I2[](def)
755 * C2[I2](), I1[I2](res),
756 * C1[I1,C2]() = mref
757 */
758 (final SelectionResolutionTestCase.Builder builder) -> {
759 final ClassData.Package pck =
760 builder.classdata.get(builder.expected).packageId;
761 final MethodData.Context ctx =
762 builder.classdata.get(builder.expected).methoddata.context;
763 final MethodData.Access acc =
764 builder.classdata.get(builder.expected).methoddata.access;
765 final MethodData mdata = getMethodData(acc, ctx);
766 final ClassData withDef = new ClassData(pck, mdata);
767 final int I2 = builder.addInterface(withDef);
768 final int C2 = builder.addClass(emptyClass(pck));
769 final int I1 = builder.expected;
770 final int C1 = builder.addClass(emptyClass(pck));
771 builder.hier.addInherit(C1, I1);
772 builder.hier.addInherit(C1, C2);
773 builder.hier.addInherit(I1, I2);
774 builder.hier.addInherit(C2, I2);
775 builder.methodref = C1;
776 },
777 /* Case 10: Inherit through superclass.
778 *
779 * I[](res)
780 * C2[I]()
781 * C1[C2]() = mref
782 */
783 (final SelectionResolutionTestCase.Builder builder) -> {
784 final ClassData.Package pck =
785 builder.classdata.get(builder.expected).packageId;
786 final int I = builder.expected;
787 final int C2 = builder.addInterface(emptyClass(pck));
788 final int C1 = builder.addClass(emptyClass(pck));
789 builder.hier.addInherit(C1, I);
790 builder.hier.addInherit(C1, C2);
791 builder.hier.addInherit(C2, I);
792 builder.methodref = C1;
793 },
794 /* Case 11: Diamond, inherit through superclass,
795 * expected at top.
796 *
797 * I3[](res)
798 * I1[I3](), I2[I3]()
799 * C2[I1,I2]()
800 * C1[C2]() = mref
801 */
802 (final SelectionResolutionTestCase.Builder builder) -> {
803 final ClassData.Package pck =
804 builder.classdata.get(builder.expected).packageId;
805 final int I3 = builder.expected;
806 final int I2 = builder.addInterface(emptyClass(pck));
807 final int I1 = builder.addInterface(emptyClass(pck));
808 final int C2 = builder.addClass(emptyClass(pck));
809 final int C1 = builder.addClass(emptyClass(pck));
810 builder.hier.addInherit(C2, I1);
811 builder.hier.addInherit(C2, I2);
812 builder.hier.addInherit(I1, I3);
813 builder.hier.addInherit(I2, I3);
814 builder.hier.addInherit(C1, C2);
815 builder.methodref = C1;
816 },
817 /* Case 12: Diamond through superclass, skip private.
818 *
819 * I3[](res)
820 * I1[I3](priv), I2[I3]()
821 * C2[I1,I2]()
822 * C1[C2]() = mref
823 */
824 (final SelectionResolutionTestCase.Builder builder) -> {
825 final ClassData.Package pck =
826 builder.classdata.get(builder.expected).packageId;
827 final MethodData.Context ctx =
828 builder.classdata.get(builder.expected).methoddata.context;
829 final MethodData.Access acc =
830 builder.classdata.get(builder.expected).methoddata.access;
831 final MethodData mdata = getMethodData(acc, ctx);
832 final ClassData withDef = new ClassData(pck, mdata);
833 final MethodData meth =
834 new MethodData(MethodData.Access.PRIVATE,
835 MethodData.Context.INSTANCE);
836 final ClassData withPrivDef = new ClassData(pck, meth);
837 final int I3 = builder.expected;
838 final int I2 = builder.addInterface(emptyClass(pck));
839 final int I1 = builder.addInterface(withPrivDef);
840 final int C2 = builder.addClass(emptyClass(pck));
841 final int C1 = builder.addClass(emptyClass(pck));
842 builder.hier.addInherit(C2, I1);
843 builder.hier.addInherit(C2, I2);
844 builder.hier.addInherit(I1, I3);
845 builder.hier.addInherit(I2, I3);
846 builder.hier.addInherit(C1, C2);
847 builder.methodref = C1;
848 },
849 /* Case 13: Diamond through superclass, skip static.
850 *
851 * I3[](def)
852 * I1[I3](stat), I2[I3]()
853 * C2[I1,I2]()
854 * C1[C2]() = mref
855 */
856 (final SelectionResolutionTestCase.Builder builder) -> {
857 final ClassData.Package pck =
858 builder.classdata.get(builder.expected).packageId;
859 final MethodData.Context ctx =
860 builder.classdata.get(builder.expected).methoddata.context;
861 final MethodData.Access acc =
862 builder.classdata.get(builder.expected).methoddata.access;
863 final MethodData mdata = getMethodData(acc, ctx);
864 final ClassData withDef = new ClassData(pck, mdata);
865 final MethodData meth =
866 new MethodData(MethodData.Access.PUBLIC,
867 MethodData.Context.STATIC);
868 final ClassData withStatDef = new ClassData(pck, meth);
869 final int I3 = builder.expected;
870 final int I2 = builder.addInterface(emptyClass(pck));
871 final int I1 = builder.addInterface(withStatDef);
872 final int C2 = builder.addClass(emptyClass(pck));
873 final int C1 = builder.addClass(emptyClass(pck));
874 builder.hier.addInherit(C2, I1);
875 builder.hier.addInherit(C2, I2);
876 builder.hier.addInherit(I1, I3);
877 builder.hier.addInherit(I2, I3);
878 builder.hier.addInherit(C1, C2);
879 builder.methodref = C1;
880 },
881 /* Case 14: Diamond through superclass, maximally-specific.
882 *
883 * I3[](def)
884 * I1[I3](res), I2[I3]()
885 * C2[I1,I2]()
886 * C1[C2]() = mref
887 */
888 (final SelectionResolutionTestCase.Builder builder) -> {
889 final ClassData.Package pck =
890 builder.classdata.get(builder.expected).packageId;
891 final MethodData.Context ctx =
892 builder.classdata.get(builder.expected).methoddata.context;
893 final MethodData.Access acc =
894 builder.classdata.get(builder.expected).methoddata.access;
895 final MethodData mdata = getMethodData(acc, ctx);
896 final ClassData withDef = new ClassData(pck, mdata);
897 final int I3 = builder.addInterface(withDef);
898 final int I2 = builder.addInterface(emptyClass(pck));
899 final int I1 = builder.expected;
900 final int C2 = builder.addClass(emptyClass(pck));
901 final int C1 = builder.addClass(emptyClass(pck));
902 builder.hier.addInherit(C2, I1);
903 builder.hier.addInherit(C2, I2);
904 builder.hier.addInherit(I1, I3);
905 builder.hier.addInherit(I2, I3);
906 builder.hier.addInherit(C1, C2);
907 builder.methodref = C1;
908 },
909 /* Case 15: Diamond through superclass,
910 * maximally-specific, skip private.
911 *
912 * I3[](def)
913 * I1[I3](res), I2[I3](priv)
914 * C2[I1,I2]()
915 * C1[C2]() = mref
916 */
917 (final SelectionResolutionTestCase.Builder builder) -> {
918 final ClassData.Package pck =
919 builder.classdata.get(builder.expected).packageId;
920 final MethodData.Context ctx =
921 builder.classdata.get(builder.expected).methoddata.context;
922 final MethodData.Access acc =
923 builder.classdata.get(builder.expected).methoddata.access;
924 final MethodData mdata = getMethodData(acc, ctx);
925 final ClassData withDef = new ClassData(pck, mdata);
926 final MethodData meth =
927 new MethodData(MethodData.Access.PRIVATE,
928 MethodData.Context.INSTANCE);
929 final ClassData withPrivDef = new ClassData(pck, meth);
930 final int I3 = builder.addInterface(withDef);
931 final int I2 = builder.addInterface(withPrivDef);
932 final int I1 = builder.expected;
933 final int C2 = builder.addClass(emptyClass(pck));
934 final int C1 = builder.addClass(emptyClass(pck));
935 builder.hier.addInherit(C2, I1);
936 builder.hier.addInherit(C2, I2);
937 builder.hier.addInherit(I1, I3);
938 builder.hier.addInherit(I2, I3);
939 builder.hier.addInherit(C1, C2);
940 builder.methodref = C1;
941 },
942 /* Case 16: Diamond through superclass,
943 * maximally-specific, skip static.
944 *
945 * I3[](pub)
946 * I1[I3](res), I2[I3](stat)
947 * C2[I1,I2]()
948 * C1[C2]() = mref
949 */
950 (final SelectionResolutionTestCase.Builder builder) -> {
951 final ClassData.Package pck =
952 builder.classdata.get(builder.expected).packageId;
953 final MethodData.Context ctx =
954 builder.classdata.get(builder.expected).methoddata.context;
955 final MethodData.Access acc =
956 builder.classdata.get(builder.expected).methoddata.access;
957 final MethodData mdata = getMethodData(acc, ctx);
958 final ClassData withDef = new ClassData(pck, mdata);
959 final MethodData meth =
960 new MethodData(MethodData.Access.PUBLIC,
961 MethodData.Context.STATIC);
962 final ClassData withStatDef = new ClassData(pck, meth);
963 final int I3 = builder.addInterface(withDef);
964 final int I2 = builder.addInterface(withStatDef);
965 final int I1 = builder.expected;
966 final int C2 = builder.addClass(emptyClass(pck));
967 final int C1 = builder.addClass(emptyClass(pck));
968 builder.hier.addInherit(C2, I1);
969 builder.hier.addInherit(C2, I2);
970 builder.hier.addInherit(I1, I3);
971 builder.hier.addInherit(I2, I3);
972 builder.hier.addInherit(C1, C2);
973 builder.methodref = C1;
974 },
975 /* Case 17: Diamond, with superclass, inherit through
976 * superclass, expected at top.
977 *
978 * I2[](res)
979 * C3[I2](), I1[I2]()
980 * C2[I1,C3]()
981 * C1[C2]() = mref
982 */
983 (final SelectionResolutionTestCase.Builder builder) -> {
984 final ClassData.Package pck =
985 builder.classdata.get(builder.expected).packageId;
986 final int I2 = builder.expected;
987 final int I1 = builder.addInterface(emptyClass(pck));
988 final int C3 = builder.addInterface(emptyClass(pck));
989 final int C2 = builder.addClass(emptyClass(pck));
990 final int C1 = builder.addClass(emptyClass(pck));
991 builder.hier.addInherit(C2, I1);
992 builder.hier.addInherit(C2, C3);
993 builder.hier.addInherit(I1, I2);
994 builder.hier.addInherit(C3, I2);
995 builder.hier.addInherit(C1, C2);
996 builder.methodref = C1;
997 },
998 /* Case 18: Diamond, with superclass, inherit through
999 * superclass, maximally-specific.
1000 *
1001 * I2[](def)
1002 * C3[I2](), I1[I2](res),
1003 * C2[I1,C3]()
1004 * C1[I1,C2]() = mref
1005 */
1006 (final SelectionResolutionTestCase.Builder builder) -> {
1007 final ClassData.Package pck =
1008 builder.classdata.get(builder.expected).packageId;
1009 final MethodData.Context ctx =
1010 builder.classdata.get(builder.expected).methoddata.context;
1011 final MethodData.Access acc =
1012 builder.classdata.get(builder.expected).methoddata.access;
1013 final MethodData mdata = getMethodData(acc, ctx);
1014 final ClassData withDef = new ClassData(pck, mdata);
1015 final int I2 = builder.addInterface(withDef);
1016 final int C3 = builder.addClass(emptyClass(pck));
1017 final int I1 = builder.expected;
1018 final int C2 = builder.addClass(emptyClass(pck));
1019 final int C1 = builder.addClass(emptyClass(pck));
1020 builder.hier.addInherit(C2, I1);
1021 builder.hier.addInherit(C2, C3);
1022 builder.hier.addInherit(I1, I2);
1023 builder.hier.addInherit(C3, I2);
1024 builder.hier.addInherit(C1, C2);
1025 builder.methodref = C1;
1026 });
1027
1028 public static final Template IfaceMethodrefAmbiguous =
1029 new Template("IfaceMethodrefAmbiguous",
1030 /* Ambiguous.
1031 *
1032 * I2[](def), I3[](def)
1033 * I1[I2]() = mref
1034 */
1035 (final SelectionResolutionTestCase.Builder builder) -> {
1036 final ClassData.Package pck =
1037 builder.classdata.get(builder.expected).packageId;
1038 final ClassData expected =
1039 builder.classdata.get(builder.expected);
1040 final int I3 = builder.addInterface(expected);
1041 final int I2 = builder.expected;
1042 final int I1 = builder.addInterface(emptyClass(pck));
1043 builder.hier.addInherit(I1, I2);
1044 builder.hier.addInherit(I1, I3);
1045 builder.methodref = I1;
1046 });
1047
1048 public static final Template MethodrefAmbiguous =
1049 new Template("MethodrefAmbiguous",
1050 /* Ambiguous.
1051 *
1052 * I1[](def), I2[](def)
1053 * C[I2]() = mref
1054 */
1055 (final SelectionResolutionTestCase.Builder builder) -> {
1056 final ClassData.Package pck =
1057 builder.classdata.get(builder.expected).packageId;
1058 final ClassData expected =
1059 builder.classdata.get(builder.expected);
1060 final int I1 = builder.addInterface(expected);
1061 final int I2 = builder.expected;
1062 final int C = builder.addClass(emptyClass(pck));
1063 builder.hier.addInherit(C, I2);
1064 builder.hier.addInherit(C, I1);
1065 builder.methodref = C;
1066 });
1067
1068 /******************************
1069 * Callsite Templates *
1070 ******************************/
1071
1072 public static final Template AllCallsiteCases =
1073 new Template("AllCallsiteCases",
1074 Template::callsiteIsMethodref,
1075 Template::callsiteSubclassMethodref,
1076 Template::callsiteUnrelatedMethodref);
1077
1078 public static final Template InvokespecialCallsiteCases =
1079 new Template("InvokespecialCallsiteCases",
1080 Template::callsiteIsMethodref,
1081 Template::callsiteSubclassMethodref);
1082
1083 public static final Template CallsiteEqualsMethodref =
1084 new Template("CallsiteEqualsMethodref",
1085 Template::callsiteIsMethodref);
1086
1087 public static final Template CallsiteSubclassMethodref =
1088 new Template("CallsiteSubclassMethodref",
1089 Template::callsiteSubclassMethodref);
1090
1091 public static final Template CallsiteUnrelatedToMethodref =
1092 new Template("CallsiteUnrelatedToMethodref",
1093 Template::callsiteUnrelatedMethodref);
1094
1095 public static final Template CallsiteNotEqualsMethodref =
1096 new Template("CallsiteNotEqualsMethodref",
1097 Template::callsiteSubclassMethodref,
1098 Template::callsiteUnrelatedMethodref);
1099
1100 /*********************************
1101 * AbstractMethodError Templates *
1102 *********************************/
1103
1104 public static final Template ReabstractExpectedIface =
1105 new Template("ReabstractExpectedIface",
1106 (builder) -> {},
1107 (final SelectionResolutionTestCase.Builder builder) -> {
1108 final ClassData expected =
1109 builder.classdata.get(builder.expected);
1110 final ClassData.Package pck = expected.packageId;
1111 final MethodData.Access acc =
1112 builder.classdata.get(builder.expected).methoddata.access;
1113 final MethodData mdata =
1114 getMethodData(acc, MethodData.Context.STATIC);
1115 final ClassData withDef = new ClassData(pck, mdata);
1116 final int C2 = builder.addInterface(withDef);
1117 final int C1 = builder.expected;
1118 builder.hier.addInherit(C1, C2);
1119 },
1120 (final SelectionResolutionTestCase.Builder builder) -> {
1121 final ClassData expected =
1122 builder.classdata.get(builder.expected);
1123 final ClassData.Package pck = expected.packageId;
1124 final MethodData.Access acc =
1125 builder.classdata.get(builder.expected).methoddata.access;
1126 final MethodData mdata =
1127 getMethodData(acc, MethodData.Context.INSTANCE);
1128 final ClassData withDef = new ClassData(pck, mdata);
1129 final int C2 = builder.addInterface(withDef);
1130 final int C1 = builder.expected;
1131 builder.hier.addInherit(C1, C2);
1132 });
1133
1134 public static final Template ReabstractExpectedClass =
1135 new Template("ReabstractExpectedClass",
1136 ReabstractExpectedIface,
1137 (final SelectionResolutionTestCase.Builder builder) -> {
1138 final ClassData expected =
1139 builder.classdata.get(builder.expected);
1140 final ClassData.Package pck = expected.packageId;
1141 final MethodData.Access acc =
1142 builder.classdata.get(builder.expected).methoddata.access;
1143 final MethodData mdata =
1144 getMethodData(acc, MethodData.Context.STATIC);
1145 final ClassData withDef = new ClassData(pck, mdata);
1146 final int C2 = builder.addClass(withDef);
1147 final int C1 = builder.expected;
1148 builder.hier.addInherit(C1, C2);
1149 },
1150 (final SelectionResolutionTestCase.Builder builder) -> {
1151 final ClassData expected =
1152 builder.classdata.get(builder.expected);
1153 final ClassData.Package pck = expected.packageId;
1154 final MethodData.Access acc =
1155 builder.classdata.get(builder.expected).methoddata.access;
1156 final MethodData mdata =
1157 getMethodData(acc, MethodData.Context.INSTANCE);
1158 final ClassData withDef = new ClassData(pck, mdata);
1159 final int C2 = builder.addClass(withDef);
1160 final int C1 = builder.expected;
1161 builder.hier.addInherit(C1, C2);
1162 });
1163
1164 public static final Template ReabstractMethodrefResolvedClass =
1165 new Template("ReabstractMethodrefResolvedClass",
1166 /* Case 1: Objectref overrides.
1167 *
1168 * C2[](*) = mref
1169 * C1[C2](res) = oref = expected
1170 */
1171 (final SelectionResolutionTestCase.Builder builder) -> {
1172 final ClassData.Package pck =
1173 builder.classdata.get(builder.methodref).packageId;
1174 final ClassData oldexpected =
1175 builder.classdata.get(builder.expected);
1176 final MethodData.Access acc =
1177 builder.classdata.get(builder.expected).methoddata.access;
1178 final ClassData withDef =
1179 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1180 final int C2 = builder.methodref;
1181 final int C1 = builder.addClass(withDef);
1182 builder.hier.addInherit(C1, C2);
1183 builder.objectref = C1;
1184 builder.expected = C1;
1185 },
1186 /* Case 2: Objectref's super overrides.
1187 *
1188 * C3[*](*) = mref
1189 * C2[C3](res) = expected
1190 * C1[C2]() = oref
1191 */
1192 (final SelectionResolutionTestCase.Builder builder) -> {
1193 final ClassData.Package pck =
1194 builder.classdata.get(builder.methodref).packageId;
1195 final ClassData oldexpected =
1196 builder.classdata.get(builder.expected);
1197 final MethodData.Access acc =
1198 builder.classdata.get(builder.expected).methoddata.access;
1199 final ClassData withDef =
1200 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1201 final int C3 = builder.methodref;
1202 final int C2 = builder.addClass(withDef);
1203 final int C1 = builder.addClass(emptyClass(pck));
1204 builder.hier.addInherit(C2, C3);
1205 builder.hier.addInherit(C1, C2);
1206 builder.objectref = C1;
1207 builder.expected = C2;
1208 },
1209 /* Case 3: Objectref's super overrides, skip private.
1210 *
1211 * C3[*](*) = mref
1212 * C2[C3](res) = expected
1213 * C1[C2](priv) = oref
1214 */
1215 (final SelectionResolutionTestCase.Builder builder) -> {
1216 final ClassData.Package pck =
1217 builder.classdata.get(builder.methodref).packageId;
1218 final ClassData oldexpected =
1219 builder.classdata.get(builder.expected);
1220 final MethodData.Access acc =
1221 builder.classdata.get(builder.expected).methoddata.access;
1222 final ClassData withDef =
1223 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1224 final MethodData meth =
1225 new MethodData(MethodData.Access.PRIVATE,
1226 MethodData.Context.INSTANCE);
1227 final ClassData withPrivDef = new ClassData(pck, meth);
1228 final int C3 = builder.methodref;
1229 final int C2 = builder.addClass(withDef);
1230 final int C1 = builder.addClass(withPrivDef);
1231 builder.hier.addInherit(C2, C3);
1232 builder.hier.addInherit(C1, C2);
1233 builder.objectref = C1;
1234 builder.expected = C2;
1235 },
1236 /* Case 4: Objectref's super overrides, skip static.
1237 *
1238 * C3[*](*) = mref
1239 * C2[C3](res) = expected
1240 * C1[C2](stat) = oref
1241 */
1242 (final SelectionResolutionTestCase.Builder builder) -> {
1243 final ClassData.Package pck =
1244 builder.classdata.get(builder.methodref).packageId;
1245 final ClassData oldexpected =
1246 builder.classdata.get(builder.expected);
1247 final MethodData.Access acc =
1248 builder.classdata.get(builder.expected).methoddata.access;
1249 final ClassData withDef =
1250 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1251 final MethodData meth =
1252 new MethodData(MethodData.Access.PUBLIC,
1253 MethodData.Context.STATIC);
1254 final ClassData withStatDef = new ClassData(pck, meth);
1255 final int C3 = builder.methodref;
1256 final int C2 = builder.addClass(withDef);
1257 final int C1 = builder.addClass(withStatDef);
1258 builder.hier.addInherit(C2, C3);
1259 builder.hier.addInherit(C1, C2);
1260 builder.objectref = C1;
1261 builder.expected = C2;
1262 });
1263
1264 public static final Template ReabstractMethodrefResolvedIface =
1265 new Template("ReabstractMethodrefResolvedIface",
1266 /* Case 1: Objectref overrides.
1267 *
1268 * C2[](*) = mref
1269 * C1[C2](res) = oref = expected
1270 */
1271 (final SelectionResolutionTestCase.Builder builder) -> {
1272 final ClassData.Package pck =
1273 builder.classdata.get(builder.methodref).packageId;
1274 final ClassData oldexpected =
1275 builder.classdata.get(builder.expected);
1276 final MethodData.Access acc =
1277 builder.classdata.get(builder.expected).methoddata.access;
1278 final ClassData withDef =
1279 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1280 final int C2 = builder.methodref;
1281 final int C1 = builder.addClass(withDef);
1282 builder.hier.addInherit(C1, C2);
1283 builder.objectref = C1;
1284 builder.expected = C1;
1285 },
1286 /* Case 2: Objectref's super overrides.
1287 *
1288 * C3[](*) = mref
1289 * C2[C3](res) = expected
1290 * C1[C2]() = oref
1291 */
1292 (final SelectionResolutionTestCase.Builder builder) -> {
1293 final ClassData.Package pck =
1294 builder.classdata.get(builder.methodref).packageId;
1295 final ClassData oldexpected =
1296 builder.classdata.get(builder.expected);
1297 final MethodData.Access acc =
1298 builder.classdata.get(builder.expected).methoddata.access;
1299 final ClassData withDef =
1300 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1301 final int C3 = builder.methodref;
1302 final int C2 = builder.addClass(withDef);
1303 final int C1 = builder.addClass(emptyClass(pck));
1304 builder.hier.addInherit(C2, C3);
1305 builder.hier.addInherit(C1, C2);
1306 builder.objectref = C1;
1307 builder.expected = C2;
1308 },
1309 /* Case 3: Objectref's super overrides, skip private.
1310 *
1311 * C3[*](*) = mref
1312 * C2[C3](res) = expected
1313 * C1[C2](priv) = oref
1314 */
1315 (final SelectionResolutionTestCase.Builder builder) -> {
1316 final ClassData.Package pck =
1317 builder.classdata.get(builder.methodref).packageId;
1318 final ClassData oldexpected =
1319 builder.classdata.get(builder.expected);
1320 final MethodData.Access acc =
1321 builder.classdata.get(builder.expected).methoddata.access;
1322 final ClassData withDef =
1323 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1324 final MethodData meth =
1325 new MethodData(MethodData.Access.PRIVATE,
1326 MethodData.Context.INSTANCE);
1327 final ClassData withPrivDef = new ClassData(pck, meth);
1328 final int C3 = builder.methodref;
1329 final int C2 = builder.addClass(withDef);
1330 final int C1 = builder.addClass(withPrivDef);
1331 builder.hier.addInherit(C2, C3);
1332 builder.hier.addInherit(C1, C2);
1333 builder.objectref = C1;
1334 builder.expected = C2;
1335 },
1336 /* Case 4: Objectref's super overrides, skip static.
1337 *
1338 * C3[*](*) = mref
1339 * C2[C3](res) = expected
1340 * C1[C2](stat) = oref
1341 */
1342 (final SelectionResolutionTestCase.Builder builder) -> {
1343 final ClassData.Package pck =
1344 builder.classdata.get(builder.methodref).packageId;
1345 final ClassData oldexpected =
1346 builder.classdata.get(builder.expected);
1347 final MethodData.Access acc =
1348 builder.classdata.get(builder.expected).methoddata.access;
1349 final ClassData withDef =
1350 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1351 final MethodData meth =
1352 new MethodData(MethodData.Access.PUBLIC,
1353 MethodData.Context.STATIC);
1354 final ClassData withStatDef = new ClassData(pck, meth);
1355 final int C3 = builder.methodref;
1356 final int C2 = builder.addClass(withDef);
1357 final int C1 = builder.addClass(withStatDef);
1358 builder.hier.addInherit(C2, C3);
1359 builder.hier.addInherit(C1, C2);
1360 builder.objectref = C1;
1361 builder.expected = C2;
1362 },
1363 /* Case 5: Overlapping with new interface overriding.
1364 *
1365 * I2[*](def) = old expected
1366 * C2[*](*) = mref, I1[I2](res) = expected
1367 * C1[C2,I2]() = oref
1368 */
1369 (final SelectionResolutionTestCase.Builder builder) -> {
1370 final ClassData.Package pck =
1371 builder.classdata.get(builder.methodref).packageId;
1372 final ClassData oldexpected =
1373 builder.classdata.get(builder.expected);
1374 final MethodData.Access acc =
1375 builder.classdata.get(builder.expected).methoddata.access;
1376 final ClassData withDef =
1377 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1378 final int C2 = builder.methodref;
1379 final int I2 = builder.expected;
1380 final int I1 = builder.addInterface(withDef);
1381 final int C1 = builder.addClass(emptyClass(pck));
1382 builder.hier.addInherit(C1, C2);
1383 builder.hier.addInherit(C1, I1);
1384 builder.hier.addInherit(I1, I2);
1385 builder.objectref = C1;
1386 builder.expected = I1;
1387 },
1388 /* Case 6: Overlapping with new interface, skip private.
1389 *
1390 * I2[*](def) = old expected
1391 * C2[*](*) = mref, I1[I2](res) = expected
1392 * C1[C2,I2](priv) = oref
1393 */
1394 (final SelectionResolutionTestCase.Builder builder) -> {
1395 final ClassData.Package pck =
1396 builder.classdata.get(builder.methodref).packageId;
1397 final ClassData oldexpected =
1398 builder.classdata.get(builder.expected);
1399 final MethodData.Access acc =
1400 builder.classdata.get(builder.expected).methoddata.access;
1401 final ClassData withDef =
1402 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1403 final MethodData meth =
1404 new MethodData(MethodData.Access.PRIVATE,
1405 MethodData.Context.INSTANCE);
1406 final ClassData withPrivDef = new ClassData(pck, meth);
1407 final int C2 = builder.methodref;
1408 final int I2 = builder.expected;
1409 final int I1 = builder.addInterface(withDef);
1410 final int C1 = builder.addClass(withPrivDef);
1411 builder.hier.addInherit(C1, C2);
1412 builder.hier.addInherit(C1, I1);
1413 builder.hier.addInherit(I1, I2);
1414 builder.objectref = C1;
1415 builder.expected = I1;
1416 },
1417 /* Case 7: Overlapping with new interface, skip static.
1418 *
1419 * I2[*](def) = old expected
1420 * C2[*](*) = mref, I1[I2](res) = expected
1421 * C1[C2,I2](stat) = oref
1422 */
1423 (final SelectionResolutionTestCase.Builder builder) -> {
1424 final ClassData.Package pck =
1425 builder.classdata.get(builder.methodref).packageId;
1426 final ClassData oldexpected =
1427 builder.classdata.get(builder.expected);
1428 final MethodData.Access acc =
1429 builder.classdata.get(builder.expected).methoddata.access;
1430 final ClassData withDef =
1431 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1432 final MethodData meth =
1433 new MethodData(MethodData.Access.PUBLIC,
1434 MethodData.Context.STATIC);
1435 final ClassData withStatDef = new ClassData(pck, meth);
1436 final int C2 = builder.methodref;
1437 final int I2 = builder.expected;
1438 final int I1 = builder.addInterface(withDef);
1439 final int C1 = builder.addClass(withStatDef);
1440 builder.hier.addInherit(C1, C2);
1441 builder.hier.addInherit(C1, I1);
1442 builder.hier.addInherit(I1, I2);
1443 builder.objectref = C1;
1444 builder.expected = I1;
1445 },
1446 /* Case 8: Overlap with objectref's super with new
1447 * interface overriding, inherit through class.
1448 *
1449 * I2[*](def) = old expected
1450 * C3[](*) = mref, I1[I2](res) = expected
1451 * C2[C3,I1]()
1452 * C1[C2]() = oref
1453 */
1454 (final SelectionResolutionTestCase.Builder builder) -> {
1455 final ClassData.Package pck =
1456 builder.classdata.get(builder.methodref).packageId;
1457 final ClassData oldexpected =
1458 builder.classdata.get(builder.expected);
1459 final MethodData.Access acc =
1460 builder.classdata.get(builder.expected).methoddata.access;
1461 final ClassData withDef =
1462 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1463 final int C3 = builder.methodref;
1464 final int C2 = builder.addClass(emptyClass(pck));
1465 final int I2 = builder.expected;
1466 final int I1 = builder.addInterface(withDef);
1467 final int C1 = builder.addClass(emptyClass(pck));
1468 builder.hier.addInherit(C2, C3);
1469 builder.hier.addInherit(C1, C2);
1470 builder.hier.addInherit(C2, I1);
1471 builder.hier.addInherit(I1, I2);
1472 builder.objectref = C1;
1473 builder.expected = I1;
1474 },
1475 /* Case 9: Overlap with objectref's super with new
1476 * interface double diamond, overriding.
1477 *
1478 * I3[*](def) = old expected
1479 * C3[](*) = mref, I2[I3](def)
1480 * C2[C3,I2](), I1[I2](res) = expected
1481 * C1[C2,I1]() = oref
1482 */
1483 (final SelectionResolutionTestCase.Builder builder) -> {
1484 final ClassData.Package pck =
1485 builder.classdata.get(builder.methodref).packageId;
1486 final ClassData oldexpected =
1487 builder.classdata.get(builder.expected);
1488 final MethodData.Access acc =
1489 builder.classdata.get(builder.expected).methoddata.access;
1490 final ClassData withDef =
1491 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1492 final int C3 = builder.methodref;
1493 final int C2 = builder.addClass(emptyClass(pck));
1494 final int I3 = builder.expected;
1495 final int I2 = builder.addInterface(withDef);
1496 final int I1 = builder.addInterface(withDef);
1497 final int C1 = builder.addClass(emptyClass(pck));
1498 builder.hier.addInherit(C2, C3);
1499 builder.hier.addInherit(C1, C2);
1500 builder.hier.addInherit(C1, I1);
1501 builder.hier.addInherit(C2, I2);
1502 builder.hier.addInherit(I1, I2);
1503 builder.hier.addInherit(I2, I3);
1504 builder.objectref = C1;
1505 builder.expected = I1;
1506 },
1507 /* Case 10: Overlap with objectref's super with new
1508 * interface double diamond, skip private.
1509 *
1510 * I3[*](def) = old expected
1511 * C3[](*) = mref, I2[I3](res) = expected
1512 * C2[C3,I2](), I1[I2](priv)
1513 * C1[C2,I1]() = oref
1514 */
1515 (final SelectionResolutionTestCase.Builder builder) -> {
1516 final ClassData.Package pck =
1517 builder.classdata.get(builder.methodref).packageId;
1518 final ClassData oldexpected =
1519 builder.classdata.get(builder.expected);
1520 final MethodData.Access acc =
1521 builder.classdata.get(builder.expected).methoddata.access;
1522 final ClassData withDef =
1523 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1524 final MethodData meth =
1525 new MethodData(MethodData.Access.PRIVATE,
1526 MethodData.Context.INSTANCE);
1527 final ClassData withPrivDef = new ClassData(pck, meth);
1528 final int C3 = builder.methodref;
1529 final int C2 = builder.addClass(emptyClass(pck));
1530 final int I3 = builder.expected;
1531 final int I2 = builder.addInterface(withDef);
1532 final int I1 = builder.addInterface(withPrivDef);
1533 final int C1 = builder.addClass(emptyClass(pck));
1534 builder.hier.addInherit(C2, C3);
1535 builder.hier.addInherit(C1, C2);
1536 builder.hier.addInherit(C1, I1);
1537 builder.hier.addInherit(C2, I2);
1538 builder.hier.addInherit(I1, I2);
1539 builder.hier.addInherit(I2, I3);
1540 builder.objectref = C1;
1541 builder.expected = I2;
1542 },
1543 /* Case 11: Overlap with objectref's super with new
1544 * interface double diamond, skip static.
1545 *
1546 * I3[*](def) = old expected
1547 * C3[](*) = mref, I2[I3](res) = expected
1548 * C2[C3,I2](), I1[I2](stat)
1549 * C1[C2,I1]() = oref
1550 */
1551 (final SelectionResolutionTestCase.Builder builder) -> {
1552 final ClassData.Package pck =
1553 builder.classdata.get(builder.methodref).packageId;
1554 final ClassData oldexpected =
1555 builder.classdata.get(builder.expected);
1556 final MethodData.Access acc =
1557 builder.classdata.get(builder.expected).methoddata.access;
1558 final ClassData withDef =
1559 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1560 final MethodData meth =
1561 new MethodData(MethodData.Access.PUBLIC,
1562 MethodData.Context.STATIC);
1563 final ClassData withStatDef = new ClassData(pck, meth);
1564 final int C3 = builder.methodref;
1565 final int C2 = builder.addClass(emptyClass(pck));
1566 final int I3 = builder.expected;
1567 final int I2 = builder.addInterface(withDef);
1568 final int I1 = builder.addInterface(withStatDef);
1569 final int C1 = builder.addClass(emptyClass(pck));
1570 builder.hier.addInherit(C2, C3);
1571 builder.hier.addInherit(C1, C2);
1572 builder.hier.addInherit(C1, I1);
1573 builder.hier.addInherit(C2, I2);
1574 builder.hier.addInherit(I1, I2);
1575 builder.hier.addInherit(I2, I3);
1576 builder.objectref = C1;
1577 builder.expected = I2;
1578 },
1579 /* Case 12: Objectref's super overrides, skip interface below.
1580 *
1581 * C3[](*) = mref
1582 * C2[C3](res) = expected, I[](def)
1583 * C1[C2,I]() = oref
1584 */
1585 (final SelectionResolutionTestCase.Builder builder) -> {
1586 final ClassData.Package pck =
1587 builder.classdata.get(builder.methodref).packageId;
1588 final ClassData oldexpected =
1589 builder.classdata.get(builder.expected);
1590 final MethodData.Access acc =
1591 builder.classdata.get(builder.expected).methoddata.access;
1592 final ClassData withDef =
1593 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1594 final int C3 = builder.methodref;
1595 final int C2 = builder.addClass(withDef);
1596 final int C1 = builder.addClass(emptyClass(pck));
1597 final int I = builder.addInterface(withDef);
1598 builder.hier.addInherit(C2, C3);
1599 builder.hier.addInherit(C1, C2);
1600 builder.hier.addInherit(C1, I);
1601 builder.objectref = C1;
1602 builder.expected = C2;
1603 },
1604 /* Case 13: Objectref's super overrides, skip interface above.
1605 *
1606 * C3[](*) = mref, I[](def)
1607 * C2[C3,I](res) = expected
1608 * C1[C2]() = oref
1609 */
1610 (final SelectionResolutionTestCase.Builder builder) -> {
1611 final ClassData.Package pck =
1612 builder.classdata.get(builder.methodref).packageId;
1613 final ClassData oldexpected =
1614 builder.classdata.get(builder.expected);
1615 final MethodData.Access acc =
1616 builder.classdata.get(builder.expected).methoddata.access;
1617 final ClassData withDef =
1618 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1619 final int C3 = builder.methodref;
1620 final int C2 = builder.addClass(withDef);
1621 final int C1 = builder.addClass(emptyClass(pck));
1622 final int I = builder.addInterface(withDef);
1623 builder.hier.addInherit(C2, C3);
1624 builder.hier.addInherit(C1, C2);
1625 builder.hier.addInherit(C2, I);
1626 builder.objectref = C1;
1627 builder.expected = C2;
1628 });
1629
1630 public static final Template ReabstractIfaceMethodrefResolved =
1631 new Template("ReabstractIfaceMethodrefResolved",
1632 /* Case 1: Objectref overrides.
1633 *
1634 * I[](*) = mref
1635 * C[I](res) = oref = expected
1636 */
1637 (final SelectionResolutionTestCase.Builder builder) -> {
1638 final ClassData.Package pck =
1639 builder.classdata.get(builder.methodref).packageId;
1640 final ClassData oldexpected =
1641 builder.classdata.get(builder.expected);
1642 final MethodData.Access acc =
1643 builder.classdata.get(builder.expected).methoddata.access;
1644 final ClassData withDef =
1645 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1646 final int I = builder.methodref;
1647 final int C = builder.addClass(withDef);
1648 builder.hier.addInherit(C, I);
1649 builder.objectref = C;
1650 builder.expected = C;
1651 },
1652 /* Case 2: Diamond, methodref at top, overriding.
1653 *
1654 * I3[](*) = mref
1655 * I1[I3](), I2[I3](res) = expected
1656 * C[I1,I2]() = oref
1657 */
1658 (final SelectionResolutionTestCase.Builder builder) -> {
1659 final ClassData.Package pck =
1660 builder.classdata.get(builder.expected).packageId;
1661 final ClassData oldexpected =
1662 builder.classdata.get(builder.expected);
1663 final MethodData.Access acc =
1664 builder.classdata.get(builder.expected).methoddata.access;
1665 final ClassData withDef =
1666 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1667 final int I3 = builder.methodref;
1668 final int I2 = builder.addInterface(withDef);
1669 final int I1 = builder.addInterface(emptyClass(pck));
1670 final int C = builder.addClass(emptyClass(pck));
1671 builder.hier.addInherit(C, I1);
1672 builder.hier.addInherit(C, I2);
1673 builder.hier.addInherit(I1, I3);
1674 builder.hier.addInherit(I2, I3);
1675 builder.objectref = C;
1676 builder.expected = I2;
1677 },
1678 /* Case 3: Diamond, methodref at top, skip static.
1679 *
1680 * I3[](*) = mref
1681 * I1[I3](), I2[I3](res) = expected
1682 * C[I1,I2](stat) = oref
1683 */
1684 (final SelectionResolutionTestCase.Builder builder) -> {
1685 final ClassData.Package pck =
1686 builder.classdata.get(builder.expected).packageId;
1687 final ClassData oldexpected =
1688 builder.classdata.get(builder.expected);
1689 final MethodData.Access acc =
1690 builder.classdata.get(builder.expected).methoddata.access;
1691 final ClassData withDef =
1692 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1693 final MethodData meth =
1694 new MethodData(MethodData.Access.PUBLIC,
1695 MethodData.Context.STATIC);
1696 final ClassData withStatDef = new ClassData(pck, meth);
1697 final int I3 = builder.methodref;
1698 final int I2 = builder.addInterface(withDef);
1699 final int I1 = builder.addInterface(emptyClass(pck));
1700 final int C = builder.addClass(withStatDef);
1701 builder.hier.addInherit(C, I1);
1702 builder.hier.addInherit(C, I2);
1703 builder.hier.addInherit(I1, I3);
1704 builder.hier.addInherit(I2, I3);
1705 builder.objectref = C;
1706 builder.expected = I2;
1707 },
1708 /* Case 4: Diamond, with superclass, methodref at top,
1709 * class overriding.
1710 *
1711 * I2[](*) = mref
1712 * C2[I2](res) = expected, I1[I2]()
1713 * C1[I1,C2]() = oref
1714 */
1715 (final SelectionResolutionTestCase.Builder builder) -> {
1716 final ClassData.Package pck =
1717 builder.classdata.get(builder.expected).packageId;
1718 final ClassData oldexpected =
1719 builder.classdata.get(builder.expected);
1720 final MethodData.Access acc =
1721 builder.classdata.get(builder.expected).methoddata.access;
1722 final ClassData withDef =
1723 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1724 final int I2 = builder.methodref;
1725 final int I1 = builder.addInterface(emptyClass(pck));
1726 final int C2 = builder.addClass(withDef);
1727 final int C1 = builder.addClass(emptyClass(pck));
1728 builder.hier.addInherit(C1, I1);
1729 builder.hier.addInherit(C1, C2);
1730 builder.hier.addInherit(I1, I2);
1731 builder.hier.addInherit(C2, I2);
1732 builder.objectref = C1;
1733 builder.expected = C2;
1734 },
1735 /* Case 5: Diamond, with superclass, methodref at top,
1736 * class overriding, skip static.
1737 *
1738 * I2[](*) = mref
1739 * C2[I2](res) = expected, I1[I2]()
1740 * C1[I1,C2](stat) = oref
1741 */
1742 (final SelectionResolutionTestCase.Builder builder) -> {
1743 final ClassData.Package pck =
1744 builder.classdata.get(builder.expected).packageId;
1745 final ClassData oldexpected =
1746 builder.classdata.get(builder.expected);
1747 final MethodData.Access acc =
1748 builder.classdata.get(builder.expected).methoddata.access;
1749 final ClassData withDef =
1750 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1751 final MethodData meth =
1752 new MethodData(MethodData.Access.PUBLIC,
1753 MethodData.Context.STATIC);
1754 final ClassData withStatDef = new ClassData(pck, meth);
1755 final int I2 = builder.methodref;
1756 final int I1 = builder.addInterface(emptyClass(pck));
1757 final int C2 = builder.addClass(withDef);
1758 final int C1 = builder.addClass(withStatDef);
1759 builder.hier.addInherit(C1, I1);
1760 builder.hier.addInherit(C1, C2);
1761 builder.hier.addInherit(I1, I2);
1762 builder.hier.addInherit(C2, I2);
1763 builder.objectref = C1;
1764 builder.expected = C2;
1765 },
1766 /* Case 6: Diamond, with superclass, expected at top,
1767 * interface overriding
1768 *
1769 * I2[](*) = mref
1770 * C2[I2](), I1[I2](res) = expected
1771 * C1[I1,C2]() = oref
1772 */
1773 (final SelectionResolutionTestCase.Builder builder) -> {
1774 final ClassData.Package pck =
1775 builder.classdata.get(builder.expected).packageId;
1776 final ClassData oldexpected =
1777 builder.classdata.get(builder.expected);
1778 final MethodData.Access acc =
1779 builder.classdata.get(builder.expected).methoddata.access;
1780 final ClassData withDef =
1781 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1782 final int I2 = builder.methodref;
1783 final int I1 = builder.addInterface(withDef);
1784 final int C2 = builder.addClass(emptyClass(pck));
1785 final int C1 = builder.addClass(emptyClass(pck));
1786 builder.hier.addInherit(C1, I1);
1787 builder.hier.addInherit(C1, C2);
1788 builder.hier.addInherit(I1, I2);
1789 builder.hier.addInherit(C2, I2);
1790 builder.objectref = C1;
1791 builder.expected = I1;
1792 },
1793 /* Case 7: Diamond, with superclass, expected at top,
1794 * interface skip static
1795 *
1796 * I2[](*) = mref
1797 * C2[I2](), I1[I2](res) = expected
1798 * C1[I1,C2](stat) = oref
1799 */
1800 (final SelectionResolutionTestCase.Builder builder) -> {
1801 final ClassData.Package pck =
1802 builder.classdata.get(builder.expected).packageId;
1803 final ClassData oldexpected =
1804 builder.classdata.get(builder.expected);
1805 final MethodData.Access acc =
1806 builder.classdata.get(builder.expected).methoddata.access;
1807 final ClassData withDef =
1808 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1809 final MethodData meth =
1810 new MethodData(MethodData.Access.PUBLIC,
1811 MethodData.Context.STATIC);
1812 final ClassData withStatDef = new ClassData(pck, meth);
1813 final int I2 = builder.methodref;
1814 final int I1 = builder.addInterface(withDef);
1815 final int C2 = builder.addClass(emptyClass(pck));
1816 final int C1 = builder.addClass(withStatDef);
1817 builder.hier.addInherit(C1, I1);
1818 builder.hier.addInherit(C1, C2);
1819 builder.hier.addInherit(I1, I2);
1820 builder.hier.addInherit(C2, I2);
1821 builder.objectref = C1;
1822 builder.expected = I1;
1823 },
1824 /* Case 8: Y, with superclass, overlaping, expected
1825 * at top, class overrides
1826 *
1827 * C2[I2](res) = expected, I1[](*) = mref
1828 * C1[I1,C2]() = oref
1829 */
1830 (final SelectionResolutionTestCase.Builder builder) -> {
1831 final ClassData.Package pck =
1832 builder.classdata.get(builder.expected).packageId;
1833 final ClassData oldexpected =
1834 builder.classdata.get(builder.expected);
1835 final MethodData.Access acc =
1836 builder.classdata.get(builder.expected).methoddata.access;
1837 final ClassData withDef =
1838 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1839 final int I1 = builder.methodref;
1840 final int C2 = builder.addClass(withDef);
1841 final int C1 = builder.addClass(emptyClass(pck));
1842 builder.hier.addInherit(C1, I1);
1843 builder.hier.addInherit(C1, C2);
1844 builder.objectref = C1;
1845 builder.expected = C2;
1846 },
1847 /* Case 9: Diamond, with superclass, overlaping, expected
1848 * at top, class overrides
1849 *
1850 * I2[](def) = old expected
1851 * C2[I2](res) = expected, I1[](*) = mref
1852 * C1[I1,C2]() = oref
1853 */
1854 (final SelectionResolutionTestCase.Builder builder) -> {
1855 final ClassData.Package pck =
1856 builder.classdata.get(builder.expected).packageId;
1857 final ClassData oldexpected =
1858 builder.classdata.get(builder.expected);
1859 final MethodData.Access acc =
1860 builder.classdata.get(builder.expected).methoddata.access;
1861 final ClassData withDef =
1862 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1863 final int I2 = builder.expected;
1864 final int I1 = builder.methodref;
1865 final int C2 = builder.addClass(withDef);
1866 final int C1 = builder.addClass(emptyClass(pck));
1867 builder.hier.addInherit(C1, I1);
1868 builder.hier.addInherit(C1, C2);
1869 builder.hier.addInherit(C2, I2);
1870 builder.objectref = C1;
1871 builder.expected = C2;
1872 },
1873 /* Case 10: Diamond, with superclass, overlaping, expected
1874 * at top, class overrides, skipping static
1875 *
1876 * I2[](def) = old expected
1877 * C2[I2](res) = expected, I1[](*) = mref
1878 * C1[I1,C2](stat) = oref
1879 */
1880 (final SelectionResolutionTestCase.Builder builder) -> {
1881 final ClassData.Package pck =
1882 builder.classdata.get(builder.expected).packageId;
1883 final ClassData oldexpected =
1884 builder.classdata.get(builder.expected);
1885 final MethodData.Access acc =
1886 builder.classdata.get(builder.expected).methoddata.access;
1887 final ClassData withDef =
1888 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1889 final MethodData meth =
1890 new MethodData(MethodData.Access.PUBLIC,
1891 MethodData.Context.STATIC);
1892 final ClassData withStatDef = new ClassData(pck, meth);
1893 final int I2 = builder.expected;
1894 final int I1 = builder.methodref;
1895 final int C2 = builder.addClass(withDef);
1896 final int C1 = builder.addClass(withStatDef);
1897 builder.hier.addInherit(C1, I1);
1898 builder.hier.addInherit(C1, C2);
1899 builder.hier.addInherit(C2, I2);
1900 builder.objectref = C1;
1901 builder.expected = C2;
1902 },
1903 /* Case 11: Superclass overrides.
1904 *
1905 * I[](*) = mref
1906 * C2[I](res) = expected
1907 * C1[C2]() = oref
1908 */
1909 (final SelectionResolutionTestCase.Builder builder) -> {
1910 final ClassData.Package pck =
1911 builder.classdata.get(builder.expected).packageId;
1912 final MethodData.Access acc =
1913 builder.classdata.get(builder.expected).methoddata.access;
1914 final ClassData withDef =
1915 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1916 final int I = builder.methodref;
1917 final int C2 = builder.addClass(withDef);
1918 final int C1 = builder.addClass(emptyClass(pck));
1919 builder.hier.addInherit(C1, I);
1920 builder.hier.addInherit(C1, C2);
1921 builder.hier.addInherit(C2, I);
1922 builder.objectref = C1;
1923 },
1924 /* Case 12: Superclass overrides, skipping static.
1925 *
1926 * I[](*) = mref
1927 * C2[I](res) = expected
1928 * C1[C2](stat) = oref
1929 */
1930 (final SelectionResolutionTestCase.Builder builder) -> {
1931 final ClassData.Package pck =
1932 builder.classdata.get(builder.expected).packageId;
1933 final MethodData.Access acc =
1934 builder.classdata.get(builder.expected).methoddata.access;
1935 final ClassData withDef =
1936 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1937 final MethodData meth =
1938 new MethodData(MethodData.Access.PUBLIC,
1939 MethodData.Context.STATIC);
1940 final ClassData withStatDef = new ClassData(pck, meth);
1941 final int I = builder.methodref;
1942 final int C2 = builder.addClass(withDef);
1943 final int C1 = builder.addClass(withStatDef);
1944 builder.hier.addInherit(C1, I);
1945 builder.hier.addInherit(C1, C2);
1946 builder.hier.addInherit(C2, I);
1947 builder.objectref = C1;
1948 },
1949 /* Case 13: Double diamond, with superclass, inherit through
1950 * superclass, expected at top.
1951 *
1952 * I3[](def) = old expected
1953 * C3[I3](), I2[*](*) = mref
1954 * C2[I2,C3](), I1[I2](res) = expected
1955 * C1[C2,I1]() = oref
1956 */
1957 (final SelectionResolutionTestCase.Builder builder) -> {
1958 final ClassData.Package pck =
1959 builder.classdata.get(builder.expected).packageId;
1960 final ClassData oldexpected =
1961 builder.classdata.get(builder.expected);
1962 final MethodData.Access acc =
1963 builder.classdata.get(builder.expected).methoddata.access;
1964 final ClassData withDef =
1965 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1966 final int I3 = builder.expected;
1967 final int I2 = builder.methodref;
1968 final int I1 = builder.addInterface(withDef);
1969 final int C3 = builder.addClass(emptyClass(pck));
1970 final int C2 = builder.addClass(emptyClass(pck));
1971 final int C1 = builder.addClass(emptyClass(pck));
1972 builder.hier.addInherit(C2, I2);
1973 builder.hier.addInherit(C2, C3);
1974 builder.hier.addInherit(C3, I3);
1975 builder.hier.addInherit(C1, C2);
1976 builder.hier.addInherit(I1, I2);
1977 builder.hier.addInherit(C1, I1);
1978 builder.objectref = C1;
1979 builder.expected = I1;
1980 },
1981 /* Case 14: Double diamond, with superclass, inherit through
1982 * superclass, expected at top.
1983 *
1984 * I3[](def) = mref
1985 * C3[I3](), I2[*](*) = expected
1986 * C2[I2,C3](), I1[I2](priv)
1987 * C1[C2,I1]() = oref
1988 */
1989 (final SelectionResolutionTestCase.Builder builder) -> {
1990 final ClassData.Package pck =
1991 builder.classdata.get(builder.expected).packageId;
1992 final ClassData oldexpected =
1993 builder.classdata.get(builder.expected);
1994 final MethodData.Access acc =
1995 builder.classdata.get(builder.expected).methoddata.access;
1996 final ClassData withDef =
1997 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
1998 final MethodData meth =
1999 new MethodData(MethodData.Access.PRIVATE,
2000 MethodData.Context.INSTANCE);
2001 final ClassData withPrivDef = new ClassData(pck, meth);
2002 final int I3 = builder.methodref;
2003 final int I2 = builder.addInterface(withDef);
2004 final int I1 = builder.addInterface(withPrivDef);
2005 final int C3 = builder.addClass(emptyClass(pck));
2006 final int C2 = builder.addClass(emptyClass(pck));
2007 final int C1 = builder.addClass(emptyClass(pck));
2008 builder.hier.addInherit(C2, I2);
2009 builder.hier.addInherit(C2, C3);
2010 builder.hier.addInherit(C3, I3);
2011 builder.hier.addInherit(C1, C2);
2012 builder.hier.addInherit(I1, I2);
2013 builder.hier.addInherit(C1, I1);
2014 builder.objectref = C1;
2015 builder.expected = I2;
2016 },
2017 /* Case 15: Double diamond, with superclass, inherit through
2018 * superclass, expected at top.
2019 *
2020 * I3[](def) = mref
2021 * C3[I3](), I2[*](*) = expected
2022 * C2[I2,C3](), I1[I2](stat)
2023 * C1[C2,I1]() = oref
2024 */
2025 (final SelectionResolutionTestCase.Builder builder) -> {
2026 final ClassData.Package pck =
2027 builder.classdata.get(builder.expected).packageId;
2028 final ClassData oldexpected =
2029 builder.classdata.get(builder.expected);
2030 final MethodData.Access acc =
2031 builder.classdata.get(builder.expected).methoddata.access;
2032 final ClassData withDef =
2033 new ClassData(pck, new MethodData(acc, MethodData.Context.ABSTRACT));
2034 final MethodData meth =
2035 new MethodData(MethodData.Access.PUBLIC,
2036 MethodData.Context.STATIC);
2037 final ClassData withStatDef = new ClassData(pck, meth);
2038 final int I3 = builder.methodref;
2039 final int I2 = builder.addInterface(withDef);
2040 final int I1 = builder.addInterface(withStatDef);
2041 final int C3 = builder.addClass(emptyClass(pck));
2042 final int C2 = builder.addClass(emptyClass(pck));
2043 final int C1 = builder.addClass(emptyClass(pck));
2044 builder.hier.addInherit(C2, I2);
2045 builder.hier.addInherit(C2, C3);
2046 builder.hier.addInherit(C3, I3);
2047 builder.hier.addInherit(C1, C2);
2048 builder.hier.addInherit(I1, I2);
2049 builder.hier.addInherit(C1, I1);
2050 builder.objectref = C1;
2051 builder.expected = I2;
2052 });
2053
2054 /******************************
2055 * Abstract Overrides *
2056 ******************************/
2057
2058 public static final Template OverrideAbstractExpectedIface =
2059 Template.ResolutionOverride(EnumSet.of(Template.Kind.INTERFACE),
2060 EnumSet.of(MethodData.Access.PUBLIC),
2061 EnumSet.allOf(MethodData.Context.class),
2062 EnumSet.of(ClassData.Package.SAME));
2063
2064 public static final Template OverrideAbstractExpectedClass =
2065 Template.ResolutionOverride(EnumSet.allOf(Template.Kind.class),
2066 EnumSet.of(MethodData.Access.PUBLIC),
2067 EnumSet.allOf(MethodData.Context.class),
2068 EnumSet.of(ClassData.Package.SAME));
2069
2070 public static final Template SelectionOverrideAbstract =
2071 new Template("SelectionOverrideAbstract",
2072 (final SelectionResolutionTestCase.Builder builder) -> {
2073 final ClassData expected =
2074 builder.classdata.get(builder.expected);
2075 final MethodData olddef =
2076 expected.methoddata;
2077 if (MethodData.Context.ABSTRACT == olddef.context) {
2078 final ClassData.Package pck = expected.packageId;
2079 final MethodData.Access acc = olddef.access;
2080 final MethodData mdata =
2081 getMethodData(MethodData.Access.PUBLIC,
2082 MethodData.Context.INSTANCE);
2083 final ClassData withDef = new ClassData(pck, mdata);
2084 final int C2 = builder.objectref;
2085 final int C1 = builder.addClass(withDef);
2086 builder.hier.addInherit(C1, C2);
2087 builder.objectref = C1;
2088 builder.expected = C1;
2089 }
2090 });
2091
2092
2093 /******************************
2094 * Ignored Abstract Templates *
2095 ******************************/
2096
2097 public static final Template IgnoredAbstract =
2098 new Template("IgnoredAbstract",
2099 (builder) -> {},
2100 (final SelectionResolutionTestCase.Builder builder) -> {
2101 final ClassData methodref =
2102 builder.classdata.get(builder.methodref);
2103 final ClassData.Package pck = methodref.packageId;
2104 final MethodData mdata =
2105 getMethodData(MethodData.Access.PUBLIC,
2106 MethodData.Context.ABSTRACT);
2107 final ClassData withDef = new ClassData(pck, mdata);
2108 final int C2 = builder.addInterface(withDef);
2109 final int C1 = builder.methodref;
2110 builder.hier.addInherit(C1, C2);
2111 });
2112
2113 /******************************
2114 * Selection Templates *
2115 ******************************/
2116
2117
2118
2119 public static final Template TrivialObjectref =
2120 new Template("TrivialObjectref",
2121 Collections.singleton((builder) -> {
2122 builder.objectref = builder.methodref;
2123 }));
2124
2125 public static final Template TrivialObjectrefNotEqualMethodref =
2126 new Template("TrivialObjectrefNotEqualMethodref",
2127 Collections.singleton(
2128 (final SelectionResolutionTestCase.Builder builder) -> {
2129 final ClassData oldexpected =
2130 builder.classdata.get(builder.expected);
2131 final ClassData.Package pck = oldexpected.packageId;
2132 final int C2 = builder.methodref;
2133 final int C1 = builder.addClass(emptyClass(pck));
2134 builder.hier.addInherit(C1, C2);
2135 builder.objectref = C1;
2136 }));
2137
2138 public static final Template MethodrefSelectionResolvedIsClassNoOverride =
2139 new Template("MethodrefSelectionResolvedIsClassNoOverride",
2140 /* Trivial.
2141 *
2142 * C[](*) = mref = oref
2143 */
2144 (builder) -> {
2145 builder.objectref = builder.methodref;
2146 },
2147 /* Case 1: Inherit from super.
2148 *
2149 * C2[](*) = mref
2150 * C1[C2]() = oref
2151 */
2152 (final SelectionResolutionTestCase.Builder builder) -> {
2153 final ClassData.Package pck =
2154 builder.classdata.get(builder.methodref).packageId;
2155 final int C2 = builder.methodref;
2156 final int C1 = builder.addClass(emptyClass(pck));
2157 builder.hier.addInherit(C1, C2);
2158 builder.objectref = C1;
2159 },
2160 /* Case 2: Objectref has private def.
2161 *
2162 * C2[](*) = mref
2163 * C1[C2](priv) = oref
2164 */
2165 (final SelectionResolutionTestCase.Builder builder) -> {
2166 final ClassData.Package pck =
2167 builder.classdata.get(builder.methodref).packageId;
2168 final ClassData oldexpected =
2169 builder.classdata.get(builder.expected);
2170 final MethodData meth =
2171 new MethodData(MethodData.Access.PRIVATE,
2172 MethodData.Context.INSTANCE);
2173 final ClassData withDef = new ClassData(pck, meth);
2174 final int C2 = builder.methodref;
2175 final int C1 = builder.addClass(withDef);
2176 builder.hier.addInherit(C1, C2);
2177 builder.objectref = C1;
2178 },
2179 /* Case 3: Objectref has static def.
2180 *
2181 * C2[](*) = mref
2182 * C1[C2](stat) = oref
2183 */
2184 (final SelectionResolutionTestCase.Builder builder) -> {
2185 final ClassData.Package pck =
2186 builder.classdata.get(builder.methodref).packageId;
2187 final ClassData oldexpected =
2188 builder.classdata.get(builder.expected);
2189 final MethodData meth =
2190 new MethodData(MethodData.Access.PUBLIC,
2191 MethodData.Context.STATIC);
2192 final ClassData withDef = new ClassData(pck, meth);
2193 final int C2 = builder.methodref;
2194 final int C1 = builder.addClass(withDef);
2195 builder.hier.addInherit(C1, C2);
2196 builder.objectref = C1;
2197 },
2198 /* Case 4: Skip inherit from interface.
2199 *
2200 * C2[](*) = mref, I[](def)
2201 * C1[C2,I]() = oref
2202 */
2203 (final SelectionResolutionTestCase.Builder builder) -> {
2204 final ClassData oldexpected =
2205 builder.classdata.get(builder.expected);
2206 final ClassData.Package pck = oldexpected.packageId;
2207 final MethodData.Context ctx =
2208 builder.classdata.get(builder.expected).methoddata.context;
2209 final MethodData.Access acc =
2210 builder.classdata.get(builder.expected).methoddata.access;
2211 final MethodData mdata = getMethodData(acc, ctx);
2212 final ClassData withDef = new ClassData(pck, mdata);
2213 final int C2 = builder.methodref;
2214 final int C1 = builder.addClass(emptyClass(pck));
2215 final int I = builder.addInterface(withDef);
2216 builder.hier.addInherit(C1, C2);
2217 builder.hier.addInherit(C1, I);
2218 builder.objectref = C1;
2219 },
2220 /* Case 5: Objectref's super has a private def.
2221 *
2222 * C3[*](*) = mref
2223 * C2[C3](res) = expected
2224 * C1[C2]() = oref
2225 */
2226 (final SelectionResolutionTestCase.Builder builder) -> {
2227 final ClassData.Package pck =
2228 builder.classdata.get(builder.methodref).packageId;
2229 final ClassData oldexpected =
2230 builder.classdata.get(builder.expected);
2231 final MethodData meth =
2232 new MethodData(MethodData.Access.PRIVATE,
2233 MethodData.Context.INSTANCE);
2234 final ClassData withDef =
2235 new ClassData(pck, meth);
2236 final int C3 = builder.methodref;
2237 final int C2 = builder.addClass(withDef);
2238 final int C1 = builder.addClass(emptyClass(pck));
2239 builder.hier.addInherit(C2, C3);
2240 builder.hier.addInherit(C1, C2);
2241 builder.objectref = C1;
2242 },
2243 /* Case 6: Objectref's super has a static def.
2244 *
2245 * C3[*](*) = mref
2246 * C2[C3](res) = expected
2247 * C1[C2]() = oref
2248 */
2249 (final SelectionResolutionTestCase.Builder builder) -> {
2250 final ClassData.Package pck =
2251 builder.classdata.get(builder.methodref).packageId;
2252 final ClassData oldexpected =
2253 builder.classdata.get(builder.expected);
2254 final MethodData meth =
2255 new MethodData(MethodData.Access.PUBLIC,
2256 MethodData.Context.STATIC);
2257 final ClassData withDef =
2258 new ClassData(pck, meth);
2259 final int C3 = builder.methodref;
2260 final int C2 = builder.addClass(withDef);
2261 final int C1 = builder.addClass(emptyClass(pck));
2262 builder.hier.addInherit(C2, C3);
2263 builder.hier.addInherit(C1, C2);
2264 builder.objectref = C1;
2265 });
2266
2267 public static final Template MethodrefSelectionResolvedIsClassOverride =
2268 new Template("MethodrefSelectionResolvedIsClassOverride",
2269 /* Case 7: Objectref overrides.
2270 *
2271 * C2[](*) = mref
2272 * C1[C2](res) = oref = expected
2273 */
2274 (final SelectionResolutionTestCase.Builder builder) -> {
2275 final ClassData.Package pck =
2276 builder.classdata.get(builder.methodref).packageId;
2277 final ClassData oldexpected =
2278 builder.classdata.get(builder.expected);
2279 final ClassData withDef =
2280 new ClassData(pck, oldexpected.methoddata);
2281 final int C2 = builder.methodref;
2282 final int C1 = builder.addClass(withDef);
2283 builder.hier.addInherit(C1, C2);
2284 builder.objectref = C1;
2285 builder.expected = C1;
2286 },
2287 /* Case 8: Objectref's super overrides.
2288 *
2289 * C3[*](*) = mref
2290 * C2[C3](res)
2291 * C1[C2]() = oref
2292 */
2293 (final SelectionResolutionTestCase.Builder builder) -> {
2294 final ClassData.Package pck =
2295 builder.classdata.get(builder.methodref).packageId;
2296 final ClassData oldexpected =
2297 builder.classdata.get(builder.expected);
2298 final ClassData withDef =
2299 new ClassData(pck, oldexpected.methoddata);
2300 final int C3 = builder.methodref;
2301 final int C2 = builder.addClass(withDef);
2302 final int C1 = builder.addClass(emptyClass(pck));
2303 builder.hier.addInherit(C2, C3);
2304 builder.hier.addInherit(C1, C2);
2305 builder.objectref = C1;
2306 builder.expected = C2;
2307 },
2308 /* Case 9: Objectref's super overrides,
2309 * objectref has a private def.
2310 *
2311 * C3[*](*) = mref
2312 * C2[C3](res)
2313 * C1[C2](priv) = oref
2314 */
2315 (final SelectionResolutionTestCase.Builder builder) -> {
2316 final ClassData.Package pck =
2317 builder.classdata.get(builder.methodref).packageId;
2318 final ClassData oldexpected =
2319 builder.classdata.get(builder.expected);
2320 final ClassData withDef =
2321 new ClassData(pck, oldexpected.methoddata);
2322 final MethodData meth =
2323 new MethodData(MethodData.Access.PRIVATE,
2324 MethodData.Context.INSTANCE);
2325 final ClassData withPrivDef =
2326 new ClassData(pck, meth);
2327 final int C3 = builder.methodref;
2328 final int C2 = builder.addClass(withDef);
2329 final int C1 = builder.addClass(withPrivDef);
2330 builder.hier.addInherit(C2, C3);
2331 builder.hier.addInherit(C1, C2);
2332 builder.objectref = C1;
2333 builder.expected = C2;
2334 },
2335 /* Case 10: Objectref's super overrides,
2336 * objectref has a static def.
2337 *
2338 * C3[*](*) = mref
2339 * C2[C3](res)
2340 * C1[C2](stat) = oref
2341 */
2342 (final SelectionResolutionTestCase.Builder builder) -> {
2343 final ClassData.Package pck =
2344 builder.classdata.get(builder.methodref).packageId;
2345 final ClassData oldexpected =
2346 builder.classdata.get(builder.expected);
2347 final ClassData withDef =
2348 new ClassData(pck, oldexpected.methoddata);
2349 final MethodData meth =
2350 new MethodData(MethodData.Access.PUBLIC,
2351 MethodData.Context.STATIC);
2352 final ClassData withPrivDef =
2353 new ClassData(pck, meth);
2354 final int C3 = builder.methodref;
2355 final int C2 = builder.addClass(withDef);
2356 final int C1 = builder.addClass(withPrivDef);
2357 builder.hier.addInherit(C2, C3);
2358 builder.hier.addInherit(C1, C2);
2359 builder.objectref = C1;
2360 builder.expected = C2;
2361 });
2362
2363 public static final Template MethodrefSelectionResolvedIsClass =
2364 new Template("MethodrefSelectionResolvedIsClass",
2365 MethodrefSelectionResolvedIsClassNoOverride,
2366 MethodrefSelectionResolvedIsClassOverride);
2367
2368 public static final Template MethodrefSelectionPackageSkip =
2369 new Template("MethodrefSelectionPackageSkip",
2370 MethodrefSelectionResolvedIsClass,
2371 /* Case 11: Objectref has public def in other package.
2372 *
2373 * C2[](*) = mref
2374 * Other.C1[C2](pub) = oref
2375 */
2376 (final SelectionResolutionTestCase.Builder builder) -> {
2377 final ClassData.Package pck =
2378 builder.classdata.get(builder.methodref).packageId;
2379 final ClassData oldexpected =
2380 builder.classdata.get(builder.expected);
2381 final MethodData meth =
2382 new MethodData(MethodData.Access.PUBLIC,
2383 MethodData.Context.INSTANCE);
2384 final ClassData withDef =
2385 new ClassData(ClassData.Package.OTHER, meth);
2386 final int C2 = builder.methodref;
2387 final int C1 = builder.addClass(withDef);
2388 builder.hier.addInherit(C1, C2);
2389 builder.objectref = C1;
2390 },
2391 /* Case 12: Objectref has package private def in other package.
2392 *
2393 * C2[](*) = mref
2394 * Other.C1[C2](pack) = oref
2395 */
2396 (final SelectionResolutionTestCase.Builder builder) -> {
2397 final ClassData.Package pck =
2398 builder.classdata.get(builder.methodref).packageId;
2399 final ClassData oldexpected =
2400 builder.classdata.get(builder.expected);
2401 final MethodData meth =
2402 new MethodData(MethodData.Access.PACKAGE,
2403 MethodData.Context.INSTANCE);
2404 final ClassData withDef =
2405 new ClassData(ClassData.Package.OTHER, meth);
2406 final int C2 = builder.methodref;
2407 final int C1 = builder.addClass(withDef);
2408 builder.hier.addInherit(C1, C2);
2409 builder.objectref = C1;
2410 },
2411 /* Case 13: Objectref has protected def in other package.
2412 *
2413 * C2[](*) = mref
2414 * Other.C1[C2](prot) = oref
2415 */
2416 (final SelectionResolutionTestCase.Builder builder) -> {
2417 final ClassData.Package pck =
2418 builder.classdata.get(builder.methodref).packageId;
2419 final ClassData oldexpected =
2420 builder.classdata.get(builder.expected);
2421 final MethodData meth =
2422 new MethodData(MethodData.Access.PROTECTED,
2423 MethodData.Context.INSTANCE);
2424 final ClassData withDef =
2425 new ClassData(ClassData.Package.OTHER, meth);
2426 final int C2 = builder.methodref;
2427 final int C1 = builder.addClass(withDef);
2428 builder.hier.addInherit(C1, C2);
2429 builder.objectref = C1;
2430 },
2431 /* Case 14: Objectref's super has a public def in other package.
2432 *
2433 * C3[*](*) = mref
2434 * Other.C2[C3](pub) = expected
2435 * C1[C2]() = oref
2436 */
2437 (final SelectionResolutionTestCase.Builder builder) -> {
2438 final ClassData.Package pck =
2439 builder.classdata.get(builder.methodref).packageId;
2440 final ClassData oldexpected =
2441 builder.classdata.get(builder.expected);
2442 final MethodData meth =
2443 new MethodData(MethodData.Access.PUBLIC,
2444 MethodData.Context.INSTANCE);
2445 final ClassData withDef =
2446 new ClassData(ClassData.Package.OTHER, meth);
2447 final int C3 = builder.methodref;
2448 final int C2 = builder.addClass(withDef);
2449 final int C1 = builder.addClass(emptyClass(pck));
2450 builder.hier.addInherit(C2, C3);
2451 builder.hier.addInherit(C1, C2);
2452 builder.objectref = C1;
2453 },
2454 /* Case 15: Objectref's super has a package
2455 * private def in other package.
2456 *
2457 * C3[*](*) = mref
2458 * Other.C2[C3](pack) = expected
2459 * C1[C2]() = oref
2460 */
2461 (final SelectionResolutionTestCase.Builder builder) -> {
2462 final ClassData.Package pck =
2463 builder.classdata.get(builder.methodref).packageId;
2464 final ClassData oldexpected =
2465 builder.classdata.get(builder.expected);
2466 final MethodData meth =
2467 new MethodData(MethodData.Access.PACKAGE,
2468 MethodData.Context.INSTANCE);
2469 final ClassData withDef =
2470 new ClassData(ClassData.Package.OTHER, meth);
2471 final int C3 = builder.methodref;
2472 final int C2 = builder.addClass(withDef);
2473 final int C1 = builder.addClass(emptyClass(pck));
2474 builder.hier.addInherit(C2, C3);
2475 builder.hier.addInherit(C1, C2);
2476 builder.objectref = C1;
2477 },
2478 /* Case 16: Objectref's super has a protected def
2479 * in other package.
2480 *
2481 * C3[*](*) = mref
2482 * Other.C2[C3](pack) = expected
2483 * C1[C2]() = oref
2484 */
2485 (final SelectionResolutionTestCase.Builder builder) -> {
2486 final ClassData.Package pck =
2487 builder.classdata.get(builder.methodref).packageId;
2488 final ClassData oldexpected =
2489 builder.classdata.get(builder.expected);
2490 final MethodData meth =
2491 new MethodData(MethodData.Access.PROTECTED,
2492 MethodData.Context.INSTANCE);
2493 final ClassData withDef =
2494 new ClassData(ClassData.Package.OTHER, meth);
2495 final int C3 = builder.methodref;
2496 final int C2 = builder.addClass(withDef);
2497 final int C1 = builder.addClass(emptyClass(pck));
2498 builder.hier.addInherit(C2, C3);
2499 builder.hier.addInherit(C1, C2);
2500 builder.objectref = C1;
2501 },
2502 /* Case 17: Transitive override.
2503 *
2504 * C3[*](*) = mref
2505 * C2[C3](pub)
2506 * Other.C1[C2](pack) = oref, expected
2507 */
2508 (final SelectionResolutionTestCase.Builder builder) -> {
2509 final ClassData.Package pck =
2510 builder.classdata.get(builder.expected).packageId;
2511 final ClassData oldexpected =
2512 builder.classdata.get(builder.expected);
2513 final MethodData meth =
2514 new MethodData(MethodData.Access.PUBLIC,
2515 MethodData.Context.INSTANCE);
2516 final MethodData packmeth =
2517 new MethodData(MethodData.Access.PACKAGE,
2518 MethodData.Context.INSTANCE);
2519 final ClassData withPubDef = new ClassData(pck, meth);
2520 final ClassData withPackDef =
2521 new ClassData(ClassData.Package.OTHER, packmeth);
2522 final int C3 = builder.methodref;
2523 final int C2 = builder.addClass(withPubDef);
2524 final int C1 = builder.addClass(withPackDef);
2525 builder.hier.addInherit(C2, C3);
2526 builder.hier.addInherit(C1, C2);
2527 builder.objectref = C1;
2528 builder.expected = C1;
2529 },
2530 /* Case 18: Objectref's has a public def in other
2531 * package, skip private.
2532 *
2533 * C3[*](*) = mref
2534 * Other.C2[C3](priv)
2535 * C1[C2](pub) = oref, expected
2536 */
2537 (final SelectionResolutionTestCase.Builder builder) -> {
2538 final ClassData.Package pck =
2539 builder.classdata.get(builder.methodref).packageId;
2540 final ClassData oldexpected =
2541 builder.classdata.get(builder.expected);
2542 final MethodData meth =
2543 new MethodData(MethodData.Access.PUBLIC,
2544 MethodData.Context.INSTANCE);
2545 final ClassData withDef =
2546 new ClassData(ClassData.Package.OTHER, meth);
2547 final MethodData privmeth =
2548 new MethodData(MethodData.Access.PRIVATE,
2549 MethodData.Context.INSTANCE);
2550 final ClassData withPrivDef =
2551 new ClassData(pck, privmeth);
2552 final int C3 = builder.methodref;
2553 final int C2 = builder.addClass(withPrivDef);
2554 final int C1 = builder.addClass(withDef);
2555 builder.hier.addInherit(C2, C3);
2556 builder.hier.addInherit(C1, C2);
2557 builder.objectref = C1;
2558 },
2559 /* Case 19: Objectref's has a package private def in other
2560 * package, skip private.
2561 *
2562 * C3[*](*) = mref
2563 * Other.C2[C3](priv)
2564 * C1[C2](pack) = oref, expected
2565 */
2566 (final SelectionResolutionTestCase.Builder builder) -> {
2567 final ClassData.Package pck =
2568 builder.classdata.get(builder.methodref).packageId;
2569 final ClassData oldexpected =
2570 builder.classdata.get(builder.expected);
2571 final MethodData meth =
2572 new MethodData(MethodData.Access.PACKAGE,
2573 MethodData.Context.INSTANCE);
2574 final ClassData withDef =
2575 new ClassData(ClassData.Package.OTHER, meth);
2576 final MethodData privmeth =
2577 new MethodData(MethodData.Access.PRIVATE,
2578 MethodData.Context.INSTANCE);
2579 final ClassData withPrivDef =
2580 new ClassData(pck, privmeth);
2581 final int C3 = builder.methodref;
2582 final int C2 = builder.addClass(withPrivDef);
2583 final int C1 = builder.addClass(withDef);
2584 builder.hier.addInherit(C2, C3);
2585 builder.hier.addInherit(C1, C2);
2586 builder.objectref = C1;
2587 },
2588 /* Case 20: Objectref's has a protected def in other
2589 * package, skip private.
2590 *
2591 * C3[*](*) = mref
2592 * Other.C2[C3](priv)
2593 * C1[C2](pro) = oref, expected
2594 */
2595 (final SelectionResolutionTestCase.Builder builder) -> {
2596 final ClassData.Package pck =
2597 builder.classdata.get(builder.methodref).packageId;
2598 final ClassData oldexpected =
2599 builder.classdata.get(builder.expected);
2600 final MethodData meth =
2601 new MethodData(MethodData.Access.PROTECTED,
2602 MethodData.Context.INSTANCE);
2603 final ClassData withDef =
2604 new ClassData(ClassData.Package.OTHER, meth);
2605 final MethodData privmeth =
2606 new MethodData(MethodData.Access.PRIVATE,
2607 MethodData.Context.INSTANCE);
2608 final ClassData withPrivDef =
2609 new ClassData(pck, privmeth);
2610 final int C3 = builder.methodref;
2611 final int C2 = builder.addClass(withPrivDef);
2612 final int C1 = builder.addClass(withDef);
2613 builder.hier.addInherit(C2, C3);
2614 builder.hier.addInherit(C1, C2);
2615 builder.objectref = C1;
2616 },
2617 /* Case 21: Objectref's super has a public def in other
2618 * package, skip private.
2619 *
2620 * C3[*](*) = mref
2621 * Other.C2[C3](pub) = expected
2622 * C1[C2](priv) = oref
2623 */
2624 (final SelectionResolutionTestCase.Builder builder) -> {
2625 final ClassData.Package pck =
2626 builder.classdata.get(builder.methodref).packageId;
2627 final ClassData oldexpected =
2628 builder.classdata.get(builder.expected);
2629 final MethodData meth =
2630 new MethodData(MethodData.Access.PUBLIC,
2631 MethodData.Context.INSTANCE);
2632 final ClassData withDef =
2633 new ClassData(ClassData.Package.OTHER, meth);
2634 final MethodData privmeth =
2635 new MethodData(MethodData.Access.PRIVATE,
2636 MethodData.Context.INSTANCE);
2637 final ClassData withPrivDef =
2638 new ClassData(pck, privmeth);
2639 final int C3 = builder.methodref;
2640 final int C2 = builder.addClass(withDef);
2641 final int C1 = builder.addClass(withPrivDef);
2642 builder.hier.addInherit(C2, C3);
2643 builder.hier.addInherit(C1, C2);
2644 builder.objectref = C1;
2645 },
2646 /* Case 22: Objectref's superhas a package private
2647 * def in other package, skip private.
2648 *
2649 * C3[*](*) = mref
2650 * Other.C2[C3](pack) = expected
2651 * C1[C2](priv) = oref
2652 */
2653 (final SelectionResolutionTestCase.Builder builder) -> {
2654 final ClassData.Package pck =
2655 builder.classdata.get(builder.methodref).packageId;
2656 final ClassData oldexpected =
2657 builder.classdata.get(builder.expected);
2658 final MethodData meth =
2659 new MethodData(MethodData.Access.PACKAGE,
2660 MethodData.Context.INSTANCE);
2661 final ClassData withDef =
2662 new ClassData(ClassData.Package.OTHER, meth);
2663 final MethodData privmeth =
2664 new MethodData(MethodData.Access.PRIVATE,
2665 MethodData.Context.INSTANCE);
2666 final ClassData withPrivDef =
2667 new ClassData(pck, privmeth);
2668 final int C3 = builder.methodref;
2669 final int C2 = builder.addClass(withDef);
2670 final int C1 = builder.addClass(withPrivDef);
2671 builder.hier.addInherit(C2, C3);
2672 builder.hier.addInherit(C1, C2);
2673 builder.objectref = C1;
2674 },
2675 /* Case 23: Objectref's super has a protected def
2676 * in other package, skip private.
2677 *
2678 * C3[*](*) = mref
2679 * Other.C2[C3](pro) = expected
2680 * C1[C2](priv) = oref
2681 */
2682 (final SelectionResolutionTestCase.Builder builder) -> {
2683 final ClassData.Package pck =
2684 builder.classdata.get(builder.methodref).packageId;
2685 final ClassData oldexpected =
2686 builder.classdata.get(builder.expected);
2687 final MethodData meth =
2688 new MethodData(MethodData.Access.PROTECTED,
2689 MethodData.Context.INSTANCE);
2690 final ClassData withDef =
2691 new ClassData(ClassData.Package.OTHER, meth);
2692 final MethodData privmeth =
2693 new MethodData(MethodData.Access.PRIVATE,
2694 MethodData.Context.INSTANCE);
2695 final ClassData withPrivDef =
2696 new ClassData(pck, privmeth);
2697 final int C3 = builder.methodref;
2698 final int C2 = builder.addClass(withPrivDef);
2699 final int C1 = builder.addClass(withDef);
2700 builder.hier.addInherit(C2, C3);
2701 builder.hier.addInherit(C1, C2);
2702 builder.objectref = C1;
2703 },
2704 /* Case 24: Transitive override, skip private in between.
2705 *
2706 * C4[*](*) = mref
2707 * C3[C4](pub)
2708 * C2[C3](priv)
2709 * Other.C1[C2](pack) = oref, expected
2710 */
2711 (final SelectionResolutionTestCase.Builder builder) -> {
2712 final ClassData.Package pck =
2713 builder.classdata.get(builder.expected).packageId;
2714 final ClassData oldexpected =
2715 builder.classdata.get(builder.expected);
2716 final MethodData meth =
2717 new MethodData(MethodData.Access.PUBLIC,
2718 MethodData.Context.INSTANCE);
2719 final MethodData packmeth =
2720 new MethodData(MethodData.Access.PACKAGE,
2721 MethodData.Context.INSTANCE);
2722 final ClassData withPubDef = new ClassData(pck, meth);
2723 final ClassData withPackDef =
2724 new ClassData(ClassData.Package.OTHER, packmeth);
2725 final MethodData privmeth =
2726 new MethodData(MethodData.Access.PRIVATE,
2727 MethodData.Context.INSTANCE);
2728 final ClassData withPrivDef =
2729 new ClassData(pck, privmeth);
2730 final int C4 = builder.methodref;
2731 final int C3 = builder.addClass(withPubDef);
2732 final int C2 = builder.addClass(withPrivDef);
2733 final int C1 = builder.addClass(withPackDef);
2734 builder.hier.addInherit(C3, C4);
2735 builder.hier.addInherit(C2, C3);
2736 builder.hier.addInherit(C1, C2);
2737 builder.objectref = C1;
2738 builder.expected = C1;
2739 },
2740 /* Case 25: Transitive override, skip private in between.
2741 *
2742 * C4[*](*) = mref
2743 * C3[C4](pub)
2744 * Other.C2[C3](pack) = expected
2745 * C1[C2](pack) = oref
2746 */
2747 (final SelectionResolutionTestCase.Builder builder) -> {
2748 final ClassData.Package pck =
2749 builder.classdata.get(builder.expected).packageId;
2750 final ClassData oldexpected =
2751 builder.classdata.get(builder.expected);
2752 final MethodData meth =
2753 new MethodData(MethodData.Access.PUBLIC,
2754 MethodData.Context.INSTANCE);
2755 final MethodData packmeth =
2756 new MethodData(MethodData.Access.PACKAGE,
2757 MethodData.Context.INSTANCE);
2758 final ClassData withPubDef = new ClassData(pck, meth);
2759 final ClassData withPackDef =
2760 new ClassData(ClassData.Package.OTHER, packmeth);
2761 final MethodData privmeth =
2762 new MethodData(MethodData.Access.PRIVATE,
2763 MethodData.Context.INSTANCE);
2764 final ClassData withPrivDef =
2765 new ClassData(pck, privmeth);
2766 final int C4 = builder.methodref;
2767 final int C3 = builder.addClass(withPubDef);
2768 final int C2 = builder.addClass(withPackDef);
2769 final int C1 = builder.addClass(withPrivDef);
2770 builder.hier.addInherit(C3, C4);
2771 builder.hier.addInherit(C2, C3);
2772 builder.hier.addInherit(C1, C2);
2773 builder.objectref = C2;
2774 builder.expected = C2;
2775 });
2776
2777 public static final Template MethodrefSelectionResolvedIsIfaceNoOverride =
2778 new Template("MethodrefSelectionResolvedIsIfaceNoOverride",
2779 /* Trivial objectref.
2780 *
2781 * C[](*) = mref = oref
2782 */
2783 (builder) -> {
2784 builder.objectref = builder.methodref;
2785 },
2786 /* Case 1: Inherit from super.
2787 *
2788 * C2[](*) = mref
2789 * C1[C2]() = oref
2790 */
2791 (final SelectionResolutionTestCase.Builder builder) -> {
2792 final ClassData.Package pck =
2793 builder.classdata.get(builder.methodref).packageId;
2794 final int C2 = builder.methodref;
2795 final int C1 = builder.addClass(emptyClass(pck));
2796 builder.hier.addInherit(C1, C2);
2797 builder.objectref = C1;
2798 },
2799 /* Case 2: Objectref has private def.
2800 *
2801 * C2[](*) = mref
2802 * C1[C2](priv) = oref
2803 */
2804 (final SelectionResolutionTestCase.Builder builder) -> {
2805 final ClassData.Package pck =
2806 builder.classdata.get(builder.methodref).packageId;
2807 final ClassData oldexpected =
2808 builder.classdata.get(builder.expected);
2809 final MethodData meth =
2810 new MethodData(MethodData.Access.PRIVATE,
2811 MethodData.Context.INSTANCE);
2812 final ClassData withDef = new ClassData(pck, meth);
2813 final int C2 = builder.methodref;
2814 final int C1 = builder.addClass(withDef);
2815 builder.hier.addInherit(C1, C2);
2816 builder.objectref = C1;
2817 },
2818 /* Case 3: Objectref has static def.
2819 *
2820 * C2[](*) = mref
2821 * C1[C2](stat) = oref
2822 */
2823 (final SelectionResolutionTestCase.Builder builder) -> {
2824 final ClassData.Package pck =
2825 builder.classdata.get(builder.methodref).packageId;
2826 final ClassData oldexpected =
2827 builder.classdata.get(builder.expected);
2828 final MethodData meth =
2829 new MethodData(MethodData.Access.PUBLIC,
2830 MethodData.Context.STATIC);
2831 final ClassData withDef = new ClassData(pck, meth);
2832 final int C2 = builder.methodref;
2833 final int C1 = builder.addClass(withDef);
2834 builder.hier.addInherit(C1, C2);
2835 builder.objectref = C1;
2836 },
2837 /* Case 4: Overlapping.
2838 *
2839 * I[*](res) = expected
2840 * C2[*](*) = mref
2841 * C1[C2,I]() = oref
2842 */
2843 (final SelectionResolutionTestCase.Builder builder) -> {
2844 final ClassData.Package pck =
2845 builder.classdata.get(builder.methodref).packageId;
2846 final int C2 = builder.methodref;
2847 final int I = builder.expected;
2848 final int C1 = builder.addClass(emptyClass(pck));
2849 builder.hier.addInherit(C1, C2);
2850 builder.hier.addInherit(C1, I);
2851 builder.objectref = C1;
2852 },
2853 /* Case 5: Overlapping with new interface.
2854 *
2855 * I2[*](res) = expected
2856 * C2[*](*) = mref, I1[I2]()
2857 * C1[C2,I2]() = oref
2858 */
2859 (final SelectionResolutionTestCase.Builder builder) -> {
2860 final ClassData.Package pck =
2861 builder.classdata.get(builder.methodref).packageId;
2862 final int C2 = builder.methodref;
2863 final int I2 = builder.expected;
2864 final int I1 = builder.addInterface(emptyClass(pck));
2865 final int C1 = builder.addClass(emptyClass(pck));
2866 builder.hier.addInherit(C1, C2);
2867 builder.hier.addInherit(C1, I1);
2868 builder.hier.addInherit(I1, I2);
2869 builder.objectref = C1;
2870 },
2871 /* Case 6: Overlapping with new interface with private def.
2872 *
2873 * I2[*](res) = expected
2874 * C2[*](*) = mref, I1[I2](priv)
2875 * C1[C2,I2]() = oref
2876 */
2877 (final SelectionResolutionTestCase.Builder builder) -> {
2878 final ClassData.Package pck =
2879 builder.classdata.get(builder.methodref).packageId;
2880 final MethodData meth =
2881 new MethodData(MethodData.Access.PRIVATE,
2882 MethodData.Context.INSTANCE);
2883 final ClassData withPrivDef =
2884 new ClassData(pck, meth);
2885 final int C2 = builder.methodref;
2886 final int I2 = builder.expected;
2887 final int I1 = builder.addInterface(withPrivDef);
2888 final int C1 = builder.addClass(emptyClass(pck));
2889 builder.hier.addInherit(C1, C2);
2890 builder.hier.addInherit(C1, I1);
2891 builder.hier.addInherit(I1, I2);
2892 builder.objectref = C1;
2893 },
2894 /* Case 7: Overlapping with new interface with static def.
2895 *
2896 * I2[*](res) = expected
2897 * C2[*](*) = mref, I1[I2](stat)
2898 * C1[C2,I2]() = oref
2899 */
2900 (final SelectionResolutionTestCase.Builder builder) -> {
2901 final ClassData.Package pck =
2902 builder.classdata.get(builder.methodref).packageId;
2903 final MethodData meth =
2904 new MethodData(MethodData.Access.PUBLIC,
2905 MethodData.Context.STATIC);
2906 final ClassData withStatDef =
2907 new ClassData(pck, meth);
2908 final int C2 = builder.methodref;
2909 final int I2 = builder.expected;
2910 final int I1 = builder.addInterface(withStatDef);
2911 final int C1 = builder.addClass(emptyClass(pck));
2912 builder.hier.addInherit(C1, C2);
2913 builder.hier.addInherit(C1, I1);
2914 builder.hier.addInherit(I1, I2);
2915 builder.objectref = C1;
2916 },
2917 /* Case 8: Objectref's super has a private def.
2918 *
2919 * C3[*](*) = mref
2920 * C2[C3](priv)
2921 * C1[C2]() = oref
2922 */
2923 (final SelectionResolutionTestCase.Builder builder) -> {
2924 final ClassData.Package pck =
2925 builder.classdata.get(builder.methodref).packageId;
2926 final ClassData oldexpected =
2927 builder.classdata.get(builder.expected);
2928 final MethodData meth =
2929 new MethodData(MethodData.Access.PRIVATE,
2930 MethodData.Context.INSTANCE);
2931 final ClassData withDef =
2932 new ClassData(pck, meth);
2933 final int C3 = builder.methodref;
2934 final int C2 = builder.addClass(withDef);
2935 final int C1 = builder.addClass(emptyClass(pck));
2936 builder.hier.addInherit(C2, C3);
2937 builder.hier.addInherit(C1, C2);
2938 builder.objectref = C1;
2939 },
2940 /* Case 9: Objectref's super has a static def.
2941 *
2942 * C3[*](*) = mref
2943 * C2[C3](stat)
2944 * C1[C2]() = oref
2945 */
2946 (final SelectionResolutionTestCase.Builder builder) -> {
2947 final ClassData.Package pck =
2948 builder.classdata.get(builder.methodref).packageId;
2949 final ClassData oldexpected =
2950 builder.classdata.get(builder.expected);
2951 final MethodData meth =
2952 new MethodData(MethodData.Access.PUBLIC,
2953 MethodData.Context.STATIC);
2954 final ClassData withDef =
2955 new ClassData(pck, meth);
2956 final int C3 = builder.methodref;
2957 final int C2 = builder.addClass(withDef);
2958 final int C1 = builder.addClass(emptyClass(pck));
2959 builder.hier.addInherit(C2, C3);
2960 builder.hier.addInherit(C1, C2);
2961 builder.objectref = C1;
2962 },
2963 /* Case 10: Overlap with objectref's super.
2964 *
2965 * I[*](res) = expected
2966 * C3[](*) = mref
2967 * C2[C3,I]()
2968 * C1[C2]() = oref
2969 */
2970 (final SelectionResolutionTestCase.Builder builder) -> {
2971 final ClassData.Package pck =
2972 builder.classdata.get(builder.methodref).packageId;
2973 final int C3 = builder.methodref;
2974 final int C2 = builder.addClass(emptyClass(pck));
2975 final int I = builder.expected;
2976 final int C1 = builder.addClass(emptyClass(pck));
2977 builder.hier.addInherit(C2, C3);
2978 builder.hier.addInherit(C1, C2);
2979 builder.hier.addInherit(C2, I);
2980 builder.objectref = C1;
2981 },
2982 /* Case 11: Overlap with objectref's super with new interface.
2983 *
2984 * I2[*](res) = expected
2985 * C3[](*) = mref, I1[I2]()
2986 * C2[C3,I1]()
2987 * C1[C2]() = oref
2988 */
2989 (final SelectionResolutionTestCase.Builder builder) -> {
2990 final ClassData.Package pck =
2991 builder.classdata.get(builder.methodref).packageId;
2992 final int C3 = builder.methodref;
2993 final int C2 = builder.addClass(emptyClass(pck));
2994 final int I2 = builder.expected;
2995 final int I1 = builder.addInterface(emptyClass(pck));
2996 final int C1 = builder.addClass(emptyClass(pck));
2997 builder.hier.addInherit(C2, C3);
2998 builder.hier.addInherit(C1, C2);
2999 builder.hier.addInherit(C2, I1);
3000 builder.hier.addInherit(I1, I2);
3001 builder.objectref = C1;
3002 },
3003 /* Case 12: Overlap with objectref's super with new
3004 * interface with private def.
3005 *
3006 * I2[*](res) = expected
3007 * C3[](*) = mref, I1[I2](priv)
3008 * C2[C3,I1]()
3009 * C1[C2]() = oref
3010 */
3011 (final SelectionResolutionTestCase.Builder builder) -> {
3012 final ClassData.Package pck =
3013 builder.classdata.get(builder.methodref).packageId;
3014 final MethodData meth =
3015 new MethodData(MethodData.Access.PRIVATE,
3016 MethodData.Context.INSTANCE);
3017 final ClassData withPrivDef =
3018 new ClassData(pck, meth);
3019 final int C3 = builder.methodref;
3020 final int C2 = builder.addClass(emptyClass(pck));
3021 final int I2 = builder.expected;
3022 final int I1 = builder.addInterface(withPrivDef);
3023 final int C1 = builder.addClass(emptyClass(pck));
3024 builder.hier.addInherit(C2, C3);
3025 builder.hier.addInherit(C1, C2);
3026 builder.hier.addInherit(C2, I1);
3027 builder.hier.addInherit(I1, I2);
3028 builder.objectref = C1;
3029 },
3030 /* Case 13: Overlap with objectref's super with new
3031 * interface with static def.
3032 *
3033 * I2[*](res) = expected
3034 * C3[](*) = mref, I1[I2](stat)
3035 * C2[C3,I1]()
3036 * C1[C2]() = oref
3037 */
3038 (final SelectionResolutionTestCase.Builder builder) -> {
3039 final ClassData.Package pck =
3040 builder.classdata.get(builder.methodref).packageId;
3041 final MethodData meth =
3042 new MethodData(MethodData.Access.PUBLIC,
3043 MethodData.Context.STATIC);
3044 final ClassData withStatDef =
3045 new ClassData(pck, meth);
3046 final int C3 = builder.methodref;
3047 final int C2 = builder.addClass(emptyClass(pck));
3048 final int I2 = builder.expected;
3049 final int I1 = builder.addInterface(withStatDef);
3050 final int C1 = builder.addClass(emptyClass(pck));
3051 builder.hier.addInherit(C2, C3);
3052 builder.hier.addInherit(C1, C2);
3053 builder.hier.addInherit(C2, I1);
3054 builder.hier.addInherit(I1, I2);
3055 builder.objectref = C1;
3056 },
3057 /* Case 14: Overlap with objectref's super with new
3058 * interface double diamond.
3059 *
3060 * I3[*](res) = expected
3061 * C3[](*) = mref, I2[I3]()
3062 * C2[C3,I2](), I1[I2]()
3063 * C1[C2,I1]() = oref
3064 */
3065 (final SelectionResolutionTestCase.Builder builder) -> {
3066 final ClassData.Package pck =
3067 builder.classdata.get(builder.methodref).packageId;
3068 final int C3 = builder.methodref;
3069 final int C2 = builder.addClass(emptyClass(pck));
3070 final int I3 = builder.expected;
3071 final int I2 = builder.addInterface(emptyClass(pck));
3072 final int I1 = builder.addInterface(emptyClass(pck));
3073 final int C1 = builder.addClass(emptyClass(pck));
3074 builder.hier.addInherit(C2, C3);
3075 builder.hier.addInherit(C1, C2);
3076 builder.hier.addInherit(C1, I1);
3077 builder.hier.addInherit(C2, I2);
3078 builder.hier.addInherit(I1, I2);
3079 builder.objectref = C1;
3080 },
3081 /* Case 15: Overlapping with new interface with private def.
3082 *
3083 * C2[*](*) = mref, I1[](priv)
3084 * C1[C2,I2]() = oref
3085 */
3086 (final SelectionResolutionTestCase.Builder builder) -> {
3087 final ClassData.Package pck =
3088 builder.classdata.get(builder.methodref).packageId;
3089 final MethodData meth =
3090 new MethodData(MethodData.Access.PRIVATE,
3091 MethodData.Context.INSTANCE);
3092 final ClassData withPrivDef =
3093 new ClassData(pck, meth);
3094 final int C2 = builder.methodref;
3095 final int I1 = builder.addInterface(withPrivDef);
3096 final int C1 = builder.addClass(emptyClass(pck));
3097 builder.hier.addInherit(C1, C2);
3098 builder.hier.addInherit(C1, I1);
3099 builder.objectref = C1;
3100 },
3101 /* Case 16: Overlapping with new interface with static def.
3102 *
3103 * C2[*](*) = mref, I1[](stat)
3104 * C1[C2,I2]() = oref
3105 */
3106 (final SelectionResolutionTestCase.Builder builder) -> {
3107 final ClassData.Package pck =
3108 builder.classdata.get(builder.methodref).packageId;
3109 final MethodData meth =
3110 new MethodData(MethodData.Access.PUBLIC,
3111 MethodData.Context.STATIC);
3112 final ClassData withStatDef =
3113 new ClassData(pck, meth);
3114 final int C2 = builder.methodref;
3115 final int I1 = builder.addInterface(withStatDef);
3116 final int C1 = builder.addClass(emptyClass(pck));
3117 builder.hier.addInherit(C1, C2);
3118 builder.hier.addInherit(C1, I1);
3119 builder.objectref = C1;
3120 });
3121
3122 public static final Template MethodrefSelectionResolvedIsIface =
3123 new Template("MethodrefSelectionResolvedIsIface",
3124 MethodrefSelectionResolvedIsIfaceNoOverride,
3125 /* Case 17: Objectref overrides.
3126 *
3127 * C2[](*) = mref
3128 * C1[C2](res) = oref = expected
3129 */
3130 (final SelectionResolutionTestCase.Builder builder) -> {
3131 final ClassData.Package pck =
3132 builder.classdata.get(builder.methodref).packageId;
3133 final ClassData oldexpected =
3134 builder.classdata.get(builder.expected);
3135 final ClassData withDef =
3136 new ClassData(pck, oldexpected.methoddata);
3137 final int C2 = builder.methodref;
3138 final int C1 = builder.addClass(withDef);
3139 builder.hier.addInherit(C1, C2);
3140 builder.objectref = C1;
3141 builder.expected = C1;
3142 },
3143 /* Case 18: Overlapping with new interface overriding.
3144 *
3145 * I2[*](def) = old expected
3146 * C2[*](*) = mref, I1[I2](res) = expected
3147 * C1[C2,I2]() = oref
3148 */
3149 (final SelectionResolutionTestCase.Builder builder) -> {
3150 final ClassData.Package pck =
3151 builder.classdata.get(builder.methodref).packageId;
3152 final ClassData oldexpected =
3153 builder.classdata.get(builder.expected);
3154 final ClassData withDef =
3155 new ClassData(pck, oldexpected.methoddata);
3156 final int C2 = builder.methodref;
3157 final int I2 = builder.expected;
3158 final int I1 = builder.addInterface(withDef);
3159 final int C1 = builder.addClass(emptyClass(pck));
3160 builder.hier.addInherit(C1, C2);
3161 builder.hier.addInherit(C1, I1);
3162 builder.hier.addInherit(I1, I2);
3163 builder.objectref = C1;
3164 builder.expected = I1;
3165 },
3166 /* Case 19: Objectref's super overrides.
3167 *
3168 * C3[](*) = mref
3169 * C2[C3](res) = expected
3170 * C1[C2]() = oref
3171 */
3172 (final SelectionResolutionTestCase.Builder builder) -> {
3173 final ClassData.Package pck =
3174 builder.classdata.get(builder.methodref).packageId;
3175 final ClassData oldexpected =
3176 builder.classdata.get(builder.expected);
3177 final ClassData withDef =
3178 new ClassData(pck, oldexpected.methoddata);
3179 final int C3 = builder.methodref;
3180 final int C2 = builder.addClass(withDef);
3181 final int C1 = builder.addClass(emptyClass(pck));
3182 builder.hier.addInherit(C2, C3);
3183 builder.hier.addInherit(C1, C2);
3184 builder.objectref = C1;
3185 builder.expected = C2;
3186 },
3187 /* Case 20: Overlap with objectref's super with
3188 * new interface overriding.
3189 *
3190 * I2[*](def) = old expected
3191 * C3[](*) = mref, I1[I2](res) = expected
3192 * C2[C3,I1]()
3193 * C1[C2]() = oref
3194 */
3195 (final SelectionResolutionTestCase.Builder builder) -> {
3196 final ClassData.Package pck =
3197 builder.classdata.get(builder.methodref).packageId;
3198 final ClassData oldexpected =
3199 builder.classdata.get(builder.expected);
3200 final ClassData withDef =
3201 new ClassData(pck, oldexpected.methoddata);
3202 final int C3 = builder.methodref;
3203 final int C2 = builder.addClass(emptyClass(pck));
3204 final int I2 = builder.expected;
3205 final int I1 = builder.addInterface(withDef);
3206 final int C1 = builder.addClass(emptyClass(pck));
3207 builder.hier.addInherit(C2, C3);
3208 builder.hier.addInherit(C1, C2);
3209 builder.hier.addInherit(C2, I1);
3210 builder.hier.addInherit(I1, I2);
3211 builder.objectref = C1;
3212 builder.expected = I1;
3213 },
3214 /* Case 21: Overlap with objectref's super with new
3215 * interface double diamond, overriding.
3216 *
3217 * I3[*](def) = old expected
3218 * C3[](*) = mref, I2[I3](def)
3219 * C2[C3,I2](), I1[I2](res) = expected
3220 * C1[C2,I1]() = oref
3221 */
3222 (final SelectionResolutionTestCase.Builder builder) -> {
3223 final ClassData.Package pck =
3224 builder.classdata.get(builder.methodref).packageId;
3225 final ClassData oldexpected =
3226 builder.classdata.get(builder.expected);
3227 final ClassData withDef =
3228 new ClassData(pck, oldexpected.methoddata);
3229 final int C3 = builder.methodref;
3230 final int C2 = builder.addClass(emptyClass(pck));
3231 final int I3 = builder.expected;
3232 final int I2 = builder.addInterface(withDef);
3233 final int I1 = builder.addInterface(withDef);
3234 final int C1 = builder.addClass(emptyClass(pck));
3235 builder.hier.addInherit(C2, C3);
3236 builder.hier.addInherit(C1, C2);
3237 builder.hier.addInherit(C1, I1);
3238 builder.hier.addInherit(C2, I2);
3239 builder.hier.addInherit(I1, I2);
3240 builder.hier.addInherit(I2, I3);
3241 builder.objectref = C1;
3242 builder.expected = I1;
3243 },
3244 /* Case 22: Objectref's super overrides, skip private.
3245 *
3246 * C3[](*) = mref
3247 * C2[C3](res) = expected
3248 * C1[C2](priv) = oref
3249 */
3250 (final SelectionResolutionTestCase.Builder builder) -> {
3251 final ClassData.Package pck =
3252 builder.classdata.get(builder.methodref).packageId;
3253 final ClassData oldexpected =
3254 builder.classdata.get(builder.expected);
3255 final MethodData meth =
3256 new MethodData(MethodData.Access.PRIVATE,
3257 MethodData.Context.INSTANCE);
3258 final ClassData withPrivDef =
3259 new ClassData(pck, meth);
3260 final ClassData withDef =
3261 new ClassData(pck, oldexpected.methoddata);
3262 final int C3 = builder.methodref;
3263 final int C2 = builder.addClass(withDef);
3264 final int C1 = builder.addClass(withPrivDef);
3265 builder.hier.addInherit(C2, C3);
3266 builder.hier.addInherit(C1, C2);
3267 builder.objectref = C1;
3268 builder.expected = C2;
3269 },
3270 /* Case 23: Objectref's super overrides, skip static.
3271 *
3272 * C3[](*) = mref
3273 * C2[C3](res) = expected
3274 * C1[C2](stat) = oref
3275 */
3276 (final SelectionResolutionTestCase.Builder builder) -> {
3277 final ClassData.Package pck =
3278 builder.classdata.get(builder.methodref).packageId;
3279 final ClassData oldexpected =
3280 builder.classdata.get(builder.expected);
3281 final MethodData meth =
3282 new MethodData(MethodData.Access.PUBLIC,
3283 MethodData.Context.STATIC);
3284 final ClassData withStatDef =
3285 new ClassData(pck, meth);
3286 final ClassData withDef =
3287 new ClassData(pck, oldexpected.methoddata);
3288 final int C3 = builder.methodref;
3289 final int C2 = builder.addClass(withDef);
3290 final int C1 = builder.addClass(withStatDef);
3291 builder.hier.addInherit(C2, C3);
3292 builder.hier.addInherit(C1, C2);
3293 builder.objectref = C1;
3294 builder.expected = C2;
3295 },
3296 /* Case 24: Overlap with objectref's super with new
3297 * interface double diamond, overriding, skip private.
3298 *
3299 * I3[*](def) = old expected
3300 * C3[](*) = mref, I2[I3](res) = expected
3301 * C2[C3,I2](), I1[I2](priv)
3302 * C1[C2,I1]() = oref
3303 */
3304 (final SelectionResolutionTestCase.Builder builder) -> {
3305 final ClassData.Package pck =
3306 builder.classdata.get(builder.methodref).packageId;
3307 final ClassData oldexpected =
3308 builder.classdata.get(builder.expected);
3309 final ClassData withDef =
3310 new ClassData(pck, oldexpected.methoddata);
3311 final MethodData meth =
3312 new MethodData(MethodData.Access.PRIVATE,
3313 MethodData.Context.INSTANCE);
3314 final ClassData withPrivDef =
3315 new ClassData(pck, meth);
3316 final int C3 = builder.methodref;
3317 final int C2 = builder.addClass(emptyClass(pck));
3318 final int I3 = builder.expected;
3319 final int I2 = builder.addInterface(withDef);
3320 final int I1 = builder.addInterface(withPrivDef);
3321 final int C1 = builder.addClass(emptyClass(pck));
3322 builder.hier.addInherit(C2, C3);
3323 builder.hier.addInherit(C1, C2);
3324 builder.hier.addInherit(C1, I1);
3325 builder.hier.addInherit(C2, I2);
3326 builder.hier.addInherit(I1, I2);
3327 builder.hier.addInherit(I2, I3);
3328 builder.objectref = C1;
3329 builder.expected = I2;
3330 },
3331 /* Case 25: Overlap with objectref's super with new
3332 * interface double diamond, overriding, skip static.
3333 *
3334 * I3[*](def) = old expected
3335 * C3[](*) = mref, I2[I3](res) = expected
3336 * C2[C3,I2](), I1[I2](stat)
3337 * C1[C2,I1]() = oref
3338 */
3339 (final SelectionResolutionTestCase.Builder builder) -> {
3340 final ClassData.Package pck =
3341 builder.classdata.get(builder.methodref).packageId;
3342 final ClassData oldexpected =
3343 builder.classdata.get(builder.expected);
3344 final ClassData withDef =
3345 new ClassData(pck, oldexpected.methoddata);
3346 final MethodData meth =
3347 new MethodData(MethodData.Access.PUBLIC,
3348 MethodData.Context.STATIC);
3349 final ClassData withStatDef =
3350 new ClassData(pck, meth);
3351 final int C3 = builder.methodref;
3352 final int C2 = builder.addClass(emptyClass(pck));
3353 final int I3 = builder.expected;
3354 final int I2 = builder.addInterface(withDef);
3355 final int I1 = builder.addInterface(withStatDef);
3356 final int C1 = builder.addClass(emptyClass(pck));
3357 builder.hier.addInherit(C2, C3);
3358 builder.hier.addInherit(C1, C2);
3359 builder.hier.addInherit(C1, I1);
3360 builder.hier.addInherit(C2, I2);
3361 builder.hier.addInherit(I1, I2);
3362 builder.hier.addInherit(I2, I3);
3363 builder.objectref = C1;
3364 builder.expected = I2;
3365 },
3366 /* Case 26: Skip interface method after class overrides.
3367 *
3368 * C3[](*) = mref
3369 * C2[C3](res) = expected, I[](def)
3370 * C1[C2, I]() = oref
3371 */
3372 (final SelectionResolutionTestCase.Builder builder) -> {
3373 final ClassData.Package pck =
3374 builder.classdata.get(builder.methodref).packageId;
3375 final ClassData oldexpected =
3376 builder.classdata.get(builder.expected);
3377 final ClassData withDef =
3378 new ClassData(pck, oldexpected.methoddata);
3379 final int C3 = builder.methodref;
3380 final int C2 = builder.addClass(withDef);
3381 final int C1 = builder.addClass(emptyClass(pck));
3382 final int I = builder.addInterface(withDef);
3383 builder.hier.addInherit(C2, C3);
3384 builder.hier.addInherit(C1, C2);
3385 builder.hier.addInherit(C1, I);
3386 builder.objectref = C1;
3387 builder.expected = C2;
3388 },
3389 /* Case 27: Skip interface method after class overrides.
3390 *
3391 * C3[](*) = mref, I[](def)
3392 * C2[C3,I](res) = expected
3393 * C1[C2]() = oref
3394 */
3395 (final SelectionResolutionTestCase.Builder builder) -> {
3396 final ClassData.Package pck =
3397 builder.classdata.get(builder.methodref).packageId;
3398 final ClassData oldexpected =
3399 builder.classdata.get(builder.expected);
3400 final ClassData withDef =
3401 new ClassData(pck, oldexpected.methoddata);
3402 final int C3 = builder.methodref;
3403 final int C2 = builder.addClass(withDef);
3404 final int C1 = builder.addClass(emptyClass(pck));
3405 final int I = builder.addInterface(withDef);
3406 builder.hier.addInherit(C2, C3);
3407 builder.hier.addInherit(C1, C2);
3408 builder.hier.addInherit(C2, I);
3409 builder.objectref = C1;
3410 builder.expected = C2;
3411 },
3412 /* Case 28: Overlap with objectref's super with new
3413 * interface double diamond, overriding.
3414 *
3415 * I3[*](def) = old expected
3416 * C3[](*) = mref, I2[I3](def)
3417 * C2[C3,I2](res) = expected, I1[I2](def) = expected
3418 * C1[C2,I1]() = oref
3419 */
3420 (final SelectionResolutionTestCase.Builder builder) -> {
3421 final ClassData.Package pck =
3422 builder.classdata.get(builder.methodref).packageId;
3423 final ClassData oldexpected =
3424 builder.classdata.get(builder.expected);
3425 final ClassData withDef =
3426 new ClassData(pck, oldexpected.methoddata);
3427 final int C3 = builder.methodref;
3428 final int C2 = builder.addClass(withDef);
3429 final int I3 = builder.expected;
3430 final int I2 = builder.addInterface(withDef);
3431 final int I1 = builder.addInterface(withDef);
3432 final int C1 = builder.addClass(emptyClass(pck));
3433 builder.hier.addInherit(C2, C3);
3434 builder.hier.addInherit(C1, C2);
3435 builder.hier.addInherit(C1, I1);
3436 builder.hier.addInherit(C2, I2);
3437 builder.hier.addInherit(I1, I2);
3438 builder.hier.addInherit(I2, I3);
3439 builder.objectref = C1;
3440 builder.expected = C2;
3441 });
3442
3443 public static final Template IfaceMethodrefSelectionNoOverride =
3444 new Template("IfaceMethodrefSelectionNoOverride",
3445 /* Case 1: Inherit from super.
3446 *
3447 * I[](*) = mref
3448 * C[I]() = oref
3449 */
3450 (final SelectionResolutionTestCase.Builder builder) -> {
3451 final ClassData.Package pck =
3452 builder.classdata.get(builder.methodref).packageId;
3453 final int I = builder.methodref;
3454 final int C = builder.addClass(emptyClass(pck));
3455 builder.hier.addInherit(C, I);
3456 builder.objectref = C;
3457 },
3458 /* Case 2: Objectref has static def
3459 *
3460 * I[](*) = mref
3461 * C[I](stat) = oref
3462 */
3463 (final SelectionResolutionTestCase.Builder builder) -> {
3464 final ClassData.Package pck =
3465 builder.classdata.get(builder.methodref).packageId;
3466 final MethodData meth =
3467 new MethodData(MethodData.Access.PUBLIC,
3468 MethodData.Context.STATIC);
3469 final ClassData withStatDef =
3470 new ClassData(pck, meth);
3471 final int I = builder.methodref;
3472 final int C = builder.addClass(withStatDef);
3473 builder.hier.addInherit(C, I);
3474 builder.objectref = C;
3475 },
3476 /* Case 3: Diamond, methodref at top.
3477 *
3478 * I3[](*) = mref
3479 * I1[I3](), I2[I3]()
3480 * C[I1,I2]() = oref
3481 */
3482 (final SelectionResolutionTestCase.Builder builder) -> {
3483 final ClassData.Package pck =
3484 builder.classdata.get(builder.expected).packageId;
3485 final int I3 = builder.methodref;
3486 final int I2 = builder.addInterface(emptyClass(pck));
3487 final int I1 = builder.addInterface(emptyClass(pck));
3488 final int C = builder.addClass(emptyClass(pck));
3489 builder.hier.addInherit(C, I1);
3490 builder.hier.addInherit(C, I2);
3491 builder.hier.addInherit(I1, I3);
3492 builder.hier.addInherit(I2, I3);
3493 builder.objectref = C;
3494 },
3495 /* Case 4: Diamond, methodref at top, skip private def
3496 *
3497 * I3[](*) = mref
3498 * I1[I3](), I2[I3](priv)
3499 * C[I1,I2]() = oref
3500 */
3501 (final SelectionResolutionTestCase.Builder builder) -> {
3502 final ClassData.Package pck =
3503 builder.classdata.get(builder.expected).packageId;
3504 final MethodData meth =
3505 new MethodData(MethodData.Access.PRIVATE,
3506 MethodData.Context.INSTANCE);
3507 final ClassData withPrivDef =
3508 new ClassData(pck, meth);
3509 final int I3 = builder.methodref;
3510 final int I2 = builder.addInterface(withPrivDef);
3511 final int I1 = builder.addInterface(emptyClass(pck));
3512 final int C = builder.addClass(emptyClass(pck));
3513 builder.hier.addInherit(C, I1);
3514 builder.hier.addInherit(C, I2);
3515 builder.hier.addInherit(I1, I3);
3516 builder.hier.addInherit(I2, I3);
3517 builder.objectref = C;
3518 },
3519 /* Case 5: Diamond, methodref at top, skip static def
3520 *
3521 * I3[](*) = mref
3522 * I1[I3](), I2[I3](stat)
3523 * C[I1,I2]() = oref
3524 */
3525 (final SelectionResolutionTestCase.Builder builder) -> {
3526 final ClassData.Package pck =
3527 builder.classdata.get(builder.expected).packageId;
3528 final MethodData meth =
3529 new MethodData(MethodData.Access.PUBLIC,
3530 MethodData.Context.STATIC);
3531 final ClassData withStatDef =
3532 new ClassData(pck, meth);
3533 final int I3 = builder.methodref;
3534 final int I2 = builder.addInterface(withStatDef);
3535 final int I1 = builder.addInterface(emptyClass(pck));
3536 final int C = builder.addClass(emptyClass(pck));
3537 builder.hier.addInherit(C, I1);
3538 builder.hier.addInherit(C, I2);
3539 builder.hier.addInherit(I1, I3);
3540 builder.hier.addInherit(I2, I3);
3541 builder.objectref = C;
3542 },
3543 /* Case 6: Diamond, overlap with resolution.
3544 *
3545 * I3[](res) = expected
3546 * I1[I3](), I2[](*) = mref
3547 * C[I1,I2]() = oref
3548 */
3549 (final SelectionResolutionTestCase.Builder builder) -> {
3550 final ClassData.Package pck =
3551 builder.classdata.get(builder.expected).packageId;
3552 final int I3 = builder.expected;
3553 final int I2 = builder.methodref;
3554 final int I1 = builder.addInterface(emptyClass(pck));
3555 final int C = builder.addClass(emptyClass(pck));
3556 builder.hier.addInherit(C, I1);
3557 builder.hier.addInherit(C, I2);
3558 builder.hier.addInherit(I1, I3);
3559 builder.objectref = C;
3560 },
3561 /* Case 7: Diamond, with superclass, expected at top.
3562 *
3563 * I2[](*) = mref
3564 * C2[I2](), I1[I2]()
3565 * C1[I1,C2]() = oref
3566 */
3567 (final SelectionResolutionTestCase.Builder builder) -> {
3568 final ClassData.Package pck =
3569 builder.classdata.get(builder.expected).packageId;
3570 final int I2 = builder.methodref;
3571 final int I1 = builder.addInterface(emptyClass(pck));
3572 final int C2 = builder.addClass(emptyClass(pck));
3573 final int C1 = builder.addClass(emptyClass(pck));
3574 builder.hier.addInherit(C1, I1);
3575 builder.hier.addInherit(C1, C2);
3576 builder.hier.addInherit(I1, I2);
3577 builder.hier.addInherit(C2, I2);
3578 builder.objectref = C1;
3579 },
3580 /* Case 8: Diamond, with superclass, expected at top,
3581 * class has static def.
3582 *
3583 * I2[](*) = mref
3584 * C2[I2](stat), I1[I2]()
3585 * C1[I1,C2]() = oref
3586 */
3587 (final SelectionResolutionTestCase.Builder builder) -> {
3588 final ClassData.Package pck =
3589 builder.classdata.get(builder.expected).packageId;
3590 final MethodData meth =
3591 new MethodData(MethodData.Access.PUBLIC,
3592 MethodData.Context.STATIC);
3593 final ClassData withStatDef =
3594 new ClassData(pck, meth);
3595 final int I2 = builder.methodref;
3596 final int I1 = builder.addInterface(emptyClass(pck));
3597 final int C2 = builder.addClass(withStatDef);
3598 final int C1 = builder.addClass(emptyClass(pck));
3599 builder.hier.addInherit(C1, I1);
3600 builder.hier.addInherit(C1, C2);
3601 builder.hier.addInherit(I1, I2);
3602 builder.hier.addInherit(C2, I2);
3603 builder.objectref = C1;
3604 },
3605 /* Case 9: Diamond, with superclass, expected at top,
3606 * interface has private def
3607 *
3608 * I2[](*) = mref
3609 * C2[I2](), I1[I2](priv)
3610 * C1[I1,C2]() = oref
3611 */
3612 (final SelectionResolutionTestCase.Builder builder) -> {
3613 final ClassData.Package pck =
3614 builder.classdata.get(builder.expected).packageId;
3615 final MethodData meth =
3616 new MethodData(MethodData.Access.PRIVATE,
3617 MethodData.Context.INSTANCE);
3618 final ClassData withPrivDef =
3619 new ClassData(pck, meth);
3620 final int I2 = builder.methodref;
3621 final int I1 = builder.addInterface(withPrivDef);
3622 final int C2 = builder.addClass(emptyClass(pck));
3623 final int C1 = builder.addClass(emptyClass(pck));
3624 builder.hier.addInherit(C1, I1);
3625 builder.hier.addInherit(C1, C2);
3626 builder.hier.addInherit(I1, I2);
3627 builder.hier.addInherit(C2, I2);
3628 builder.objectref = C1;
3629 },
3630 /* Case 10: Diamond, with superclass, expected at top,
3631 * interface has static def
3632 *
3633 * I2[](*) = mref
3634 * C2[I2](), I1[I2](stat)
3635 * C1[I1,C2]() = oref
3636 */
3637 (final SelectionResolutionTestCase.Builder builder) -> {
3638 final ClassData.Package pck =
3639 builder.classdata.get(builder.expected).packageId;
3640 final MethodData meth =
3641 new MethodData(MethodData.Access.PUBLIC,
3642 MethodData.Context.STATIC);
3643 final ClassData withPrivDef =
3644 new ClassData(pck, meth);
3645 final int I2 = builder.methodref;
3646 final int I1 = builder.addInterface(withPrivDef);
3647 final int C2 = builder.addClass(emptyClass(pck));
3648 final int C1 = builder.addClass(emptyClass(pck));
3649 builder.hier.addInherit(C1, I1);
3650 builder.hier.addInherit(C1, C2);
3651 builder.hier.addInherit(I1, I2);
3652 builder.hier.addInherit(C2, I2);
3653 builder.objectref = C1;
3654 },
3655 /* Case 11: Y, with superclass, expected
3656 * at top.
3657 *
3658 * C2[](), I1[](*) = mref
3659 * C1[I1,C2]() = oref
3660 */
3661 (final SelectionResolutionTestCase.Builder builder) -> {
3662 final ClassData.Package pck =
3663 builder.classdata.get(builder.expected).packageId;
3664 final int I1 = builder.methodref;
3665 final int C2 = builder.addClass(emptyClass(pck));
3666 final int C1 = builder.addClass(emptyClass(pck));
3667 builder.hier.addInherit(C1, I1);
3668 builder.hier.addInherit(C1, C2);
3669 builder.objectref = C1;
3670 },
3671 /* Case 12: Y, with superclass, expected
3672 * at top, class has static def
3673 *
3674 * C2[](stat), I1[](*) = mref
3675 * C1[I1,C2]() = oref
3676 */
3677 (final SelectionResolutionTestCase.Builder builder) -> {
3678 final ClassData.Package pck =
3679 builder.classdata.get(builder.expected).packageId;
3680 final MethodData meth =
3681 new MethodData(MethodData.Access.PUBLIC,
3682 MethodData.Context.STATIC);
3683 final ClassData withStatDef =
3684 new ClassData(pck, meth);
3685 final int I1 = builder.methodref;
3686 final int C2 = builder.addClass(emptyClass(pck));
3687 final int C1 = builder.addClass(emptyClass(pck));
3688 builder.hier.addInherit(C1, I1);
3689 builder.hier.addInherit(C1, C2);
3690 builder.objectref = C1;
3691 },
3692 /* Case 13: Diamond, with superclass, overlapping, expected
3693 * at top.
3694 *
3695 * I2[](res) = expected
3696 * C2[I2](), I1[](*) = mref
3697 * C1[I1,C2]() = oref
3698 */
3699 (final SelectionResolutionTestCase.Builder builder) -> {
3700 final ClassData.Package pck =
3701 builder.classdata.get(builder.expected).packageId;
3702 final int I2 = builder.expected;
3703 final int I1 = builder.methodref;
3704 final int C2 = builder.addClass(emptyClass(pck));
3705 final int C1 = builder.addClass(emptyClass(pck));
3706 builder.hier.addInherit(C1, I1);
3707 builder.hier.addInherit(C1, C2);
3708 builder.hier.addInherit(C2, I2);
3709 builder.objectref = C1;
3710 },
3711 /* Case 14: Diamond, with superclass, overlapping, expected
3712 * at top, class has static def
3713 *
3714 * I2[](def) = expected
3715 * C2[I2](stat), I1[](*) = mref
3716 * C1[I1,C2]() = oref
3717 */
3718 (final SelectionResolutionTestCase.Builder builder) -> {
3719 final ClassData.Package pck =
3720 builder.classdata.get(builder.expected).packageId;
3721 final MethodData meth =
3722 new MethodData(MethodData.Access.PUBLIC,
3723 MethodData.Context.STATIC);
3724 final ClassData withStatDef =
3725 new ClassData(pck, meth);
3726 final int I2 = builder.expected;
3727 final int I1 = builder.methodref;
3728 final int C2 = builder.addClass(withStatDef);
3729 final int C1 = builder.addClass(emptyClass(pck));
3730 builder.hier.addInherit(C1, I1);
3731 builder.hier.addInherit(C1, C2);
3732 builder.hier.addInherit(C2, I2);
3733 builder.objectref = C1;
3734 },
3735 /* Case 15: Inherit through superclass.
3736 *
3737 * I[](*) = mref
3738 * C2[I]()
3739 * C1[C2]() = oref
3740 */
3741 (final SelectionResolutionTestCase.Builder builder) -> {
3742 final ClassData.Package pck =
3743 builder.classdata.get(builder.expected).packageId;
3744 final int I = builder.methodref;
3745 final int C2 = builder.addClass(emptyClass(pck));
3746 final int C1 = builder.addClass(emptyClass(pck));
3747 builder.hier.addInherit(C1, I);
3748 builder.hier.addInherit(C1, C2);
3749 builder.hier.addInherit(C2, I);
3750 builder.objectref = C1;
3751 },
3752 /* Case 16: Superclass has static def.
3753 *
3754 * I[](*) = mref
3755 * C2[I](stat) = expected
3756 * C1[C2]() = oref
3757 */
3758 (final SelectionResolutionTestCase.Builder builder) -> {
3759 final ClassData.Package pck =
3760 builder.classdata.get(builder.expected).packageId;
3761 final MethodData meth =
3762 new MethodData(MethodData.Access.PUBLIC,
3763 MethodData.Context.STATIC);
3764 final ClassData withStatDef =
3765 new ClassData(pck, meth);
3766 final int I = builder.methodref;
3767 final int C2 = builder.addClass(withStatDef);
3768 final int C1 = builder.addClass(emptyClass(pck));
3769 builder.hier.addInherit(C1, I);
3770 builder.hier.addInherit(C1, C2);
3771 builder.hier.addInherit(C2, I);
3772 builder.objectref = C1;
3773 },
3774 /* Case 17: Diamond, inherit through superclass,
3775 * methodref at top.
3776 *
3777 * I3[](*) = mref
3778 * I1[I3](), I2[I3]()
3779 * C2[I1,I2]()
3780 * C1[C2]() = oref
3781 */
3782 (final SelectionResolutionTestCase.Builder builder) -> {
3783 final ClassData.Package pck =
3784 builder.classdata.get(builder.expected).packageId;
3785 final int I3 = builder.methodref;
3786 final int I2 = builder.addInterface(emptyClass(pck));
3787 final int I1 = builder.addInterface(emptyClass(pck));
3788 final int C2 = builder.addClass(emptyClass(pck));
3789 final int C1 = builder.addClass(emptyClass(pck));
3790 builder.hier.addInherit(C2, I1);
3791 builder.hier.addInherit(C2, I2);
3792 builder.hier.addInherit(I1, I3);
3793 builder.hier.addInherit(I2, I3);
3794 builder.hier.addInherit(C1, C2);
3795 builder.objectref = C1;
3796 },
3797 /* Case 18: Diamond, with superclass, inherit through
3798 * superclass, methodref at top.
3799 *
3800 * I2[](*) = mref
3801 * C3[I2](), I1[I2]()
3802 * C2[I1,C3]()
3803 * C1[C2]() = oref
3804 */
3805 (final SelectionResolutionTestCase.Builder builder) -> {
3806 final ClassData.Package pck =
3807 builder.classdata.get(builder.expected).packageId;
3808 final int I2 = builder.methodref;
3809 final int I1 = builder.addInterface(emptyClass(pck));
3810 final int C3 = builder.addClass(emptyClass(pck));
3811 final int C2 = builder.addClass(emptyClass(pck));
3812 final int C1 = builder.addClass(emptyClass(pck));
3813 builder.hier.addInherit(C2, I1);
3814 builder.hier.addInherit(C2, C3);
3815 builder.hier.addInherit(I1, I2);
3816 builder.hier.addInherit(C3, I2);
3817 builder.hier.addInherit(C1, C2);
3818 builder.objectref = C1;
3819 },
3820 /* Case 19: Diamond, inherit through superclass,
3821 * expected at top, skip private.
3822 *
3823 * I3[](*) = mref
3824 * I1[I3](), I2[I3](priv)
3825 * C2[I1,I2]()
3826 * C1[C2]() = oref
3827 */
3828 (final SelectionResolutionTestCase.Builder builder) -> {
3829 final ClassData.Package pck =
3830 builder.classdata.get(builder.expected).packageId;
3831 final MethodData meth =
3832 new MethodData(MethodData.Access.PRIVATE,
3833 MethodData.Context.INSTANCE);
3834 final ClassData withPrivDef =
3835 new ClassData(pck, meth);
3836 final int I3 = builder.methodref;
3837 final int I2 = builder.addInterface(withPrivDef);
3838 final int I1 = builder.addInterface(emptyClass(pck));
3839 final int C2 = builder.addClass(emptyClass(pck));
3840 final int C1 = builder.addClass(emptyClass(pck));
3841 builder.hier.addInherit(C2, I1);
3842 builder.hier.addInherit(C2, I2);
3843 builder.hier.addInherit(I1, I3);
3844 builder.hier.addInherit(I2, I3);
3845 builder.hier.addInherit(C1, C2);
3846 builder.objectref = C1;
3847 },
3848 /* Case 20: Diamond, inherit through superclass,
3849 * expected at top, skip static.
3850 *
3851 * I3[](*) = mref
3852 * I1[I3](), I2[I3](stat)
3853 * C2[I1,I2]()
3854 * C1[C2]() = oref
3855 */
3856 (final SelectionResolutionTestCase.Builder builder) -> {
3857 final ClassData.Package pck =
3858 builder.classdata.get(builder.expected).packageId;
3859 final MethodData meth =
3860 new MethodData(MethodData.Access.PUBLIC,
3861 MethodData.Context.STATIC);
3862 final ClassData withStatDef =
3863 new ClassData(pck, meth);
3864 final int I3 = builder.methodref;
3865 final int I2 = builder.addInterface(withStatDef);
3866 final int I1 = builder.addInterface(emptyClass(pck));
3867 final int C2 = builder.addClass(emptyClass(pck));
3868 final int C1 = builder.addClass(emptyClass(pck));
3869 builder.hier.addInherit(C2, I1);
3870 builder.hier.addInherit(C2, I2);
3871 builder.hier.addInherit(I1, I3);
3872 builder.hier.addInherit(I2, I3);
3873 builder.hier.addInherit(C1, C2);
3874 builder.objectref = C1;
3875 },
3876 /* Case 21: Diamond, inherit through superclass,
3877 * overlapping, expected at top.
3878 *
3879 * I3[](res) = expected
3880 * I1[I3](), I2[*](*) = mref
3881 * C2[I1,I2]()
3882 * C1[C2]() = oref
3883 */
3884 (final SelectionResolutionTestCase.Builder builder) -> {
3885 final ClassData.Package pck =
3886 builder.classdata.get(builder.expected).packageId;
3887 final int I3 = builder.expected;
3888 final int I2 = builder.methodref;
3889 final int I1 = builder.addInterface(emptyClass(pck));
3890 final int C2 = builder.addClass(emptyClass(pck));
3891 final int C1 = builder.addClass(emptyClass(pck));
3892 builder.hier.addInherit(C2, I1);
3893 builder.hier.addInherit(C2, I2);
3894 builder.hier.addInherit(I1, I3);
3895 builder.hier.addInherit(C1, C2);
3896 builder.objectref = C1;
3897 },
3898 /* Case 22: Y, with superclass, inherit through
3899 * superclass, expected at top.
3900 *
3901 * C3[](), I1[*](*) = mref
3902 * C2[I1,C3]()
3903 * C1[C2]() = oref
3904 */
3905 (final SelectionResolutionTestCase.Builder builder) -> {
3906 final ClassData.Package pck =
3907 builder.classdata.get(builder.expected).packageId;
3908 final int I1 = builder.methodref;
3909 final int C3 = builder.addClass(emptyClass(pck));
3910 final int C2 = builder.addClass(emptyClass(pck));
3911 final int C1 = builder.addClass(emptyClass(pck));
3912 builder.hier.addInherit(C2, I1);
3913 builder.hier.addInherit(C2, C3);
3914 builder.hier.addInherit(C1, C2);
3915 builder.objectref = C1;
3916 },
3917 /* Case 23: Diamond, with superclass, inherit through
3918 * superclass, overlapping, expected at top.
3919 *
3920 * I2[](res) = expected
3921 * C3[I2](), I1[*](*) = mref
3922 * C2[I1,C3]()
3923 * C1[C2]() = oref
3924 */
3925 (final SelectionResolutionTestCase.Builder builder) -> {
3926 final ClassData.Package pck =
3927 builder.classdata.get(builder.expected).packageId;
3928 final int I2 = builder.expected;
3929 final int I1 = builder.methodref;
3930 final int C3 = builder.addClass(emptyClass(pck));
3931 final int C2 = builder.addClass(emptyClass(pck));
3932 final int C1 = builder.addClass(emptyClass(pck));
3933 builder.hier.addInherit(C2, I1);
3934 builder.hier.addInherit(C2, C3);
3935 builder.hier.addInherit(C3, I2);
3936 builder.hier.addInherit(C1, C2);
3937 builder.objectref = C1;
3938 },
3939 /* Case 24: Double diamond, with superclass, inherit through
3940 * superclass, overlapping expected at top.
3941 *
3942 * I3[](res) = expected
3943 * C3[I3](), I2[*](*) = mref
3944 * C2[I2,C3](), I1[I2]()
3945 * C1[C2,I1]() = oref
3946 */
3947 (final SelectionResolutionTestCase.Builder builder) -> {
3948 final ClassData.Package pck =
3949 builder.classdata.get(builder.expected).packageId;
3950 final int I3 = builder.expected;
3951 final int I2 = builder.methodref;
3952 final int I1 = builder.addInterface(emptyClass(pck));
3953 final int C3 = builder.addClass(emptyClass(pck));
3954 final int C2 = builder.addClass(emptyClass(pck));
3955 final int C1 = builder.addClass(emptyClass(pck));
3956 builder.hier.addInherit(C2, I2);
3957 builder.hier.addInherit(C2, C3);
3958 builder.hier.addInherit(C3, I3);
3959 builder.hier.addInherit(C1, C2);
3960 builder.hier.addInherit(I1, I2);
3961 builder.hier.addInherit(C1, I1);
3962 builder.objectref = C1;
3963 },
3964 /* Case 25: Double diamond, with superclass, inherit through
3965 * superclass, skip private.
3966 *
3967 * I3[](def) = old expected
3968 * C3[I3](), I2[*](*) = mref
3969 * C2[I2,C3](), I1[I2](priv)
3970 * C1[C2,I1]() = oref
3971 */
3972 (final SelectionResolutionTestCase.Builder builder) -> {
3973 final ClassData.Package pck =
3974 builder.classdata.get(builder.expected).packageId;
3975 final MethodData meth =
3976 new MethodData(MethodData.Access.PRIVATE,
3977 MethodData.Context.INSTANCE);
3978 final ClassData withPrivDef =
3979 new ClassData(pck, meth);
3980 final int I3 = builder.expected;
3981 final int I2 = builder.methodref;
3982 final int I1 = builder.addInterface(withPrivDef);
3983 final int C3 = builder.addClass(emptyClass(pck));
3984 final int C2 = builder.addClass(emptyClass(pck));
3985 final int C1 = builder.addClass(emptyClass(pck));
3986 builder.hier.addInherit(C2, I2);
3987 builder.hier.addInherit(C2, C3);
3988 builder.hier.addInherit(C3, I3);
3989 builder.hier.addInherit(C1, C2);
3990 builder.hier.addInherit(I1, I2);
3991 builder.hier.addInherit(C1, I1);
3992 builder.objectref = C1;
3993 },
3994 /* Case 26: Double diamond, with superclass, inherit through
3995 * superclass, skip static.
3996 *
3997 * I3[](def) = old expected
3998 * C3[I3](), I2[*](*) = mref
3999 * C2[I2,C3](), I1[I2](stat)
4000 * C1[C2,I1]() = oref
4001 */
4002 (final SelectionResolutionTestCase.Builder builder) -> {
4003 final ClassData.Package pck =
4004 builder.classdata.get(builder.expected).packageId;
4005 final MethodData meth =
4006 new MethodData(MethodData.Access.PUBLIC,
4007 MethodData.Context.STATIC);
4008 final ClassData withStatDef =
4009 new ClassData(pck, meth);
4010 final int I3 = builder.expected;
4011 final int I2 = builder.methodref;
4012 final int I1 = builder.addInterface(withStatDef);
4013 final int C3 = builder.addClass(emptyClass(pck));
4014 final int C2 = builder.addClass(emptyClass(pck));
4015 final int C1 = builder.addClass(emptyClass(pck));
4016 builder.hier.addInherit(C2, I2);
4017 builder.hier.addInherit(C2, C3);
4018 builder.hier.addInherit(C3, I3);
4019 builder.hier.addInherit(C1, C2);
4020 builder.hier.addInherit(I1, I2);
4021 builder.hier.addInherit(C1, I1);
4022 builder.objectref = C1;
4023 });
4024
4025 public static final Template IfaceMethodrefSelection =
4026 new Template("IfaceMethodrefSelection",
4027 IfaceMethodrefSelectionNoOverride,
4028 /* Case 27: Objectref overrides.
4029 *
4030 * I[](*) = mref
4031 * C[I](res) = oref = expected
4032 */
4033 (final SelectionResolutionTestCase.Builder builder) -> {
4034 final ClassData.Package pck =
4035 builder.classdata.get(builder.methodref).packageId;
4036 final ClassData oldexpected =
4037 builder.classdata.get(builder.expected);
4038 final ClassData withDef =
4039 new ClassData(pck, oldexpected.methoddata);
4040 final int I = builder.methodref;
4041 final int C = builder.addClass(withDef);
4042 builder.hier.addInherit(C, I);
4043 builder.objectref = C;
4044 builder.expected = C;
4045 },
4046 /* Case 28: Diamond, methodref at top, overriding.
4047 *
4048 * I3[](*) = mref
4049 * I1[I3](), I2[I3](res) = expected
4050 * C[I1,I2]() = oref
4051 */
4052 (final SelectionResolutionTestCase.Builder builder) -> {
4053 final ClassData.Package pck =
4054 builder.classdata.get(builder.expected).packageId;
4055 final ClassData oldexpected =
4056 builder.classdata.get(builder.expected);
4057 final ClassData withDef =
4058 new ClassData(pck, oldexpected.methoddata);
4059 final int I3 = builder.methodref;
4060 final int I2 = builder.addInterface(withDef);
4061 final int I1 = builder.addInterface(emptyClass(pck));
4062 final int C = builder.addClass(emptyClass(pck));
4063 builder.hier.addInherit(C, I1);
4064 builder.hier.addInherit(C, I2);
4065 builder.hier.addInherit(I1, I3);
4066 builder.hier.addInherit(I2, I3);
4067 builder.objectref = C;
4068 builder.expected = I2;
4069 },
4070 /* Case 29: Diamond, with superclass, expected at top,
4071 * class overriding.
4072 *
4073 * I2[](*) = mref
4074 * C2[I2](res) = expected, I1[I2]()
4075 * C1[I1,C2]() = oref
4076 */
4077 (final SelectionResolutionTestCase.Builder builder) -> {
4078 final ClassData.Package pck =
4079 builder.classdata.get(builder.expected).packageId;
4080 final ClassData oldexpected =
4081 builder.classdata.get(builder.expected);
4082 final ClassData withDef =
4083 new ClassData(pck, oldexpected.methoddata);
4084 final int I2 = builder.methodref;
4085 final int I1 = builder.addInterface(emptyClass(pck));
4086 final int C2 = builder.addClass(withDef);
4087 final int C1 = builder.addClass(emptyClass(pck));
4088 builder.hier.addInherit(C1, I1);
4089 builder.hier.addInherit(C1, C2);
4090 builder.hier.addInherit(I1, I2);
4091 builder.hier.addInherit(C2, I2);
4092 builder.objectref = C1;
4093 builder.expected = C2;
4094 },
4095 /* Case 30: Diamond, with superclass, expected at top,
4096 * interface overriding
4097 *
4098 * I2[](*) = mref
4099 * C2[I2](), I1[I2](res) = expected
4100 * C1[I1,C2]() = oref
4101 */
4102 (final SelectionResolutionTestCase.Builder builder) -> {
4103 final ClassData.Package pck =
4104 builder.classdata.get(builder.expected).packageId;
4105 final ClassData oldexpected =
4106 builder.classdata.get(builder.expected);
4107 final ClassData withDef =
4108 new ClassData(pck, oldexpected.methoddata);
4109 final int I2 = builder.methodref;
4110 final int I1 = builder.addInterface(withDef);
4111 final int C2 = builder.addClass(emptyClass(pck));
4112 final int C1 = builder.addClass(emptyClass(pck));
4113 builder.hier.addInherit(C1, I1);
4114 builder.hier.addInherit(C1, C2);
4115 builder.hier.addInherit(I1, I2);
4116 builder.hier.addInherit(C2, I2);
4117 builder.objectref = C1;
4118 builder.expected = I1;
4119 },
4120 /* Case 31: Y, with superclass, overlaping, expected
4121 * at top, class overrides
4122 *
4123 * C2[](res) = expected, I1[](*) = mref
4124 * C1[I1,C2]() = oref
4125 */
4126 (final SelectionResolutionTestCase.Builder builder) -> {
4127 final ClassData.Package pck =
4128 builder.classdata.get(builder.expected).packageId;
4129 final ClassData oldexpected =
4130 builder.classdata.get(builder.expected);
4131 final ClassData withDef =
4132 new ClassData(pck, oldexpected.methoddata);
4133 final int I1 = builder.methodref;
4134 final int C2 = builder.addClass(withDef);
4135 final int C1 = builder.addClass(emptyClass(pck));
4136 builder.hier.addInherit(C1, I1);
4137 builder.hier.addInherit(C1, C2);
4138 builder.objectref = C1;
4139 builder.expected = C2;
4140 },
4141 /* Case 32: Diamond, with superclass, overlaping, expected
4142 * at top, class overrides
4143 *
4144 * I2[](def) = old expected
4145 * C2[I2](res) = expected, I1[](*) = mref
4146 * C1[I1,C2]() = oref
4147 */
4148 (final SelectionResolutionTestCase.Builder builder) -> {
4149 final ClassData.Package pck =
4150 builder.classdata.get(builder.expected).packageId;
4151 final ClassData oldexpected =
4152 builder.classdata.get(builder.expected);
4153 final ClassData withDef =
4154 new ClassData(pck, oldexpected.methoddata);
4155 final int I2 = builder.expected;
4156 final int I1 = builder.methodref;
4157 final int C2 = builder.addClass(withDef);
4158 final int C1 = builder.addClass(emptyClass(pck));
4159 builder.hier.addInherit(C1, I1);
4160 builder.hier.addInherit(C1, C2);
4161 builder.hier.addInherit(C2, I2);
4162 builder.objectref = C1;
4163 builder.expected = C2;
4164 },
4165 /* Case 33: Superclass overrides.
4166 *
4167 * I[](*) = mref
4168 * C2[I](res) = expected
4169 * C1[C2]() = oref
4170 */
4171 (final SelectionResolutionTestCase.Builder builder) -> {
4172 final ClassData.Package pck =
4173 builder.classdata.get(builder.expected).packageId;
4174 final ClassData oldexpected =
4175 builder.classdata.get(builder.expected);
4176 final ClassData withDef =
4177 new ClassData(pck, oldexpected.methoddata);
4178 final int I = builder.methodref;
4179 final int C2 = builder.addClass(withDef);
4180 final int C1 = builder.addClass(emptyClass(pck));
4181 builder.hier.addInherit(C1, I);
4182 builder.hier.addInherit(C1, C2);
4183 builder.hier.addInherit(C2, I);
4184 builder.expected = C2;
4185 builder.objectref = C1;
4186 },
4187 /* Case 34: Diamond, inherit through superclass,
4188 * expected at top, override.
4189 *
4190 * I3[](*) = mref
4191 * I1[I3](), I2[I3](res) = expected
4192 * C2[I1,I2]()
4193 * C1[C2]() = oref
4194 */
4195 (final SelectionResolutionTestCase.Builder builder) -> {
4196 final ClassData.Package pck =
4197 builder.classdata.get(builder.expected).packageId;
4198 final ClassData oldexpected =
4199 builder.classdata.get(builder.expected);
4200 final ClassData withDef =
4201 new ClassData(pck, oldexpected.methoddata);
4202 final int I3 = builder.methodref;
4203 final int I2 = builder.addInterface(withDef);
4204 final int I1 = builder.addInterface(emptyClass(pck));
4205 final int C2 = builder.addClass(emptyClass(pck));
4206 final int C1 = builder.addClass(emptyClass(pck));
4207 builder.hier.addInherit(C2, I1);
4208 builder.hier.addInherit(C2, I2);
4209 builder.hier.addInherit(I1, I3);
4210 builder.hier.addInherit(I2, I3);
4211 builder.hier.addInherit(C1, C2);
4212 builder.objectref = C1;
4213 builder.expected = I2;
4214 },
4215 /* Case 35: Y, with superclass, inherit through
4216 * superclass, overlapping, expected at top.
4217 *
4218 * C3[](res) = expected, I1[*](*) = mref
4219 * C2[I1,C3]()
4220 * C1[C2]() = oref
4221 */
4222 (final SelectionResolutionTestCase.Builder builder) -> {
4223 final ClassData.Package pck =
4224 builder.classdata.get(builder.expected).packageId;
4225 final ClassData oldexpected =
4226 builder.classdata.get(builder.expected);
4227 final ClassData withDef =
4228 new ClassData(pck, oldexpected.methoddata);
4229 final int I1 = builder.methodref;
4230 final int C3 = builder.addClass(withDef);
4231 final int C2 = builder.addClass(emptyClass(pck));
4232 final int C1 = builder.addClass(emptyClass(pck));
4233 builder.hier.addInherit(C2, I1);
4234 builder.hier.addInherit(C2, C3);
4235 builder.hier.addInherit(C1, C2);
4236 builder.objectref = C1;
4237 builder.expected = C3;
4238 },
4239 /* Case 36: Diamond, with superclass, inherit through
4240 * superclass, overlapping, expected at top.
4241 *
4242 * I2[](*) = oldexpected
4243 * C3[I2](res) = expected, I1[*](*) = mref
4244 * C2[I1,C3]()
4245 * C1[C2]() = oref
4246 */
4247 (final SelectionResolutionTestCase.Builder builder) -> {
4248 final ClassData.Package pck =
4249 builder.classdata.get(builder.expected).packageId;
4250 final ClassData oldexpected =
4251 builder.classdata.get(builder.expected);
4252 final ClassData withDef =
4253 new ClassData(pck, oldexpected.methoddata);
4254 final int I2 = builder.expected;
4255 final int I1 = builder.methodref;
4256 final int C3 = builder.addClass(withDef);
4257 final int C2 = builder.addClass(emptyClass(pck));
4258 final int C1 = builder.addClass(emptyClass(pck));
4259 builder.hier.addInherit(C2, I1);
4260 builder.hier.addInherit(C2, C3);
4261 builder.hier.addInherit(C3, I2);
4262 builder.hier.addInherit(C1, C2);
4263 builder.objectref = C1;
4264 builder.expected = C3;
4265 },
4266 /* Case 37: Double diamond, with superclass, inherit through
4267 * superclass, overriding.
4268 *
4269 * I3[](def) = old expected
4270 * C3[I3](), I2[*](*) = mref
4271 * C2[I2,C3](), I1[I2](res) = expected
4272 * C1[C2,I1]() = oref
4273 */
4274 (final SelectionResolutionTestCase.Builder builder) -> {
4275 final ClassData.Package pck =
4276 builder.classdata.get(builder.expected).packageId;
4277 final ClassData oldexpected =
4278 builder.classdata.get(builder.expected);
4279 final ClassData withDef =
4280 new ClassData(pck, oldexpected.methoddata);
4281 final int I3 = builder.expected;
4282 final int I2 = builder.methodref;
4283 final int I1 = builder.addInterface(withDef);
4284 final int C3 = builder.addClass(emptyClass(pck));
4285 final int C2 = builder.addClass(emptyClass(pck));
4286 final int C1 = builder.addClass(emptyClass(pck));
4287 builder.hier.addInherit(C2, I2);
4288 builder.hier.addInherit(C2, C3);
4289 builder.hier.addInherit(C3, I3);
4290 builder.hier.addInherit(C1, C2);
4291 builder.hier.addInherit(I1, I2);
4292 builder.hier.addInherit(C1, I1);
4293 builder.objectref = C1;
4294 builder.expected = I1;
4295 },
4296 /* Case 38: Double diamond, with superclass, inherit through
4297 * superclass, skip private.
4298 *
4299 * I3[](def) = old expected
4300 * C3[I3](), I2[*](*) = mref
4301 * C2[I2,C3](), I1[I2](priv)
4302 * C1[C2,I1]() = oref
4303 */
4304 (final SelectionResolutionTestCase.Builder builder) -> {
4305 final ClassData.Package pck =
4306 builder.classdata.get(builder.expected).packageId;
4307 final ClassData oldexpected =
4308 builder.classdata.get(builder.expected);
4309 final ClassData withDef =
4310 new ClassData(pck, oldexpected.methoddata);
4311 final MethodData meth =
4312 new MethodData(MethodData.Access.PRIVATE,
4313 MethodData.Context.INSTANCE);
4314 final ClassData withPrivDef =
4315 new ClassData(pck, meth);
4316 final int I3 = builder.expected;
4317 final int I2 = builder.methodref;
4318 final int I1 = builder.addInterface(withPrivDef);
4319 final int C3 = builder.addClass(emptyClass(pck));
4320 final int C2 = builder.addClass(emptyClass(pck));
4321 final int C1 = builder.addClass(emptyClass(pck));
4322 builder.hier.addInherit(C2, I2);
4323 builder.hier.addInherit(C2, C3);
4324 builder.hier.addInherit(C3, I3);
4325 builder.hier.addInherit(C1, C2);
4326 builder.hier.addInherit(I1, I2);
4327 builder.hier.addInherit(C1, I1);
4328 builder.objectref = C1;
4329 },
4330 /* Case 39: Double diamond, with superclass, inherit through
4331 * superclass, skip static.
4332 *
4333 * I3[](def) = old expected
4334 * C3[I3](), I2[*](*) = mref
4335 * C2[I2,C3](), I1[I2](stat)
4336 * C1[C2,I1]() = oref
4337 */
4338 (final SelectionResolutionTestCase.Builder builder) -> {
4339 final ClassData.Package pck =
4340 builder.classdata.get(builder.expected).packageId;
4341 final ClassData oldexpected =
4342 builder.classdata.get(builder.expected);
4343 final ClassData withDef =
4344 new ClassData(pck, oldexpected.methoddata);
4345 final MethodData meth =
4346 new MethodData(MethodData.Access.PUBLIC,
4347 MethodData.Context.STATIC);
4348 final ClassData withStatDef =
4349 new ClassData(pck, meth);
4350 final int I3 = builder.expected;
4351 final int I2 = builder.methodref;
4352 final int I1 = builder.addInterface(withStatDef);
4353 final int C3 = builder.addClass(emptyClass(pck));
4354 final int C2 = builder.addClass(emptyClass(pck));
4355 final int C1 = builder.addClass(emptyClass(pck));
4356 builder.hier.addInherit(C2, I2);
4357 builder.hier.addInherit(C2, C3);
4358 builder.hier.addInherit(C3, I3);
4359 builder.hier.addInherit(C1, C2);
4360 builder.hier.addInherit(I1, I2);
4361 builder.hier.addInherit(C1, I1);
4362 builder.objectref = C1;
4363 },
4364 /* Case 40: Superclass overrides.
4365 *
4366 * I[](*) = mref
4367 * C3[I](res) = expected
4368 * C2[C3](stat) = expected
4369 * C1[C2]() = oref
4370 */
4371 (final SelectionResolutionTestCase.Builder builder) -> {
4372 final ClassData.Package pck =
4373 builder.classdata.get(builder.expected).packageId;
4374 final ClassData oldexpected =
4375 builder.classdata.get(builder.expected);
4376 final ClassData withDef =
4377 new ClassData(pck, oldexpected.methoddata);
4378 final MethodData meth =
4379 new MethodData(MethodData.Access.PUBLIC,
4380 MethodData.Context.STATIC);
4381 final ClassData withStatDef =
4382 new ClassData(pck, meth);
4383 final int I = builder.methodref;
4384 final int C3 = builder.addClass(withDef);
4385 final int C2 = builder.addClass(withStatDef);
4386 final int C1 = builder.addClass(emptyClass(pck));
4387 builder.hier.addInherit(C1, I);
4388 builder.hier.addInherit(C1, C2);
4389 builder.hier.addInherit(C2, C3);
4390 builder.hier.addInherit(C2, I);
4391 builder.expected = C3;
4392 builder.objectref = C1;
4393 });
4394
4395 public static final Template IfaceMethodrefSelectionOverrideNonPublic =
4396 new Template("IfaceMethodrefSelection",
4397 /* Case 1: Objectref overrides.
4398 *
4399 * I[](*) = mref
4400 * C[I](priv) = oref = expected
4401 */
4402 (final SelectionResolutionTestCase.Builder builder) -> {
4403 final ClassData.Package pck =
4404 builder.classdata.get(builder.methodref).packageId;
4405 final ClassData oldexpected =
4406 builder.classdata.get(builder.expected);
4407 final MethodData meth =
4408 new MethodData(MethodData.Access.PRIVATE,
4409 MethodData.Context.INSTANCE);
4410 final ClassData withDef =
4411 new ClassData(pck, meth);
4412 final int I = builder.methodref;
4413 final int C = builder.addClass(withDef);
4414 builder.hier.addInherit(C, I);
4415 builder.objectref = C;
4416 builder.expected = C;
4417 },
4418 /* Case 2: Objectref overrides.
4419 *
4420 * I[](*) = mref
4421 * C[I](prot) = oref = expected
4422 */
4423 (final SelectionResolutionTestCase.Builder builder) -> {
4424 final ClassData.Package pck =
4425 builder.classdata.get(builder.methodref).packageId;
4426 final ClassData oldexpected =
4427 builder.classdata.get(builder.expected);
4428 final MethodData meth =
4429 new MethodData(MethodData.Access.PROTECTED,
4430 MethodData.Context.INSTANCE);
4431 final ClassData withDef =
4432 new ClassData(pck, meth);
4433 final int I = builder.methodref;
4434 final int C = builder.addClass(withDef);
4435 builder.hier.addInherit(C, I);
4436 builder.objectref = C;
4437 builder.expected = C;
4438 },
4439 /* Case 3: Objectref overrides package private.
4440 *
4441 * I[](*) = mref
4442 * C[I](pack) = oref = expected
4443 */
4444 (final SelectionResolutionTestCase.Builder builder) -> {
4445 final ClassData.Package pck =
4446 builder.classdata.get(builder.methodref).packageId;
4447 final ClassData oldexpected =
4448 builder.classdata.get(builder.expected);
4449 final MethodData meth =
4450 new MethodData(MethodData.Access.PACKAGE,
4451 MethodData.Context.INSTANCE);
4452 final ClassData withDef =
4453 new ClassData(pck, meth);
4454 final int I = builder.methodref;
4455 final int C = builder.addClass(withDef);
4456 builder.hier.addInherit(C, I);
4457 builder.objectref = C;
4458 builder.expected = C;
4459 },
4460 /* Case 4: Diamond, with superclass, expected at top,
4461 * class overriding with private.
4462 *
4463 * I2[](*) = mref
4464 * C2[I2](priv) = expected, I1[I2]()
4465 * C1[I1,C2]() = oref
4466 */
4467 (final SelectionResolutionTestCase.Builder builder) -> {
4468 final ClassData.Package pck =
4469 builder.classdata.get(builder.expected).packageId;
4470 final ClassData oldexpected =
4471 builder.classdata.get(builder.expected);
4472 final MethodData meth =
4473 new MethodData(MethodData.Access.PRIVATE,
4474 MethodData.Context.INSTANCE);
4475 final ClassData withDef =
4476 new ClassData(pck, meth);
4477 final int I2 = builder.methodref;
4478 final int I1 = builder.addInterface(emptyClass(pck));
4479 final int C2 = builder.addClass(withDef);
4480 final int C1 = builder.addClass(emptyClass(pck));
4481 builder.hier.addInherit(C1, I1);
4482 builder.hier.addInherit(C1, C2);
4483 builder.hier.addInherit(I1, I2);
4484 builder.hier.addInherit(C2, I2);
4485 builder.objectref = C1;
4486 builder.expected = C2;
4487 },
4488 /* Case 5: Diamond, with superclass, expected at top,
4489 * class overriding with package private.
4490 *
4491 * I2[](*) = mref
4492 * C2[I2](pack) = expected, I1[I2]()
4493 * C1[I1,C2]() = oref
4494 */
4495 (final SelectionResolutionTestCase.Builder builder) -> {
4496 final ClassData.Package pck =
4497 builder.classdata.get(builder.expected).packageId;
4498 final ClassData oldexpected =
4499 builder.classdata.get(builder.expected);
4500 final MethodData meth =
4501 new MethodData(MethodData.Access.PACKAGE,
4502 MethodData.Context.INSTANCE);
4503 final ClassData withDef =
4504 new ClassData(pck, meth);
4505 final int I2 = builder.methodref;
4506 final int I1 = builder.addInterface(emptyClass(pck));
4507 final int C2 = builder.addClass(withDef);
4508 final int C1 = builder.addClass(emptyClass(pck));
4509 builder.hier.addInherit(C1, I1);
4510 builder.hier.addInherit(C1, C2);
4511 builder.hier.addInherit(I1, I2);
4512 builder.hier.addInherit(C2, I2);
4513 builder.objectref = C1;
4514 builder.expected = C2;
4515 },
4516 /* Case 6: Diamond, with superclass, expected at top,
4517 * class overriding with protected.
4518 *
4519 * I2[](*) = mref
4520 * C2[I2](prot) = expected, I1[I2]()
4521 * C1[I1,C2]() = oref
4522 */
4523 (final SelectionResolutionTestCase.Builder builder) -> {
4524 final ClassData.Package pck =
4525 builder.classdata.get(builder.expected).packageId;
4526 final ClassData oldexpected =
4527 builder.classdata.get(builder.expected);
4528 final MethodData meth =
4529 new MethodData(MethodData.Access.PROTECTED,
4530 MethodData.Context.INSTANCE);
4531 final ClassData withDef =
4532 new ClassData(pck, meth);
4533 final int I2 = builder.methodref;
4534 final int I1 = builder.addInterface(emptyClass(pck));
4535 final int C2 = builder.addClass(withDef);
4536 final int C1 = builder.addClass(emptyClass(pck));
4537 builder.hier.addInherit(C1, I1);
4538 builder.hier.addInherit(C1, C2);
4539 builder.hier.addInherit(I1, I2);
4540 builder.hier.addInherit(C2, I2);
4541 builder.objectref = C1;
4542 builder.expected = C2;
4543 },
4544 /* Case 7: Y, with superclass, overlaping, expected
4545 * at top, class overrides
4546 *
4547 * C2[](priv) = expected, I1[](*) = mref
4548 * C1[I1,C2]() = oref
4549 */
4550 (final SelectionResolutionTestCase.Builder builder) -> {
4551 final ClassData.Package pck =
4552 builder.classdata.get(builder.expected).packageId;
4553 final ClassData oldexpected =
4554 builder.classdata.get(builder.expected);
4555 final MethodData meth =
4556 new MethodData(MethodData.Access.PRIVATE,
4557 MethodData.Context.INSTANCE);
4558 final ClassData withDef =
4559 new ClassData(pck, meth);
4560 final int I1 = builder.methodref;
4561 final int C2 = builder.addClass(withDef);
4562 final int C1 = builder.addClass(emptyClass(pck));
4563 builder.hier.addInherit(C1, I1);
4564 builder.hier.addInherit(C1, C2);
4565 builder.objectref = C1;
4566 builder.expected = C2;
4567 },
4568 /* Case 8: Y, with superclass, overlaping, expected
4569 * at top, class overrides
4570 *
4571 * C2[](prot) = expected, I1[](*) = mref
4572 * C1[I1,C2]() = oref
4573 */
4574 (final SelectionResolutionTestCase.Builder builder) -> {
4575 final ClassData.Package pck =
4576 builder.classdata.get(builder.expected).packageId;
4577 final ClassData oldexpected =
4578 builder.classdata.get(builder.expected);
4579 final MethodData meth =
4580 new MethodData(MethodData.Access.PROTECTED,
4581 MethodData.Context.INSTANCE);
4582 final ClassData withDef =
4583 new ClassData(pck, meth);
4584 final int I1 = builder.methodref;
4585 final int C2 = builder.addClass(withDef);
4586 final int C1 = builder.addClass(emptyClass(pck));
4587 builder.hier.addInherit(C1, I1);
4588 builder.hier.addInherit(C1, C2);
4589 builder.objectref = C1;
4590 builder.expected = C2;
4591 },
4592 /* Case 9: Y, with superclass, overlaping, expected
4593 * at top, class overrides
4594 *
4595 * C2[](pack) = expected, I1[](*) = mref
4596 * C1[I1,C2]() = oref
4597 */
4598 (final SelectionResolutionTestCase.Builder builder) -> {
4599 final ClassData.Package pck =
4600 builder.classdata.get(builder.expected).packageId;
4601 final ClassData oldexpected =
4602 builder.classdata.get(builder.expected);
4603 final MethodData meth =
4604 new MethodData(MethodData.Access.PACKAGE,
4605 MethodData.Context.INSTANCE);
4606 final ClassData withDef =
4607 new ClassData(pck, meth);
4608 final int I1 = builder.methodref;
4609 final int C2 = builder.addClass(withDef);
4610 final int C1 = builder.addClass(emptyClass(pck));
4611 builder.hier.addInherit(C1, I1);
4612 builder.hier.addInherit(C1, C2);
4613 builder.objectref = C1;
4614 builder.expected = C2;
4615 },
4616 /* Case 10: Diamond, with superclass, overlaping, expected
4617 * at top, class overrides
4618 *
4619 * I2[](def) = old expected
4620 * C2[I2](priv) = expected, I1[](*) = mref
4621 * C1[I1,C2]() = oref
4622 */
4623 (final SelectionResolutionTestCase.Builder builder) -> {
4624 final ClassData.Package pck =
4625 builder.classdata.get(builder.expected).packageId;
4626 final ClassData oldexpected =
4627 builder.classdata.get(builder.expected);
4628 final MethodData meth =
4629 new MethodData(MethodData.Access.PRIVATE,
4630 MethodData.Context.INSTANCE);
4631 final ClassData withDef =
4632 new ClassData(pck, meth);
4633 final int I2 = builder.expected;
4634 final int I1 = builder.methodref;
4635 final int C2 = builder.addClass(withDef);
4636 final int C1 = builder.addClass(emptyClass(pck));
4637 builder.hier.addInherit(C1, I1);
4638 builder.hier.addInherit(C1, C2);
4639 builder.hier.addInherit(C2, I2);
4640 builder.objectref = C1;
4641 builder.expected = C2;
4642 },
4643 /* Case 11: Diamond, with superclass, overlaping, expected
4644 * at top, class overrides
4645 *
4646 * I2[](def) = old expected
4647 * C2[I2](pack) = expected, I1[](*) = mref
4648 * C1[I1,C2]() = oref
4649 */
4650 (final SelectionResolutionTestCase.Builder builder) -> {
4651 final ClassData.Package pck =
4652 builder.classdata.get(builder.expected).packageId;
4653 final ClassData oldexpected =
4654 builder.classdata.get(builder.expected);
4655 final MethodData meth =
4656 new MethodData(MethodData.Access.PACKAGE,
4657 MethodData.Context.INSTANCE);
4658 final ClassData withDef =
4659 new ClassData(pck, meth);
4660 final int I2 = builder.expected;
4661 final int I1 = builder.methodref;
4662 final int C2 = builder.addClass(withDef);
4663 final int C1 = builder.addClass(emptyClass(pck));
4664 builder.hier.addInherit(C1, I1);
4665 builder.hier.addInherit(C1, C2);
4666 builder.hier.addInherit(C2, I2);
4667 builder.objectref = C1;
4668 builder.expected = C2;
4669 },
4670 /* Case 12: Diamond, with superclass, overlaping, expected
4671 * at top, class overrides
4672 *
4673 * I2[](def) = old expected
4674 * C2[I2](prot) = expected, I1[](*) = mref
4675 * C1[I1,C2]() = oref
4676 */
4677 (final SelectionResolutionTestCase.Builder builder) -> {
4678 final ClassData.Package pck =
4679 builder.classdata.get(builder.expected).packageId;
4680 final ClassData oldexpected =
4681 builder.classdata.get(builder.expected);
4682 final MethodData meth =
4683 new MethodData(MethodData.Access.PROTECTED,
4684 MethodData.Context.INSTANCE);
4685 final ClassData withDef =
4686 new ClassData(pck, meth);
4687 final int I2 = builder.expected;
4688 final int I1 = builder.methodref;
4689 final int C2 = builder.addClass(withDef);
4690 final int C1 = builder.addClass(emptyClass(pck));
4691 builder.hier.addInherit(C1, I1);
4692 builder.hier.addInherit(C1, C2);
4693 builder.hier.addInherit(C2, I2);
4694 builder.objectref = C1;
4695 builder.expected = C2;
4696 },
4697 /* Case 13: Superclass overrides.
4698 *
4699 * I[](*) = mref
4700 * C2[I](priv) = expected
4701 * C1[C2]() = oref
4702 */
4703 (final SelectionResolutionTestCase.Builder builder) -> {
4704 final ClassData.Package pck =
4705 builder.classdata.get(builder.expected).packageId;
4706 final ClassData oldexpected =
4707 builder.classdata.get(builder.expected);
4708 final MethodData meth =
4709 new MethodData(MethodData.Access.PRIVATE,
4710 MethodData.Context.INSTANCE);
4711 final ClassData withDef =
4712 new ClassData(pck, meth);
4713 final int I = builder.methodref;
4714 final int C2 = builder.addClass(withDef);
4715 final int C1 = builder.addClass(emptyClass(pck));
4716 builder.hier.addInherit(C1, I);
4717 builder.hier.addInherit(C1, C2);
4718 builder.hier.addInherit(C2, I);
4719 builder.expected = C2;
4720 builder.objectref = C1;
4721 },
4722 /* Case 14: Superclass overrides.
4723 *
4724 * I[](*) = mref
4725 * C2[I](prot) = expected
4726 * C1[C2]() = oref
4727 */
4728 (final SelectionResolutionTestCase.Builder builder) -> {
4729 final ClassData.Package pck =
4730 builder.classdata.get(builder.expected).packageId;
4731 final ClassData oldexpected =
4732 builder.classdata.get(builder.expected);
4733 final MethodData meth =
4734 new MethodData(MethodData.Access.PROTECTED,
4735 MethodData.Context.INSTANCE);
4736 final ClassData withDef =
4737 new ClassData(pck, meth);
4738 final int I = builder.methodref;
4739 final int C2 = builder.addClass(withDef);
4740 final int C1 = builder.addClass(emptyClass(pck));
4741 builder.hier.addInherit(C1, I);
4742 builder.hier.addInherit(C1, C2);
4743 builder.hier.addInherit(C2, I);
4744 builder.expected = C2;
4745 builder.objectref = C1;
4746 },
4747 /* Case 15: Superclass overrides.
4748 *
4749 * I[](*) = mref
4750 * C2[I](pack) = expected
4751 * C1[C2]() = oref
4752 */
4753 (final SelectionResolutionTestCase.Builder builder) -> {
4754 final ClassData.Package pck =
4755 builder.classdata.get(builder.expected).packageId;
4756 final ClassData oldexpected =
4757 builder.classdata.get(builder.expected);
4758 final MethodData meth =
4759 new MethodData(MethodData.Access.PACKAGE,
4760 MethodData.Context.INSTANCE);
4761 final ClassData withDef =
4762 new ClassData(pck, meth);
4763 final int I = builder.methodref;
4764 final int C2 = builder.addClass(withDef);
4765 final int C1 = builder.addClass(emptyClass(pck));
4766 builder.hier.addInherit(C1, I);
4767 builder.hier.addInherit(C1, C2);
4768 builder.hier.addInherit(C2, I);
4769 builder.expected = C2;
4770 builder.objectref = C1;
4771 });
4772
4773 /***********************
4774 * Ambiguous selection *
4775 ***********************/
4776
4777 public static final Template MethodrefAmbiguousResolvedIsIface =
4778 new Template("MethodrefAmbiguousResolvedIsIface",
4779 /* Inherit from interface.
4780 *
4781 * C2[](*) = mref, I[](any)
4782 * C1[C2,I]() = oref
4783 */
4784 (final SelectionResolutionTestCase.Builder builder) -> {
4785 final ClassData oldexpected =
4786 builder.classdata.get(builder.expected);
4787 final ClassData.Package pck = oldexpected.packageId;
4788 final MethodData.Context ctx = oldexpected.methoddata.context;
4789 final MethodData mdata =
4790 new MethodData(MethodData.Access.PUBLIC, ctx);
4791 final ClassData withDef = new ClassData(pck, mdata);
4792 final int C2 = builder.methodref;
4793 final int C1 = builder.addClass(emptyClass(pck));
4794 final int I = builder.addInterface(withDef);
4795 builder.hier.addInherit(C1, C2);
4796 builder.hier.addInherit(C1, I);
4797 builder.objectref = C1;
4798 });
4799
4800 public static final Template IfaceMethodrefAmbiguousResolvedIsIface =
4801 new Template("IfaceMethodrefAmbiguousResolvedIsIface",
4802 /* Inherit from interface.
4803 *
4804 * I1[](*) = mref, I2[](any)
4805 * C1[I1,I2]() = oref
4806 */
4807 (final SelectionResolutionTestCase.Builder builder) -> {
4808 final ClassData oldexpected =
4809 builder.classdata.get(builder.expected);
4810 final ClassData.Package pck = oldexpected.packageId;
4811 final MethodData.Context ctx = oldexpected.methoddata.context;
4812 final MethodData mdata =
4813 new MethodData(MethodData.Access.PUBLIC, ctx);
4814 final ClassData withDef = new ClassData(pck, mdata);
4815 final int I1 = builder.methodref;
4816 final int C = builder.addClass(emptyClass(pck));
4817 final int I2 = builder.addInterface(withDef);
4818 builder.hier.addInherit(C, I1);
4819 builder.hier.addInherit(C, I2);
4820 builder.objectref = C;
4821 });
4822
4823 public static final Template InvokespecialAmbiguousResolvedIsIface =
4824 new Template("InvokespecialAmbiguousResolvedIsIface",
4825 /* Inherit from interface.
4826 *
4827 * C2[](*) = csite, I[](any)
4828 * C1[C2,I]() = oref
4829 */
4830 (final SelectionResolutionTestCase.Builder builder) -> {
4831 final ClassData oldexpected =
4832 builder.classdata.get(builder.expected);
4833 final ClassData.Package pck = oldexpected.packageId;
4834 final MethodData.Context ctx = oldexpected.methoddata.context;
4835 final MethodData mdata =
4836 new MethodData(MethodData.Access.PUBLIC, ctx);
4837 final ClassData withDef = new ClassData(pck, mdata);
4838 final int C2 = builder.callsite;
4839 final int C1 = builder.addClass(emptyClass(pck));
4840 final int I = builder.addInterface(withDef);
4841 builder.hier.addInherit(C1, C2);
4842 builder.hier.addInherit(C1, I);
4843 builder.objectref = C1;
4844 });
4845
4846 /******************************
4847 * invokespecial Templates *
4848 ******************************/
4849
4850 // Create this by taking MethodrefSelection and replacing
4851 // methodref with callsite.
4852 public static final Template ObjectrefAssignableToCallsite =
4853 new Template("ObjectrefAssignableToCallsite",
4854 /* Case 1: Objectref equals callsite
4855 *
4856 * C[](*) = csite = oref
4857 */
4858 (builder) -> {
4859 builder.objectref = builder.callsite;
4860 },
4861 /* Case 2: Inherit from super.
4862 *
4863 * C2[](*) = csite
4864 * C1[C2]() = oref
4865 */
4866 (final SelectionResolutionTestCase.Builder builder) -> {
4867 final ClassData.Package pck =
4868 builder.classdata.get(builder.callsite).packageId;
4869 final int C2 = builder.callsite;
4870 final int C1 = builder.addClass(emptyClass(pck));
4871 builder.hier.addInherit(C1, C2);
4872 builder.objectref = C1;
4873 });
4874
4875 public static final Template ObjectrefExactSubclassOfCallsite =
4876 new Template("ObjectrefSubclassOfCallsite",
4877 /* Inherit from super.
4878 *
4879 * C2[](*) = csite
4880 * C1[C2]() = oref
4881 */
4882 (final SelectionResolutionTestCase.Builder builder) -> {
4883 final ClassData.Package pck =
4884 builder.classdata.get(builder.callsite).packageId;
4885 final int C2 = builder.callsite;
4886 final int C1 = builder.addClass(emptyClass(pck));
4887 builder.hier.addInherit(C1, C2);
4888 builder.objectref = C1;
4889 });
4890
4891 public static final Template ObjectrefEqualsOrExactSubclassOfCallsite =
4892 new Template("ObjectrefEqualsOrExactSubclassOfCallsite",
4893 (final SelectionResolutionTestCase.Builder builder) -> {
4894 builder.objectref = builder.callsite;
4895 },
4896 /* Inherit from super.
4897 *
4898 * C2[](*) = csite
4899 * C1[C2]() = oref
4900 */
4901 (final SelectionResolutionTestCase.Builder builder) -> {
4902 final ClassData.Package pck =
4903 builder.classdata.get(builder.callsite).packageId;
4904 final int C2 = builder.callsite;
4905 final int C1 = builder.addClass(emptyClass(pck));
4906 builder.hier.addInherit(C1, C2);
4907 builder.objectref = C1;
4908 });
4909
4910 public static final Template ObjectrefEqualsCallsite =
4911 new Template("TrivialObjectref",
4912 Collections.singleton((builder) -> {
4913 builder.objectref = builder.callsite;
4914 }));
4915
4916 public static final Template ObjectrefSubclassOfSubclassOfCallsite =
4917 new Template("ObjectrefSubclassOfCallsite",
4918 /* Inherit from super.
4919 *
4920 * C3[](*) = csite
4921 * C2[C3]()
4922 * C1[C2]() = oref
4923 */
4924 (final SelectionResolutionTestCase.Builder builder) -> {
4925 final ClassData.Package pck =
4926 builder.classdata.get(builder.callsite).packageId;
4927 final int C3 = builder.callsite;
4928 final int C2 = builder.addClass(emptyClass(pck));
4929 final int C1 = builder.addClass(emptyClass(pck));
4930 builder.hier.addInherit(C2, C3);
4931 builder.hier.addInherit(C1, C2);
4932 builder.objectref = C1;
4933 });
4934
4935 private static class Placeholder extends ClassData {
4936 private final String placeholder;
4937
4938
4939 private Placeholder(final String placeholder,
4940 final MethodData methoddata) {
4941 super(ClassData.Package.PLACEHOLDER, methoddata);
4942 this.placeholder = placeholder;
4943 }
4944
4945 private Placeholder(final String placeholder) {
4946 this(placeholder, null);
4947 }
4948
4949 public String toString() {
4950 return " = <Placeholder for " + placeholder + ">\n\n";
4951 }
4952
4953 public static final Placeholder objectref = new Placeholder("objectref");
4954 public static final Placeholder methodref = new Placeholder("methodref");
4955 public static final Placeholder callsite = new Placeholder("callsite");
4956 public static final Placeholder expected =
4957 new Placeholder("expected",
4958 new MethodData(MethodData.Access.PLACEHOLDER,
4959 MethodData.Context.PLACEHOLDER));
4960 }
4961
4962 public static void main(String... args) {
4963
4964 System.err.println("*** Resolution Templates ***\n");
4965 final SelectionResolutionTestCase.Builder withExpectedIface =
4966 new SelectionResolutionTestCase.Builder();
4967 withExpectedIface.expected =
4968 withExpectedIface.addInterface(Placeholder.expected);
4969 final SelectionResolutionTestCase.Builder withExpectedClass =
4970 new SelectionResolutionTestCase.Builder();
4971 withExpectedClass.expected =
4972 withExpectedClass.addClass(Placeholder.expected);
4973
4974 MethodrefNotEqualsExpectedClass.printCases(withExpectedClass);
4975 MethodrefNotEqualsExpectedIface.printCases(withExpectedIface);
4976 IfaceMethodrefNotEqualsExpected.printCases(withExpectedIface);
4977 MethodrefAmbiguous.printCases(withExpectedIface);
4978 IfaceMethodrefAmbiguous.printCases(withExpectedIface);
4979 ReabstractExpectedIface.printCases(withExpectedIface);
4980 ReabstractExpectedClass.printCases(withExpectedClass);
4981
4982 final SelectionResolutionTestCase.Builder methodrefExpectedIface =
4983 withExpectedIface.copy();
4984 methodrefExpectedIface.methodref =
4985 methodrefExpectedIface.addClass(Placeholder.methodref);
4986 final SelectionResolutionTestCase.Builder methodrefExpectedClass =
4987 withExpectedClass.copy();
4988 methodrefExpectedClass.methodref =
4989 methodrefExpectedClass.addClass(Placeholder.methodref);
4990 final SelectionResolutionTestCase.Builder ifaceMethodref =
4991 withExpectedIface.copy();
4992 ifaceMethodref.methodref =
4993 ifaceMethodref.addInterface(Placeholder.methodref);
4994
4995 IgnoredAbstract.printCases(methodrefExpectedIface);
4996 MethodrefSelectionResolvedIsClass.printCases(methodrefExpectedClass);
4997 MethodrefSelectionResolvedIsIface.printCases(methodrefExpectedIface);
4998 IfaceMethodrefSelection.printCases(ifaceMethodref);
4999 IfaceMethodrefSelectionOverrideNonPublic.printCases(ifaceMethodref);
5000
5001 }
5002
5003 }