7092965: javac should not close processorClassLoader before end of compilation

Reviewed-by: darcy

langtools/src/share/classes/com/sun/tools/javac/main/JavaCompiler.java

@@ -488,6 +488,10 @@ public class JavaCompiler implements ClassReader.SourceCompleter {
      */
     public Todo todo;
 
+    /** A list of items to be closed when the compilation is complete.
+     */
+    public List<Closeable> closeables = List.nil();
+
     /** Ordered list of compiler phases for each compilation unit. */
     public enum CompileState {
         PARSE(1),
@@ -1581,6 +1585,19 @@ public class JavaCompiler implements ClassReader.SourceCompleter {
             if (names != null && disposeNames)
                 names.dispose();
             names = null;
+
+            for (Closeable c: closeables) {
+                try {
+                    c.close();
+                } catch (IOException e) {
+                    // When javac uses JDK 7 as a baseline, this code would be
+                    // better written to set any/all exceptions from all the
+                    // Closeables as suppressed exceptions on the FatalError
+                    // that is thrown.
+                    JCDiagnostic msg = diagFactory.fragment("fatal.err.cant.close");
+                    throw new FatalError(msg, e);
+                }
+            }
         }
     }
 
@@ -1615,6 +1632,8 @@ public class JavaCompiler implements ClassReader.SourceCompleter {
         keepComments = prev.keepComments;
         start_msec = prev.start_msec;
         hasBeenUsed = true;
+        closeables = prev.closeables;
+        prev.closeables = List.nil();
     }
 
     public static void enableLogging() {

langtools/src/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java

@@ -225,6 +225,11 @@ public class JavacProcessingEnvironment implements ProcessingEnvironment, Closea
                     ? fileManager.getClassLoader(ANNOTATION_PROCESSOR_PATH)
                     : fileManager.getClassLoader(CLASS_PATH);
 
+                if (processorClassLoader != null && processorClassLoader instanceof Closeable) {
+                    JavaCompiler compiler = JavaCompiler.instance(context);
+                    compiler.closeables = compiler.closeables.prepend((Closeable) processorClassLoader);
+                }
+
                 /*
                  * If the "-processor" option is used, search the appropriate
                  * path for the named class.  Otherwise, use a service
@@ -1211,14 +1216,6 @@ public class JavacProcessingEnvironment implements ProcessingEnvironment, Closea
         if (discoveredProcs != null) // Make calling close idempotent
             discoveredProcs.close();
         discoveredProcs = null;
-        if (processorClassLoader != null && processorClassLoader instanceof Closeable) {
-            try {
-                ((Closeable) processorClassLoader).close();
-            } catch (IOException e) {
-                JCDiagnostic msg = diags.fragment("fatal.err.cant.close.loader");
-                throw new FatalError(msg, e);
-            }
-        }
     }
 
     private List<ClassSymbol> getTopLevelClasses(List<? extends JCCompilationUnit> units) {

langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties

@@ -895,8 +895,8 @@ compiler.misc.fatal.err.cant.locate.field=\
 compiler.misc.fatal.err.cant.locate.ctor=\
     Fatal Error: Unable to find constructor for {0}
 
-compiler.misc.fatal.err.cant.close.loader=\
+compiler.misc.fatal.err.cant.close=\
-    Fatal Error: Cannot close class loader for annotation processors
+    Fatal Error: Cannot close compiler resources
 
 #####
 

langtools/test/tools/javac/diags/examples.not-yet.txt

@@ -60,7 +60,7 @@ compiler.misc.class.file.wrong.class
 compiler.misc.fatal.err.cant.locate.ctor                # Resolve, from Lower
 compiler.misc.fatal.err.cant.locate.field               # Resolve, from Lower
 compiler.misc.fatal.err.cant.locate.meth                # Resolve, from Lower
-compiler.misc.fatal.err.cant.close.loader               # JavacProcessingEnvironment
+compiler.misc.fatal.err.cant.close	                # JavaCompiler
 compiler.misc.file.does.not.contain.package
 compiler.misc.illegal.start.of.class.file
 compiler.misc.kindname.annotation

langtools/test/tools/javac/processing/loader/testClose/TestClose.java

@@ -0,0 +1,229 @@
+/*
+ * Copyright (c) 2011, 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 7092965
+ * @summary javac should not close processorClassLoader before end of compilation
+ */
+
+import com.sun.source.util.JavacTask;
+import com.sun.source.util.TaskEvent;
+import com.sun.source.util.TaskListener;
+import com.sun.tools.javac.api.ClientCodeWrapper.Trusted;
+import com.sun.tools.javac.api.JavacTool;
+import com.sun.tools.javac.processing.JavacProcessingEnvironment;
+import com.sun.tools.javac.util.Context;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.tools.JavaFileObject;
+import javax.tools.SimpleJavaFileObject;
+import javax.tools.StandardJavaFileManager;
+import javax.tools.StandardLocation;
+import javax.tools.ToolProvider;
+
+/*
+ * The test compiles an annotation processor and a helper class into a
+ * custom classes directory.
+ *
+ * It then uses them while compiling a dummy file, with the custom classes
+ * directory on the processor path, thus guaranteeing that references to
+ * these class are satisfied by the processor class loader.
+ *
+ * The annotation processor uses the javac TaskListener to run code
+ * after annotation processing has completed, to verify that the classloader
+ * is not closed until the end of the compilation.
+ */
+
+@Trusted // avoids use of ClientCodeWrapper
+public class TestClose implements TaskListener {
+    public static final String annoProc =
+        "import java.util.*;\n" +
+        "import javax.annotation.processing.*;\n" +
+        "import javax.lang.model.*;\n" +
+        "import javax.lang.model.element.*;\n" +
+        "import com.sun.source.util.*;\n" +
+        "import com.sun.tools.javac.processing.*;\n" +
+        "import com.sun.tools.javac.util.*;\n" +
+        "@SupportedAnnotationTypes(\"*\")\n" +
+        "public class AnnoProc extends AbstractProcessor {\n" +
+        "    @Override\n" +
+        "    public SourceVersion getSupportedSourceVersion() {\n" +
+        "        return SourceVersion.latest();\n" +
+        "    }\n" +
+        "    @Override\n" +
+        "    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {\n" +
+        "        System.out.println(\"in AnnoProc.process\");\n" +
+        "        final ClassLoader cl = getClass().getClassLoader();\n" +
+        "        if (roundEnv.processingOver()) {\n" +
+        "            TestClose.add(processingEnv, new Runnable() {\n" +
+        "                public void run() {\n" +
+        "                    System.out.println(getClass().getName() + \": run()\");\n" +
+        "                    try {\n" +
+        "                    cl.loadClass(\"Callback\")\n" +
+        "                        .asSubclass(Runnable.class)\n" +
+        "                        .newInstance()\n" +
+        "                        .run();\n" +
+        "                    } catch (ReflectiveOperationException e) {\n" +
+        "                        throw new Error(e);\n" +
+        "                    }\n" +
+        "                }\n" +
+        "            });\n" +
+        "        }\n" +
+        "        return true;\n" +
+        "    }\n" +
+        "}\n";
+
+    public static final String callback =
+        "public class Callback implements Runnable {\n" +
+        "    public void run() {\n" +
+        "        System.out.println(getClass().getName() + \": run()\");\n" +
+        "    }\n" +
+        "}";
+
+    public static void main(String... args) throws Exception {
+        new TestClose().run();
+    }
+
+    void run() throws IOException {
+        JavacTool tool = (JavacTool) ToolProvider.getSystemJavaCompiler();
+        StandardJavaFileManager fm = tool.getStandardFileManager(null, null, null);
+
+        File classes = new File("classes");
+        classes.mkdirs();
+        File extraClasses = new File("extraClasses");
+        extraClasses.mkdirs();
+
+        System.out.println("compiling classes to extraClasses");
+        {   // setup class in extraClasses
+            fm.setLocation(StandardLocation.CLASS_OUTPUT,
+                    Collections.singleton(extraClasses));
+            List<? extends JavaFileObject> files = Arrays.asList(
+                    new MemFile("AnnoProc.java", annoProc),
+                    new MemFile("Callback.java", callback));
+            JavacTask task = tool.getTask(null, fm, null, null, null, files);
+            check(task.call());
+        }
+
+        System.out.println("compiling dummy to classes with anno processor");
+        {   // use that class in a TaskListener after processing has completed
+            PrintStream prev = System.out;
+            String out;
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            try (PrintStream ps = new PrintStream(baos)) {
+                System.setOut(ps);
+                File testClasses = new File(System.getProperty("test.classes"));
+                fm.setLocation(StandardLocation.CLASS_OUTPUT,
+                        Collections.singleton(classes));
+                fm.setLocation(StandardLocation.ANNOTATION_PROCESSOR_PATH,
+                        Arrays.asList(extraClasses, testClasses));
+                List<? extends JavaFileObject> files = Arrays.asList(
+                        new MemFile("my://dummy", "class Dummy { }"));
+                List<String> options = Arrays.asList("-processor", "AnnoProc");
+                JavacTask task = tool.getTask(null, fm, null, options, null, files);
+                task.setTaskListener(this);
+                check(task.call());
+            } finally {
+                System.setOut(prev);
+                out = baos.toString();
+                if (!out.isEmpty())
+                    System.out.println(out);
+            }
+            check(out.contains("AnnoProc$1: run()"));
+            check(out.contains("Callback: run()"));
+        }
+    }
+
+    @Override
+    public void started(TaskEvent e) {
+        System.out.println("Started: " + e);
+    }
+
+    @Override
+    public void finished(TaskEvent e) {
+        System.out.println("Finished: " + e);
+        if (e.getKind() == TaskEvent.Kind.ANALYZE) {
+            for (Runnable r: runnables) {
+                System.out.println("running " + r);
+                r.run();
+            }
+        }
+    }
+
+    void check(boolean b) {
+        if (!b)
+            throw new AssertionError();
+    }
+
+
+    public static void add(ProcessingEnvironment env, Runnable r) {
+        try {
+            Context c = ((JavacProcessingEnvironment) env).getContext();
+            Object o = c.get(TaskListener.class);
+            // The TaskListener is an instanceof TestClose, but when using the
+            // default class loaders. the taskListener uses a different
+            // instance of Class<TestClose> than the anno processor.
+            // If you try to evaluate
+            //      TestClose tc = (TestClose) (o).
+            // you get the following somewhat confusing error:
+            //   java.lang.ClassCastException: TestClose cannot be cast to TestClose
+            // The workaround is to access the fields of TestClose with reflection.
+            Field f = o.getClass().getField("runnables");
+            @SuppressWarnings("unchecked")
+            List<Runnable> runnables = (List<Runnable>) f.get(o);
+            runnables.add(r);
+        } catch (Throwable t) {
+            System.err.println(t);
+        }
+    }
+
+    public List<Runnable> runnables = new ArrayList<>();
+
+    class MemFile extends SimpleJavaFileObject {
+        public final String text;
+
+        MemFile(String name, String text) {
+            super(URI.create(name), JavaFileObject.Kind.SOURCE);
+            this.text = text;
+        }
+
+        @Override
+        public String getName() {
+            return uri.toString();
+        }
+
+        @Override
+        public String getCharContent(boolean ignoreEncodingErrors) {
+            return text;
+        }
+    }
+}

langtools/test/tools/javac/processing/loader/testClose/TestClose2.java

@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 2011, 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 7092965
+ * @summary javac should not close processorClassLoader before end of compilation
+ */
+
+import com.sun.source.util.JavacTask;
+import com.sun.source.util.TaskEvent;
+import com.sun.source.util.TaskListener;
+import com.sun.tools.javac.api.JavacTool;
+import com.sun.tools.javac.file.JavacFileManager;
+import com.sun.tools.javac.util.Context;
+import java.io.File;
+import java.io.IOException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+import javax.annotation.processing.AbstractProcessor;
+import javax.annotation.processing.Messager;
+import javax.annotation.processing.RoundEnvironment;
+import javax.annotation.processing.SupportedAnnotationTypes;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.TypeElement;
+import javax.tools.Diagnostic;
+import javax.tools.JavaFileObject;
+import javax.tools.StandardJavaFileManager;
+import javax.tools.StandardLocation;
+import javax.tools.ToolProvider;
+
+@SupportedAnnotationTypes("*")
+public class TestClose2 extends AbstractProcessor implements TaskListener {
+
+    public static void main(String... args) throws Exception {
+        new TestClose2().run();
+    }
+
+    void run() throws IOException {
+        File testSrc = new File(System.getProperty("test.src"));
+        File testClasses = new File(System.getProperty("test.classes"));
+
+        JavacTool tool = (JavacTool) ToolProvider.getSystemJavaCompiler();
+        final ClassLoader cl = getClass().getClassLoader();
+        Context c = new Context();
+        StandardJavaFileManager fm = new JavacFileManager(c, true, null) {
+            @Override
+            protected ClassLoader getClassLoader(URL[] urls) {
+                return new URLClassLoader(urls, cl) {
+                    @Override
+                    public void close() throws IOException {
+                        System.err.println(getClass().getName() + " closing");
+                        TestClose2.this.closedCount++;
+                        TestClose2.this.closedIsLast = true;
+                        super.close();
+                    }
+                };
+            }
+        };
+
+        fm.setLocation(StandardLocation.CLASS_OUTPUT,
+                Collections.singleton(new File(".")));
+        fm.setLocation(StandardLocation.ANNOTATION_PROCESSOR_PATH,
+                Collections.singleton(testClasses));
+        Iterable<? extends JavaFileObject> files =
+                fm.getJavaFileObjects(new File(testSrc, TestClose2.class.getName() + ".java"));
+        List<String> options = Arrays.asList(
+                "-processor", TestClose2.class.getName());
+
+        JavacTask task = tool.getTask(null, fm, null, options, null, files);
+        task.setTaskListener(this);
+
+        if (!task.call())
+            throw new Error("compilation failed");
+
+        if (closedCount == 0)
+            throw new Error("no closing message");
+        else if (closedCount > 1)
+            throw new Error(closedCount + " closed messages");
+
+        if (!closedIsLast)
+            throw new Error("closing message not last");
+    }
+
+    // AbstractProcessor methods
+
+    @Override
+    public SourceVersion getSupportedSourceVersion() {
+        return SourceVersion.latest();
+    }
+
+    @Override
+    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
+        Messager messager = processingEnv.getMessager();
+        messager.printMessage(Diagnostic.Kind.NOTE, "processing");
+        return true;
+    }
+
+    // TaskListener methods
+
+    @Override
+    public void started(TaskEvent e) {
+        System.err.println("Started: " + e);
+        closedIsLast = false;
+    }
+
+    @Override
+    public void finished(TaskEvent e) {
+        System.err.println("Finished: " + e);
+        closedIsLast = false;
+    }
+
+    //
+
+    int closedCount = 0;
+    boolean closedIsLast = false;
+}