changeset 51777:cecc2e10edf4

8207229: Trees.getScope crashes for broken lambda 8207230: Trees.getScope runs Analyzers Reviewed-by: vromero
author jlahoda
date Tue, 17 Jul 2018 14:28:56 +0200
parents 90144bc10fe6
children e34379f2a1c8
files src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Analyzer.java src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java test/langtools/tools/javac/api/TestGetScopeResult.java
diffstat 3 files changed, 118 insertions(+), 4 deletions(-) [+]
line wrap: on
line diff
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Analyzer.java	Tue Jul 17 08:10:48 2018 +0100
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Analyzer.java	Tue Jul 17 14:28:56 2018 +0200
@@ -474,7 +474,7 @@
      * Analyze an AST node; this involves collecting a list of all the nodes that needs rewriting,
      * and speculatively type-check the rewritten code to compare results against previously attributed code.
      */
-    void analyze(JCStatement statement, Env<AttrContext> env) {
+    protected void analyze(JCStatement statement, Env<AttrContext> env) {
         StatementScanner statementScanner = new StatementScanner(statement, env);
         statementScanner.scan();
 
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java	Tue Jul 17 08:10:48 2018 +0100
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java	Tue Jul 17 14:28:56 2018 +0200
@@ -71,6 +71,7 @@
 import static com.sun.tools.javac.code.Kinds.Kind.*;
 import static com.sun.tools.javac.code.TypeTag.*;
 import static com.sun.tools.javac.code.TypeTag.WILDCARD;
+import com.sun.tools.javac.comp.Analyzer.AnalyzerMode;
 import static com.sun.tools.javac.tree.JCTree.Tag.*;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticFlag;
 
@@ -390,7 +391,9 @@
     public Env<AttrContext> attribExprToTree(JCTree expr, Env<AttrContext> env, JCTree tree) {
         breakTree = tree;
         JavaFileObject prev = log.useSource(env.toplevel.sourcefile);
+        EnumSet<AnalyzerMode> analyzerModes = EnumSet.copyOf(analyzer.analyzerModes);
         try {
+            analyzer.analyzerModes.clear();
             attribExpr(expr, env);
         } catch (BreakAttr b) {
             return b.env;
@@ -403,6 +406,7 @@
         } finally {
             breakTree = null;
             log.useSource(prev);
+            analyzer.analyzerModes.addAll(analyzerModes);
         }
         return env;
     }
@@ -410,7 +414,9 @@
     public Env<AttrContext> attribStatToTree(JCTree stmt, Env<AttrContext> env, JCTree tree) {
         breakTree = tree;
         JavaFileObject prev = log.useSource(env.toplevel.sourcefile);
+        EnumSet<AnalyzerMode> analyzerModes = EnumSet.copyOf(analyzer.analyzerModes);
         try {
+            analyzer.analyzerModes.clear();
             attribStat(stmt, env);
         } catch (BreakAttr b) {
             return b.env;
@@ -423,6 +429,7 @@
         } finally {
             breakTree = null;
             log.useSource(prev);
+            analyzer.analyzerModes.addAll(analyzerModes);
         }
         return env;
     }
@@ -2753,7 +2760,7 @@
                     JCLambda lambda = (JCLambda)tree;
                     List<Type> argtypes = List.nil();
                     for (JCVariableDecl param : lambda.params) {
-                        argtypes = param.vartype != null ?
+                        argtypes = param.vartype != null && param.vartype.type != null ?
                                 argtypes.append(param.vartype.type) :
                                 argtypes.append(syms.errType);
                     }
--- a/test/langtools/tools/javac/api/TestGetScopeResult.java	Tue Jul 17 08:10:48 2018 +0100
+++ b/test/langtools/tools/javac/api/TestGetScopeResult.java	Tue Jul 17 14:28:56 2018 +0200
@@ -23,9 +23,12 @@
 
 /*
  * @test
- * @bug 8205418
+ * @bug 8205418 8207229 8207230
  * @summary Test the outcomes from Trees.getScope
- * @modules jdk.compiler
+ * @modules jdk.compiler/com.sun.tools.javac.api
+ *          jdk.compiler/com.sun.tools.javac.comp
+ *          jdk.compiler/com.sun.tools.javac.tree
+ *          jdk.compiler/com.sun.tools.javac.util
  */
 
 import java.io.IOException;
@@ -42,16 +45,26 @@
 import com.sun.source.tree.CompilationUnitTree;
 import com.sun.source.tree.LambdaExpressionTree;
 import com.sun.source.tree.Scope;
+import com.sun.source.tree.VariableTree;
 import com.sun.source.util.JavacTask;
 import com.sun.source.util.TreePath;
 import com.sun.source.util.TreePathScanner;
 import com.sun.source.util.Trees;
 
+import com.sun.tools.javac.api.JavacTool;
+import com.sun.tools.javac.comp.Analyzer;
+import com.sun.tools.javac.comp.AttrContext;
+import com.sun.tools.javac.comp.Env;
+import com.sun.tools.javac.tree.JCTree.JCStatement;
+import com.sun.tools.javac.util.Context;
+import com.sun.tools.javac.util.Context.Factory;
+
 import static javax.tools.JavaFileObject.Kind.SOURCE;
 
 public class TestGetScopeResult {
     public static void main(String... args) throws IOException {
         new TestGetScopeResult().run();
+        new TestGetScopeResult().testAnalyzerDisabled();
     }
 
     public void run() throws IOException {
@@ -109,6 +122,26 @@
         };
         doTest("class Test { void test() { cand1(s -> { }); } void cand1(I1 i) { } void cand1(I2 i, int i) { } interface I1 { public String test(String s); } interface I2 { public int test(CharSequence s); } }",
                multipleCandidates2);
+
+        String[] implicitExplicitConflict1 = {
+            ":t",
+            "s:java.lang.String",
+            "super:java.lang.Object",
+            "this:Test"
+        };
+
+        doTest("class Test { void test() { cand((var s, t) -> \"\"); } void cand(I i) { } interface I { public String test(String s); }  }",
+               implicitExplicitConflict1);
+
+        String[] implicitExplicitConflict2 = {
+            "s:<any>",
+            ":t",
+            "super:java.lang.Object",
+            "this:Test"
+        };
+
+        doTest("class Test { void test() { cand((t, var s) -> \"\"); } void cand(I i) { } interface I { public String test(String s); }  }",
+               implicitExplicitConflict2);
     }
 
     public void doTest(String code, String... expected) throws IOException {
@@ -151,5 +184,79 @@
         }
     }
 
+    void testAnalyzerDisabled() throws IOException {
+        JavacTool c = JavacTool.create();
+        try (StandardJavaFileManager fm = c.getStandardFileManager(null, null, null)) {
+            class MyFileObject extends SimpleJavaFileObject {
+                MyFileObject() {
+                    super(URI.create("myfo:///Test.java"), SOURCE);
+                }
+                @Override
+                public String getCharContent(boolean ignoreEncodingErrors) {
+                    return "class Test {" +
+                           "    void test() { cand(() -> { System.err.println(); }); }" +
+                           "    Runnable r = new Runnable() { public void test() { System.err.println(); } };" +
+                           "    void cand(Runnable r) { }" +
+                           "}";
+                }
+            }
+            Context ctx = new Context();
+            TestAnalyzer.preRegister(ctx);
+            JavacTask t = (JavacTask) c.getTask(null, fm, null, List.of("-XDfind=lambda"), null,
+                                                List.of(new MyFileObject()), ctx);
+            CompilationUnitTree cut = t.parse().iterator().next();
+            t.analyze();
+
+            TestAnalyzer analyzer = (TestAnalyzer) TestAnalyzer.instance(ctx);
+
+            if (!analyzer.analyzeCalled) {
+                throw new IllegalStateException("Analyzer didn't run!");
+            }
+
+            new TreePathScanner<Void, Void>() {
+                @Override
+                public Void visitLambdaExpression(LambdaExpressionTree node, Void p) {
+                    analyzer.analyzeCalled = false;
+                    Trees.instance(t).getScope(new TreePath(getCurrentPath(), node.getBody()));
+                    if (analyzer.analyzeCalled) {
+                        throw new IllegalStateException("Analyzer was run during getScope!");
+                    }
+                    return super.visitLambdaExpression(node, p);
+                }
+
+                @Override
+                public Void visitVariable(VariableTree node, Void p) {
+                    if (node.getInitializer() != null) {
+                        analyzer.analyzeCalled = false;
+                        TreePath tp = new TreePath(getCurrentPath(), node.getInitializer());
+                        Trees.instance(t).getScope(tp);
+                        if (analyzer.analyzeCalled) {
+                            throw new IllegalStateException("Analyzer was run during getScope!");
+                        }
+                    }
+                    return super.visitVariable(node, p);
+                }
+            }.scan(cut, null);
+        }
+    }
+
+    private static final class TestAnalyzer extends Analyzer {
+
+        public static void preRegister(Context context) {
+            context.put(analyzerKey, (Factory<Analyzer>) ctx -> new TestAnalyzer(ctx));
+        }
+
+        private boolean analyzeCalled;
+
+        public TestAnalyzer(Context context) {
+            super(context);
+        }
+
+        @Override
+        protected void analyze(JCStatement statement, Env<AttrContext> env) {
+            analyzeCalled = true;
+            super.analyze(statement, env);
+        }
+    }
 }