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