jdk8-mips64-public/langtools: comparison test/tools/javac/lambda/intersection/IntersectionTargetTypeTest.java

-:94a202228ec2
+:c635a966ce84
 * @bug 8002099
 * @summary Add support for intersection types in cast expression
 */
 import com.sun.source.util.JavacTask;
-import com.sun.tools.javac.util.List;
 import com.sun.tools.javac.util.ListBuffer;
 import java.net.URI;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.List;
 import javax.tools.Diagnostic;
 import javax.tools.JavaCompiler;
 import javax.tools.JavaFileObject;
 import javax.tools.SimpleJavaFileObject;
 import javax.tools.StandardJavaFileManager;
 static int checkCount = 0;
 enum BoundKind {
 INTF,
-CLASS,
+CLASS;
-SAM,
-ZAM;
 }
 enum MethodKind {
-NONE,
+NONE(false),
-ABSTRACT,
+ABSTRACT_M(true),
-DEFAULT;
+DEFAULT_M(false),
+ABSTRACT_G(true),
+DEFAULT_G(false);
+boolean isAbstract;
+MethodKind(boolean isAbstract) {
+this.isAbstract = isAbstract;
+}
 }
 enum TypeKind {
-A("interface A { }\n", "A", BoundKind.ZAM),
+A("interface A { }\n", "A", BoundKind.INTF, MethodKind.NONE),
-B("interface B { default void m() { } }\n", "B", BoundKind.ZAM),
+B("interface B { default void m() { } }\n", "B", BoundKind.INTF, MethodKind.DEFAULT_M),
-C("interface C { void m(); }\n", "C", BoundKind.SAM),
+C("interface C { void m(); }\n", "C", BoundKind.INTF, MethodKind.ABSTRACT_M),
-D("interface D extends B { }\n", "D", BoundKind.ZAM),
+D("interface D extends B { }\n", "D", BoundKind.INTF, MethodKind.DEFAULT_M),
-E("interface E extends C { }\n", "E", BoundKind.SAM),
+E("interface E extends C { }\n", "E", BoundKind.INTF, MethodKind.ABSTRACT_M),
-F("interface F extends C { void g(); }\n", "F", BoundKind.INTF),
+F("interface F extends C { void g(); }\n", "F", BoundKind.INTF, MethodKind.ABSTRACT_G, MethodKind.ABSTRACT_M),
-G("interface G extends B { void g(); }\n", "G", BoundKind.SAM),
+G("interface G extends B { void g(); }\n", "G", BoundKind.INTF, MethodKind.ABSTRACT_G, MethodKind.DEFAULT_M),
-H("interface H extends A { void g(); }\n", "H", BoundKind.SAM),
+H("interface H extends A { void g(); }\n", "H", BoundKind.INTF, MethodKind.ABSTRACT_G),
 OBJECT("", "Object", BoundKind.CLASS),
 STRING("", "String", BoundKind.CLASS);
 String declStr;
 String typeStr;
 BoundKind boundKind;
+MethodKind[] methodKinds;
-private TypeKind(String declStr, String typeStr, BoundKind boundKind) {
+private TypeKind(String declStr, String typeStr, BoundKind boundKind, MethodKind... methodKinds) {
 this.declStr = declStr;
 this.typeStr = typeStr;
 this.boundKind = boundKind;
+this.methodKinds = methodKinds;
 }
 boolean compatibleSupertype(TypeKind tk) {
 if (tk == this) return true;
 switch (tk) {
 checkCount++;
 boolean errorExpected = !cInfo.wellFormed();
 if (ek.isFunctional) {
-//first bound must be a SAM
+List<MethodKind> mks = new ArrayList<>();
-errorExpected |= cInfo.types[0].boundKind != BoundKind.SAM;
+for (TypeKind tk : cInfo.types) {
-if (cInfo.types.length > 1) {
+if (tk.boundKind == BoundKind.CLASS) {
-//additional bounds must be ZAMs
+errorExpected = true;
-for (int i = 1; i < cInfo.types.length; i++) {
+break;
-errorExpected |= cInfo.types[i].boundKind != BoundKind.ZAM;
+} else {
-}
+mks = mergeMethods(mks, Arrays.asList(tk.methodKinds));
 }
+}
+int abstractCount = 0;
+for (MethodKind mk : mks) {
+if (mk.isAbstract) {
+abstractCount++;
+}
+}
+errorExpected |= abstractCount != 1;
 }
 if (errorExpected != diagChecker.errorFound) {
 throw new Error("invalid diagnostics for source:\n" +
 source.getCharContent(true) +
 "\nFound error: " + diagChecker.errorFound +
 "\nExpected error: " + errorExpected);
 }
 }
+List<MethodKind> mergeMethods(List<MethodKind> l1, List<MethodKind> l2) {
+List<MethodKind> mergedMethods = new ArrayList<>(l1);
+for (MethodKind mk2 : l2) {
+boolean add = !mergedMethods.contains(mk2);
+switch (mk2) {
+case ABSTRACT_G:
+add = add && !mergedMethods.contains(MethodKind.DEFAULT_G);
+break;
+case ABSTRACT_M:
+add = add && !mergedMethods.contains(MethodKind.DEFAULT_M);
+break;
+case DEFAULT_G:
+mergedMethods.remove(MethodKind.ABSTRACT_G);
+case DEFAULT_M:
+mergedMethods.remove(MethodKind.ABSTRACT_M);
+case NONE:
+add = false;
+break;
+}
+if (add) {
+mergedMethods.add(mk2);
+}
+}
+return mergedMethods;
+}
 static class DiagnosticChecker implements javax.tools.DiagnosticListener<JavaFileObject> {
 boolean errorFound;
 public void report(Diagnostic<? extends JavaFileObject> diagnostic) {

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: test/tools/javac/lambda/intersection/IntersectionTargetTypeTest.java

test/tools/javac/lambda/intersection/IntersectionTargetTypeTest.java