test/langtools/tools/javac/api/TestGetScopeResult.java

rev 50958 : 8207229: Trees.getScope crashes for broken lambda
8207230: Trees.getScope runs Analyzers
Reviewed-by: TBD

*** 21,33 ****
   * questions.
   */
  
  /*
   * @test
!  * @bug 8205418
   * @summary Test the outcomes from Trees.getScope
!  * @modules jdk.compiler
   */
  
  import java.io.IOException;
  import java.net.URI;
  import java.util.ArrayList;
--- 21,36 ----
   * questions.
   */
  
  /*
   * @test
!  * @bug 8205418 8207229 8207230
   * @summary Test the outcomes from Trees.getScope
!  * @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;
  import java.net.URI;
  import java.util.ArrayList;
*** 40,59 ****
--- 43,72 ----
  import javax.tools.ToolProvider;
  
  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 {
          String[] simpleLambda = {
              "s:java.lang.String",
*** 107,116 ****
--- 120,149 ----
              "super:java.lang.Object",
              "this:Test"
          };
          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 {
          JavaCompiler c = ToolProvider.getSystemJavaCompiler();
          try (StandardJavaFileManager fm = c.getStandardFileManager(null, null, null)) {
*** 149,155 ****
--- 182,262 ----
                  throw new IllegalStateException("Unexpected scope content: " + actual);
              }
          }
      }
  
+     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);
+         }
+     }
  }