| /* | |
| * Copyright (c) 2013, 2022, Oracle and/or its affiliates. All rights reserved. | |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | |
| * | |
| * This code is free software; you can redistribute it and/or modify it | |
| * under the terms of the GNU General Public License version 2 only, as | |
| * published by the Free Software Foundation. | |
| * | |
| * This code is distributed in the hope that it will be useful, but WITHOUT | |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| * version 2 for more details (a copy is included in the LICENSE file that | |
| * accompanied this code). | |
| * | |
| * You should have received a copy of the GNU General Public License version | |
| * 2 along with this work; if not, write to the Free Software Foundation, | |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| * | |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | |
| * or visit www.oracle.com if you need additional information or have any | |
| * questions. | |
| */ | |
| /* | |
| * @test | |
| * @bug 8013789 | |
| * @summary Compiler should emit bridges in interfaces | |
| * @modules jdk.compiler/com.sun.tools.javac.api | |
| * jdk.compiler/com.sun.tools.javac.util | |
| */ | |
| import com.sun.source.util.JavacTask; | |
| import com.sun.tools.javac.api.ClientCodeWrapper.DiagnosticSourceUnwrapper; | |
| import com.sun.tools.javac.util.JCDiagnostic; | |
| import java.io.File; | |
| import java.io.PrintWriter; | |
| import java.net.URI; | |
| import java.util.ArrayList; | |
| import java.util.Arrays; | |
| import java.util.EnumSet; | |
| import java.util.List; | |
| import java.util.Set; | |
| import javax.tools.Diagnostic; | |
| import javax.tools.Diagnostic.Kind; | |
| import javax.tools.JavaCompiler; | |
| import javax.tools.JavaFileObject; | |
| import javax.tools.SimpleJavaFileObject; | |
| import javax.tools.ToolProvider; | |
| public class TestMetafactoryBridges { | |
| static int checkCount = 0; | |
| enum ClasspathKind { | |
| NONE(), | |
| B8(8, ClassKind.B), | |
| A8(8, ClassKind.A); | |
| int version; | |
| ClassKind ck; | |
| ClasspathKind() { | |
| this(-1, null); | |
| } | |
| ClasspathKind(int version, ClassKind ck) { | |
| this.version = version; | |
| this.ck = ck; | |
| } | |
| } | |
| enum PreferPolicy { | |
| SOURCE("-Xprefer:source"), | |
| NEWER("-Xprefer:newer"); | |
| String preferOpt; | |
| PreferPolicy(String preferOpt) { | |
| this.preferOpt = preferOpt; | |
| } | |
| } | |
| enum SourcepathKind { | |
| NONE, | |
| A(ClassKind.A), | |
| B(ClassKind.B), | |
| C(ClassKind.C), | |
| AB(ClassKind.A, ClassKind.B), | |
| BC(ClassKind.B, ClassKind.C), | |
| AC(ClassKind.A, ClassKind.C), | |
| ABC(ClassKind.A, ClassKind.B, ClassKind.C); | |
| List<ClassKind> sources; | |
| SourcepathKind(ClassKind... sources) { | |
| this.sources = Arrays.asList(sources); | |
| } | |
| } | |
| enum SourceSet { | |
| ALL() { | |
| @Override | |
| List<List<ClassKind>> permutations() { | |
| return Arrays.asList( | |
| Arrays.asList(ClassKind.A, ClassKind.B, ClassKind.C), | |
| Arrays.asList(ClassKind.A, ClassKind.B, ClassKind.C), | |
| Arrays.asList(ClassKind.B, ClassKind.A, ClassKind.C), | |
| Arrays.asList(ClassKind.B, ClassKind.C, ClassKind.A), | |
| Arrays.asList(ClassKind.C, ClassKind.A, ClassKind.B), | |
| Arrays.asList(ClassKind.C, ClassKind.B, ClassKind.A) | |
| ); | |
| } | |
| }, | |
| AC() { | |
| @Override | |
| List<List<ClassKind>> permutations() { | |
| return Arrays.asList( | |
| Arrays.asList(ClassKind.A, ClassKind.C), | |
| Arrays.asList(ClassKind.C, ClassKind.A) | |
| ); | |
| } | |
| }, | |
| C() { | |
| @Override | |
| List<List<ClassKind>> permutations() { | |
| return Arrays.asList(Arrays.asList(ClassKind.C)); | |
| } | |
| }; | |
| abstract List<List<ClassKind>> permutations(); | |
| } | |
| enum ClassKind { | |
| A("A", "interface A { Object m(); }"), | |
| B("B", "interface B extends A { Integer m(); }", A), | |
| C("C", "class C { B b = ()->42; }", A, B); | |
| String name; | |
| String source; | |
| ClassKind[] deps; | |
| ClassKind(String name, String source, ClassKind... deps) { | |
| this.name = name; | |
| this.source = source; | |
| this.deps = deps; | |
| } | |
| } | |
| public static void main(String... args) throws Exception { | |
| String SCRATCH_DIR = System.getProperty("user.dir"); | |
| //create default shared JavaCompiler - reused across multiple compilations | |
| JavaCompiler comp = ToolProvider.getSystemJavaCompiler(); | |
| int n = 0; | |
| for (SourceSet ss : SourceSet.values()) { | |
| for (List<ClassKind> sources : ss.permutations()) { | |
| for (SourcepathKind spKind : SourcepathKind.values()) { | |
| for (ClasspathKind cpKind : ClasspathKind.values()) { | |
| for (PreferPolicy pp : PreferPolicy.values()) { | |
| Set<ClassKind> deps = EnumSet.noneOf(ClassKind.class); | |
| if (cpKind.ck != null) { | |
| deps.add(cpKind.ck); | |
| } | |
| deps.addAll(sources); | |
| if (deps.size() < 3) continue; | |
| File testDir = new File(SCRATCH_DIR, "test" + n); | |
| testDir.mkdir(); | |
| try (PrintWriter debugWriter = new PrintWriter(new File(testDir, "debug.txt"))) { | |
| new TestMetafactoryBridges(testDir, sources, spKind, cpKind, pp, debugWriter).run(comp); | |
| n++; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| System.out.println("Total check executed: " + checkCount); | |
| } | |
| File testDir; | |
| List<ClassKind> sources; | |
| SourcepathKind spKind; | |
| ClasspathKind cpKind; | |
| PreferPolicy pp; | |
| PrintWriter debugWriter; | |
| DiagnosticChecker diagChecker; | |
| TestMetafactoryBridges(File testDir, List<ClassKind>sources, SourcepathKind spKind, | |
| ClasspathKind cpKind, PreferPolicy pp, PrintWriter debugWriter) { | |
| this.testDir = testDir; | |
| this.sources = sources; | |
| this.spKind = spKind; | |
| this.cpKind = cpKind; | |
| this.pp = pp; | |
| this.debugWriter = debugWriter; | |
| this.diagChecker = new DiagnosticChecker(); | |
| } | |
| class JavaSource extends SimpleJavaFileObject { | |
| final String source; | |
| public JavaSource(ClassKind ck) { | |
| super(URI.create(String.format("myfo:/%s.java", ck.name)), JavaFileObject.Kind.SOURCE); | |
| this.source = ck.source; | |
| } | |
| @Override | |
| public CharSequence getCharContent(boolean ignoreEncodingErrors) { | |
| return source; | |
| } | |
| } | |
| void run(JavaCompiler tool) throws Exception { | |
| File classesDir = new File(testDir, "classes"); | |
| File outDir = new File(testDir, "out"); | |
| File srcDir = new File(testDir, "src"); | |
| classesDir.mkdir(); | |
| outDir.mkdir(); | |
| srcDir.mkdir(); | |
| debugWriter.append(testDir.getName() + "\n"); | |
| debugWriter.append("sources = " + sources + "\n"); | |
| debugWriter.append("spKind = " + spKind + "\n"); | |
| debugWriter.append("cpKind = " + cpKind + "\n"); | |
| debugWriter.append("preferPolicy = " + pp.preferOpt + "\n"); | |
| //step 1 - prepare sources (older!!) | |
| debugWriter.append("Preparing sources\n"); | |
| for (ClassKind ck : spKind.sources) { | |
| //skip sources explicitly provided on command line | |
| if (!sources.contains(ck)) { | |
| debugWriter.append("Copy " + ck.name + ".java to" + srcDir.getAbsolutePath() + "\n"); | |
| File dest = new File(srcDir, ck.name + ".java"); | |
| PrintWriter pw = new PrintWriter(dest); | |
| pw.append(ck.source); | |
| pw.close(); | |
| } | |
| } | |
| //step 2 - prepare classes | |
| debugWriter.append("Preparing classes\n"); | |
| if (cpKind != ClasspathKind.NONE) { | |
| List<JavaSource> sources = new ArrayList<>(); | |
| ClassKind toRemove = null; | |
| sources.add(new JavaSource(cpKind.ck)); | |
| if (cpKind.ck.deps.length != 0) { | |
| //at most only one dependency | |
| toRemove = cpKind.ck.deps[0]; | |
| sources.add(new JavaSource(toRemove)); | |
| } | |
| JavacTask ct = (JavacTask)tool.getTask(debugWriter, null, null, | |
| Arrays.asList("-d", classesDir.getAbsolutePath(), "-source", String.valueOf(cpKind.version)), null, sources); | |
| try { | |
| ct.generate(); | |
| if (toRemove != null) { | |
| debugWriter.append("Remove " + toRemove.name + ".class from" + classesDir.getAbsolutePath() + "\n"); | |
| File fileToRemove = new File(classesDir, toRemove.name + ".class"); | |
| fileToRemove.delete(); | |
| } | |
| } catch (Throwable ex) { | |
| throw new AssertionError("Error thrown when generating side-classes"); | |
| } | |
| } | |
| //step 3 - compile | |
| debugWriter.append("Compiling test\n"); | |
| List<JavaSource> sourcefiles = new ArrayList<>(); | |
| for (ClassKind ck : sources) { | |
| sourcefiles.add(new JavaSource(ck)); | |
| } | |
| JavacTask ct = (JavacTask)tool.getTask(debugWriter, null, diagChecker, | |
| Arrays.asList("--debug=dumpLambdaToMethodStats", "-d", outDir.getAbsolutePath(), | |
| "-sourcepath", srcDir.getAbsolutePath(), | |
| "-classpath", classesDir.getAbsolutePath(), | |
| pp.preferOpt), null, sourcefiles); | |
| try { | |
| ct.generate(); | |
| } catch (Throwable ex) { | |
| throw new AssertionError("Error thrown when compiling test case"); | |
| } | |
| check(); | |
| } | |
| void check() { | |
| checkCount++; | |
| if (diagChecker.errorFound) { | |
| throw new AssertionError("Unexpected compilation failure"); | |
| } | |
| boolean altMetafactory = false; | |
| if (altMetafactory != diagChecker.altMetafactory) { | |
| throw new AssertionError("Bad metafactory detected - expected altMetafactory: " + altMetafactory + | |
| "\ntest: " + testDir); | |
| } | |
| } | |
| static class DiagnosticChecker implements javax.tools.DiagnosticListener<JavaFileObject> { | |
| boolean altMetafactory = false; | |
| boolean errorFound = false; | |
| public void report(Diagnostic<? extends JavaFileObject> diagnostic) { | |
| if (diagnostic.getKind() == Diagnostic.Kind.ERROR) { | |
| errorFound = true; | |
| } else if (statProcessor.matches(diagnostic)) { | |
| statProcessor.process(diagnostic); | |
| } | |
| } | |
| abstract class DiagnosticProcessor { | |
| List<String> codes; | |
| Diagnostic.Kind kind; | |
| public DiagnosticProcessor(Kind kind, String... codes) { | |
| this.codes = Arrays.asList(codes); | |
| this.kind = kind; | |
| } | |
| abstract void process(Diagnostic<? extends JavaFileObject> diagnostic); | |
| boolean matches(Diagnostic<? extends JavaFileObject> diagnostic) { | |
| return (codes.isEmpty() || codes.contains(diagnostic.getCode())) && | |
| diagnostic.getKind() == kind; | |
| } | |
| JCDiagnostic asJCDiagnostic(Diagnostic<? extends JavaFileObject> diagnostic) { | |
| if (diagnostic instanceof JCDiagnostic) { | |
| return (JCDiagnostic)diagnostic; | |
| } else if (diagnostic instanceof DiagnosticSourceUnwrapper) { | |
| return ((DiagnosticSourceUnwrapper)diagnostic).d; | |
| } else { | |
| throw new AssertionError("Cannot convert diagnostic to JCDiagnostic: " + diagnostic.getClass().getName()); | |
| } | |
| } | |
| } | |
| DiagnosticProcessor statProcessor = new DiagnosticProcessor(Kind.NOTE, | |
| "compiler.note.lambda.stat", | |
| "compiler.note.mref.stat", | |
| "compiler.note.mref.stat.1") { | |
| @Override | |
| void process(Diagnostic<? extends JavaFileObject> diagnostic) { | |
| JCDiagnostic diag = asJCDiagnostic(diagnostic); | |
| if ((Boolean)diag.getArgs()[0]) { | |
| altMetafactory = true; | |
| } | |
| } | |
| }; | |
| } | |
| } |