changeset 60824:db8ac4690d6a

8239544: Javac does not respect should-stop.ifNoError policy to stop after CompileState PARSE, ENTER and PROCESS Summary: JavaCompiler patch fixing its response to should-stop.ifNoError= option for PARSE, ENTER and PROCESS compiler states + new T8239544.java matrix regression test Reviewed-by: jlaskey, jlahoda
author asotona
date Wed, 08 Apr 2020 15:00:39 +0200
parents 13e20575efe1
children 8d9804c38e0c
files src/jdk.compiler/share/classes/com/sun/tools/javac/main/JavaCompiler.java test/langtools/tools/javac/main/T8239544.java
diffstat 2 files changed, 149 insertions(+), 26 deletions(-) [+]
line wrap: on
line diff
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/main/JavaCompiler.java	Wed Apr 08 08:13:22 2020 -0400
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/main/JavaCompiler.java	Wed Apr 08 15:00:39 2020 +0200
@@ -934,8 +934,8 @@
             // These method calls must be chained to avoid memory leaks
             processAnnotations(
                 enterTrees(
-                        stopIfError(CompileState.PARSE,
-                                initModules(stopIfError(CompileState.PARSE, parseFiles(sourceFileObjects))))
+                        stopIfError(CompileState.ENTER,
+                                initModules(stopIfError(CompileState.ENTER, parseFiles(sourceFileObjects))))
                 ),
                 classnames
             );
@@ -946,34 +946,36 @@
                 todo.retainFiles(inputFiles);
             }
 
-            switch (compilePolicy) {
-            case ATTR_ONLY:
-                attribute(todo);
-                break;
+            if (!CompileState.ATTR.isAfter(shouldStopPolicyIfNoError)) {
+                switch (compilePolicy) {
+                case ATTR_ONLY:
+                    attribute(todo);
+                    break;
 
-            case CHECK_ONLY:
-                flow(attribute(todo));
-                break;
+                case CHECK_ONLY:
+                    flow(attribute(todo));
+                    break;
 
-            case SIMPLE:
-                generate(desugar(flow(attribute(todo))));
-                break;
+                case SIMPLE:
+                    generate(desugar(flow(attribute(todo))));
+                    break;
 
-            case BY_FILE: {
-                    Queue<Queue<Env<AttrContext>>> q = todo.groupByFile();
-                    while (!q.isEmpty() && !shouldStop(CompileState.ATTR)) {
-                        generate(desugar(flow(attribute(q.remove()))));
+                case BY_FILE: {
+                        Queue<Queue<Env<AttrContext>>> q = todo.groupByFile();
+                        while (!q.isEmpty() && !shouldStop(CompileState.ATTR)) {
+                            generate(desugar(flow(attribute(q.remove()))));
+                        }
                     }
+                    break;
+
+                case BY_TODO:
+                    while (!todo.isEmpty())
+                        generate(desugar(flow(attribute(todo.remove()))));
+                    break;
+
+                default:
+                    Assert.error("unknown compile policy");
                 }
-                break;
-
-            case BY_TODO:
-                while (!todo.isEmpty())
-                    generate(desugar(flow(attribute(todo.remove()))));
-                break;
-
-            default:
-                Assert.error("unknown compile policy");
             }
         } catch (Abort ex) {
             if (devVerbose)
@@ -1179,7 +1181,7 @@
             // Unless all the errors are resolve errors, the errors were parse errors
             // or other errors during enter which cannot be fixed by running
             // any annotation processors.
-            if (unrecoverableError()) {
+            if (processAnnotations) {
                 deferredDiagnosticHandler.reportDeferredDiagnostics();
                 log.popDiagnosticHandler(deferredDiagnosticHandler);
                 return ;
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/langtools/tools/javac/main/T8239544.java	Wed Apr 08 15:00:39 2020 +0200
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2014, 2020, 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     8239544
+ * @summary Javac does not respect should-stop.ifNoError policy to stop after CompileState PARSE, ENTER and PROCESS
+ * @modules jdk.compiler/com.sun.tools.javac.code
+ *          jdk.compiler/com.sun.tools.javac.comp
+ *          jdk.compiler/com.sun.tools.javac.main
+ *          jdk.compiler/com.sun.tools.javac.processing
+ *          jdk.compiler/com.sun.tools.javac.tree
+ *          jdk.compiler/com.sun.tools.javac.util
+ * @run main T8239544
+ */
+import com.sun.tools.javac.code.Symbol;
+import com.sun.tools.javac.comp.CompileStates.CompileState;
+import com.sun.tools.javac.main.JavaCompiler;
+import com.sun.tools.javac.processing.JavacProcessingEnvironment;
+import com.sun.tools.javac.processing.PrintingProcessor;
+import com.sun.tools.javac.tree.JCTree;
+import com.sun.tools.javac.util.Context;
+import com.sun.tools.javac.util.List;
+import com.sun.tools.javac.util.Log;
+import com.sun.tools.javac.util.Options;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Collection;
+import java.util.Collections;
+import javax.annotation.processing.Processor;
+import javax.tools.JavaFileObject;
+import javax.tools.SimpleJavaFileObject;
+
+public class T8239544 {
+
+    private static final String[] TESTED_COMPILE_POLICIES = {"simple", "byfile", "bytodo"};
+    private static final CompileState[] TESTED_COMPILE_STATES =  {CompileState.INIT, CompileState.PARSE, CompileState.ENTER, CompileState.PROCESS,
+        CompileState.ATTR, CompileState.FLOW, CompileState.TRANSTYPES, CompileState.TRANSPATTERNS, CompileState.UNLAMBDA, CompileState.LOWER}; //everything except GENERATE
+
+    public static void main(String... args) throws IOException {
+        var f = new SimpleJavaFileObject(URI.create("TestLambdaClass.java"), JavaFileObject.Kind.SOURCE) {
+            @Override
+            public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
+                return "@Deprecated public class TestLambdaClass {{new Thread(() -> {});}}";
+            }
+        };
+        for (String compilePolicy : TESTED_COMPILE_POLICIES) {
+            for (CompileState stop : TESTED_COMPILE_STATES) {
+                var ctx = new Context();
+                var opt = Options.instance(ctx);
+                opt.put("should-stop.ifNoError", stop.name());
+                opt.put("compilePolicy", compilePolicy);
+                opt.put("debug.dumpLambdaToMethodStats", "true");
+                var compiler = new JavaCompiler(ctx) {
+
+                    private CompileState reachedState = CompileState.INIT;
+
+                    private CompileState getLatestState() {
+                        for (CompileState cs : compileStates.values()) {
+                            if (cs.isAfter(reachedState)) reachedState = cs;
+                        }
+                        return reachedState;
+                    }
+
+                    @Override
+                    public List<JCTree.JCCompilationUnit> parseFiles(Iterable<JavaFileObject> fileObjects, boolean force) {
+                        var res = super.parseFiles(fileObjects, force);
+                        if (res.size() > 0 && CompileState.ENTER.isAfter(reachedState)) reachedState = CompileState.PARSE;
+                        return res;
+                    }
+
+                    @Override
+                    public List<JCTree.JCCompilationUnit> enterTrees(List<JCTree.JCCompilationUnit> roots) {
+                        var res = super.enterTrees(roots);
+                        if (res.size() > 0 && CompileState.ENTER.isAfter(reachedState)) reachedState = CompileState.ENTER;
+                        return res;
+                    }
+
+                    @Override
+                    public void initProcessAnnotations(Iterable<? extends Processor> processors, Collection<? extends JavaFileObject> initialFiles, Collection<String> initialClassNames) {
+                        new JavacProcessingEnvironment(context) {
+                            @Override
+                            public boolean doProcessing(List<JCTree.JCCompilationUnit> roots, List<Symbol.ClassSymbol> classSymbols, Iterable<? extends Symbol.PackageSymbol> pckSymbols, Log.DeferredDiagnosticHandler deferredDiagnosticHandler) {
+                                if (roots.size() > 0 && CompileState.PROCESS.isAfter(reachedState)) reachedState = CompileState.PROCESS;
+                                return super.doProcessing(roots, classSymbols, pckSymbols, deferredDiagnosticHandler);
+                            }
+                        };
+                        super.initProcessAnnotations(processors, initialFiles, initialClassNames);
+                    }
+                };
+                compiler.compile(List.of(f), List.nil(), Collections.singleton(new PrintingProcessor()), List.nil());
+                if (compiler.errorCount() > 0) {
+                    throw new AssertionError();
+                }
+                if (!stop.equals(compiler.getLatestState())) {
+                    throw new AssertionError("Compiler with compilePolicy=" + compilePolicy + " expected to stop at " + stop + " but " + compiler.reachedState + " has been reached");
+                }
+            }
+        }
+    }
+}