6983239: TreeScanner does not scan default value for method

Reviewed-by: mcimadamore

src/share/classes/com/sun/source/util/TreeScanner.java

@@ -141,6 +141,7 @@ public class TreeScanner<R,P> implements TreeVisitor<R,P> {
         r = scanAndReduce(node.getReceiverAnnotations(), p, r);
         r = scanAndReduce(node.getThrows(), p, r);
         r = scanAndReduce(node.getBody(), p, r);
+        r = scanAndReduce(node.getDefaultValue(), p, r);
         return r;
     }
 

test/tools/javac/api/T6392782.java

@@ -47,12 +47,12 @@ public class T6392782 {
         check(scanner, 6, scanner.scan(trees, null));
 
         CountNodes nodeCounter = new CountNodes();
-        // 383 nodes with the regular parser; 384 nodes with EndPosParser
-        // We automatically swith to EndPosParser when calling JavacTask.parse()
-        check(nodeCounter, 384, nodeCounter.scan(trees, null));
+        // 359 nodes with the regular parser; 360 nodes with EndPosParser
+        // We automatically switch to EndPosParser when calling JavacTask.parse()
+        check(nodeCounter, 360, nodeCounter.scan(trees, null));
 
         CountIdentifiers idCounter = new CountIdentifiers();
-        check(idCounter, 106, idCounter.scan(trees, null));
+        check(idCounter, 107, idCounter.scan(trees, null));
     }
 
     private static void check(TreeScanner<?,?> scanner, int expect, int found) {
@@ -73,10 +73,11 @@ public class T6392782 {
         }
     }
 
-    // example from TreeScanner javadoc
     static class CountNodes extends TreeScanner<Integer,Void> {
         @Override
         public Integer scan(Tree node, Void p) {
+            if (node == null)
+                return 0;
             Integer n = super.scan(node, p);
             return (n == null ? 0 : n) + 1;
         }

test/tools/javac/tree/TreeScannerTest.java → test/tools/javac/tree/AbstractTreeScannerTest.java

@@ -21,57 +21,20 @@
  * questions.
  */
 
-
-/**
- * Utility and test program to check javac's internal TreeScanner class.
- * The program can be run standalone, or as a jtreg test.  For info on
- * command line args, run program with no args.
- *
- * <p>
- * jtreg: Note that by using the -r switch in the test description below, this test
- * will process all java files in the langtools/test directory, thus implicitly
- * covering any new language features that may be tested in this test suite.
- */
-
-/*
- * @test
- * @bug 6923080
- * @summary TreeScanner.visitNewClass should scan tree.typeargs
- * @run main TreeScannerTest -q -r .
- */
-
 import java.io.*;
 import java.lang.reflect.*;
 import java.util.*;
 import javax.tools.*;
 
 import com.sun.source.tree.CompilationUnitTree;
+import com.sun.source.tree.Tree;
 import com.sun.source.util.JavacTask;
 import com.sun.tools.javac.api.JavacTool;
-import com.sun.tools.javac.tree.*;
-import com.sun.tools.javac.tree.JCTree.*;
+import com.sun.tools.javac.tree.JCTree;
+import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;
 import com.sun.tools.javac.util.List;
 
-public class TreeScannerTest {
-    /**
-     * Main entry point.
-     * If test.src is set, program runs in jtreg mode, and will throw an Error
-     * if any errors arise, otherwise System.exit will be used. In jtreg mode,
-     * the default base directory for file args is the value of ${test.src}.
-     * In jtreg mode, the -r option can be given to change the default base
-     * directory to the root test directory.
-     */
-    public static void main(String... args) {
-        String testSrc = System.getProperty("test.src");
-        File baseDir = (testSrc == null) ? null : new File(testSrc);
-        boolean ok = new TreeScannerTest().run(baseDir, args);
-        if (!ok) {
-            if (testSrc != null)  // jtreg mode
-                throw new Error("failed");
-            else
-                System.exit(1);
-        }
-    }
+public abstract class AbstractTreeScannerTest {
 
     /**
      * Run the program. A base directory can be provided for file arguments.
@@ -120,6 +83,7 @@ public class TreeScannerTest {
 
         if (fileCount != 1)
             System.err.println(fileCount + " files read");
+        System.err.println(treeCount + " tree nodes compared");
         if (errors > 0)
             System.err.println(errors + " errors");
 
@@ -132,7 +96,7 @@ public class TreeScannerTest {
      */
     void usage(PrintStream out) {
         out.println("Usage:");
-        out.println("  java TreeScannerTest options... files...");
+        out.println("  java " + getClass().getName() + " options... files...");
         out.println("");
         out.println("where options include:");
         out.println("-q        Quiet: don't report on inapplicable files");
@@ -162,8 +126,7 @@ public class TreeScannerTest {
                 if (verbose)
                     System.err.println(file);
                 fileCount++;
-                ScanTester t = new ScanTester();
-                t.test(read(file));
+                treeCount += test(read(file));
             } catch (ParseException e) {
                 if (!quiet) {
                     error("Error parsing " + file + "\n" + e.getMessage());
@@ -178,6 +141,8 @@ public class TreeScannerTest {
             error("File " + file + " ignored");
     }
 
+    abstract int test(JCCompilationUnit t);
+
     /**
      * Read a file.
      * @param file the file to be read
@@ -222,20 +187,24 @@ public class TreeScannerTest {
      *  @param t    the tree node
      *  @param label an indication of the error
      */
-    void error(JavaFileObject file, JCTree t, String msg) {
+    void error(JavaFileObject file, Tree tree, String msg) {
+        JCTree t = (JCTree) tree;
         error(file.getName() + ":" + getLine(file, t) + ": " + msg + " " + trim(t, 64));
     }
 
     /**
      * Get a trimmed string for a tree node, with normalized white space and limited length.
      */
-    String trim(JCTree t, int len) {
+    String trim(Tree tree, int len) {
+        JCTree t = (JCTree) tree;
         String s = t.toString().replaceAll("[\r\n]+", " ").replaceAll(" +", " ");
         return (s.length() < len) ? s : s.substring(0, len);
     }
 
     /** Number of files that have been analyzed. */
     int fileCount;
+    /** Number of trees that have been successfully compared. */
+    int treeCount;
     /** Number of errors reported. */
     int errors;
     /** Flag: don't report irrelevant files. */
@@ -243,78 +212,6 @@ public class TreeScannerTest {
     /** Flag: report files as they are processed. */
     boolean verbose;
 
-    /**
-     * Main class for testing operation of tree scanner.
-     * The set of nodes found by the scanner are compared
-     * against the set of nodes found by reflection.
-     */
-    private class ScanTester extends TreeScanner {
-        /** Main entry method for the class. */
-        void test(JCCompilationUnit tree) {
-            sourcefile = tree.sourcefile;
-            found = new HashSet<JCTree>();
-            scan(tree);
-            expect = new HashSet<JCTree>();
-            reflectiveScan(tree);
-            if (found.equals(expect))
-                return;
-
-            error("Differences found for " + tree.sourcefile.getName());
-
-            if (found.size() != expect.size())
-                error("Size mismatch; found: " + found.size() + ", expected: " + expect.size());
-
-            Set<JCTree> missing = new HashSet<JCTree>();
-            missing.addAll(expect);
-            missing.removeAll(found);
-            for (JCTree t: missing)
-                error(tree.sourcefile, t, "missing");
-
-            Set<JCTree> excess = new HashSet<JCTree>();
-            excess.addAll(found);
-            excess.removeAll(expect);
-            for (JCTree t: excess)
-                error(tree.sourcefile, t, "unexpected");
-        }
-
-        /** Record all tree nodes found by scanner. */
-        @Override
-        public void scan(JCTree tree) {
-            if (tree == null)
-                return;
-            System.err.println("FOUND: " + tree.getTag() + " " + trim(tree, 64));
-            found.add(tree);
-            super.scan(tree);
-        }
-
-        /** record all tree nodes found by reflection. */
-        public void reflectiveScan(Object o) {
-            if (o == null)
-                return;
-            if (o instanceof JCTree) {
-                JCTree tree = (JCTree) o;
-                System.err.println("EXPECT: " + tree.getTag() + " " + trim(tree, 64));
-                expect.add(tree);
-                for (Field f: getFields(tree)) {
-                    try {
-                        //System.err.println("FIELD: " + f.getName());
-                        reflectiveScan(f.get(tree));
-                    } catch (IllegalAccessException e) {
-                        error(e.toString());
-                    }
-                }
-            } else if (o instanceof List) {
-                List<?> list = (List<?>) o;
-                for (Object item: list)
-                    reflectiveScan(item);
-            } else
-                error("unexpected item: " + o);
-        }
-
-        JavaFileObject sourcefile;
-        Set<JCTree> found;
-        Set<JCTree> expect;
-    }
 
     /**
      * Thrown when errors are found parsing a java file.

test/tools/javac/tree/JavacTreeScannerTest.java

+/*
+ * Copyright (c) 2010, 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.
+ */
+
+
+/**
+ * Utility and test program to check javac's internal TreeScanner class.
+ * The program can be run standalone, or as a jtreg test.  For info on
+ * command line args, run program with no args.
+ *
+ * <p>
+ * jtreg: Note that by using the -r switch in the test description below, this test
+ * will process all java files in the langtools/test directory, thus implicitly
+ * covering any new language features that may be tested in this test suite.
+ */
+
+/*
+ * @test
+ * @bug 6923080
+ * @summary TreeScanner.visitNewClass should scan tree.typeargs
+ * @build AbstractTreeScannerTest JavacTreeScannerTest
+ * @run main JavacTreeScannerTest -q -r .
+ */
+
+import java.io.*;
+import java.lang.reflect.*;
+import java.util.*;
+import javax.tools.*;
+
+import com.sun.tools.javac.tree.JCTree;
+import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;
+import com.sun.tools.javac.tree.TreeScanner;
+import com.sun.tools.javac.util.List;
+
+public class JavacTreeScannerTest extends AbstractTreeScannerTest {
+    /**
+     * Main entry point.
+     * If test.src is set, program runs in jtreg mode, and will throw an Error
+     * if any errors arise, otherwise System.exit will be used. In jtreg mode,
+     * the default base directory for file args is the value of ${test.src}.
+     * In jtreg mode, the -r option can be given to change the default base
+     * directory to the root test directory.
+     */
+    public static void main(String... args) {
+        String testSrc = System.getProperty("test.src");
+        File baseDir = (testSrc == null) ? null : new File(testSrc);
+        boolean ok = new JavacTreeScannerTest().run(baseDir, args);
+        if (!ok) {
+            if (testSrc != null)  // jtreg mode
+                throw new Error("failed");
+            else
+                System.exit(1);
+        }
+    }
+
+    int test(JCCompilationUnit tree) {
+        return new ScanTester().test(tree);
+    }
+
+    /**
+     * Main class for testing operation of tree scanner.
+     * The set of nodes found by the scanner are compared
+     * against the set of nodes found by reflection.
+     */
+    private class ScanTester extends TreeScanner {
+        /** Main entry method for the class. */
+        int test(JCCompilationUnit tree) {
+            sourcefile = tree.sourcefile;
+            found = new HashSet<JCTree>();
+            scan(tree);
+            expect = new HashSet<JCTree>();
+            reflectiveScan(tree);
+            if (found.equals(expect)) {
+                System.err.println(found.size() + " trees compared OK");
+                return found.size();
+            }
+
+            error("Differences found for " + tree.sourcefile.getName());
+
+            if (found.size() != expect.size())
+                error("Size mismatch; found: " + found.size() + ", expected: " + expect.size());
+
+            Set<JCTree> missing = new HashSet<JCTree>();
+            missing.addAll(expect);
+            missing.removeAll(found);
+            for (JCTree t: missing)
+                error(tree.sourcefile, t, "missing");
+
+            Set<JCTree> excess = new HashSet<JCTree>();
+            excess.addAll(found);
+            excess.removeAll(expect);
+            for (JCTree t: excess)
+                error(tree.sourcefile, t, "unexpected");
+
+            return 0;
+        }
+
+        /** Record all tree nodes found by scanner. */
+        @Override
+        public void scan(JCTree tree) {
+            if (tree == null)
+                return;
+            System.err.println("FOUND: " + tree.getTag() + " " + trim(tree, 64));
+            found.add(tree);
+            super.scan(tree);
+        }
+
+        /** record all tree nodes found by reflection. */
+        public void reflectiveScan(Object o) {
+            if (o == null)
+                return;
+            if (o instanceof JCTree) {
+                JCTree tree = (JCTree) o;
+                System.err.println("EXPECT: " + tree.getTag() + " " + trim(tree, 64));
+                expect.add(tree);
+                for (Field f: getFields(tree)) {
+                    try {
+                        //System.err.println("FIELD: " + f.getName());
+                        reflectiveScan(f.get(tree));
+                    } catch (IllegalAccessException e) {
+                        error(e.toString());
+                    }
+                }
+            } else if (o instanceof List) {
+                List<?> list = (List<?>) o;
+                for (Object item: list)
+                    reflectiveScan(item);
+            } else
+                error("unexpected item: " + o);
+        }
+
+        JavaFileObject sourcefile;
+        Set<JCTree> found;
+        Set<JCTree> expect;
+    }
+}

test/tools/javac/tree/SourceTreeScannerTest.java

+/*
+ * Copyright (c) 2010, 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.
+ */
+
+
+/**
+ * Utility and test program to check javac's internal TreeScanner class.
+ * The program can be run standalone, or as a jtreg test.  For info on
+ * command line args, run program with no args.
+ *
+ * <p>
+ * jtreg: Note that by using the -r switch in the test description below, this test
+ * will process all java files in the langtools/test directory, thus implicitly
+ * covering any new language features that may be tested in this test suite.
+ */
+
+/*
+ * @test
+ * @bug 6923080
+ * @summary TreeScanner.visitNewClass should scan tree.typeargs
+ * @build AbstractTreeScannerTest SourceTreeScannerTest
+ * @run main SourceTreeScannerTest -q -r .
+ */
+
+import java.io.*;
+import java.lang.reflect.*;
+import java.util.*;
+import javax.tools.*;
+
+import com.sun.source.tree.Tree;
+import com.sun.source.util.TreeScanner;
+import com.sun.tools.javac.tree.JCTree;
+import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;
+import com.sun.tools.javac.tree.JCTree.TypeBoundKind;
+import com.sun.tools.javac.util.List;
+
+public class SourceTreeScannerTest extends AbstractTreeScannerTest {
+    /**
+     * Main entry point.
+     * If test.src is set, program runs in jtreg mode, and will throw an Error
+     * if any errors arise, otherwise System.exit will be used. In jtreg mode,
+     * the default base directory for file args is the value of ${test.src}.
+     * In jtreg mode, the -r option can be given to change the default base
+     * directory to the root test directory.
+     */
+    public static void main(String... args) {
+        String testSrc = System.getProperty("test.src");
+        File baseDir = (testSrc == null) ? null : new File(testSrc);
+        boolean ok = new SourceTreeScannerTest().run(baseDir, args);
+        if (!ok) {
+            if (testSrc != null)  // jtreg mode
+                throw new Error("failed");
+            else
+                System.exit(1);
+        }
+    }
+
+    int test(JCCompilationUnit tree) {
+        return new ScanTester().test(tree);
+    }
+
+    /**
+     * Main class for testing operation of tree scanner.
+     * The set of nodes found by the scanner are compared
+     * against the set of nodes found by reflection.
+     */
+    private class ScanTester extends TreeScanner<Void,Void> {
+        /** Main entry method for the class. */
+        int test(JCCompilationUnit tree) {
+            sourcefile = tree.sourcefile;
+            found = new HashSet<Tree>();
+            scan(tree, null);
+            expect = new HashSet<Tree>();
+            reflectiveScan(tree);
+            if (found.equals(expect)) {
+                System.err.println(found.size() + " trees compared OK");
+                return found.size();
+            }
+
+            error("Differences found for " + tree.sourcefile.getName());
+
+            if (found.size() != expect.size())
+                error("Size mismatch; found: " + found.size() + ", expected: " + expect.size());
+
+            Set<Tree> missing = new HashSet<Tree>();
+            missing.addAll(expect);
+            missing.removeAll(found);
+            for (Tree t: missing)
+                error(tree.sourcefile, t, "missing");
+
+            Set<Tree> excess = new HashSet<Tree>();
+            excess.addAll(found);
+            excess.removeAll(expect);
+            for (Tree t: excess)
+                error(tree.sourcefile, t, "unexpected");
+
+            return 0;
+        }
+
+        /** Record all tree nodes found by scanner. */
+        @Override
+        public Void scan(Tree tree, Void ignore) {
+            if (tree == null)
+                return null;
+            System.err.println("FOUND: " + tree.getKind() + " " + trim(tree, 64));
+            found.add(tree);
+            return super.scan(tree, ignore);
+        }
+
+        /** record all tree nodes found by reflection. */
+        public void reflectiveScan(Object o) {
+            if (o == null)
+                return;
+            if (o instanceof JCTree) {
+                JCTree tree = (JCTree) o;
+                System.err.println("EXPECT: " + tree.getKind() + " " + trim(tree, 64));
+                expect.add(tree);
+                for (Field f: getFields(tree)) {
+                    if (TypeBoundKind.class.isAssignableFrom(f.getType())) {
+                        // not part of public API
+                        continue;
+                    }
+                    if (JCTree.JCNewArray.class.isAssignableFrom(tree.getClass())
+                            && (f.getName().equals("annotations")
+                                || f.getName().equals("dimAnnotations"))) {
+                        // these fields are incorrectly missing from the public API
+                        // (CR 6983297)
+                        continue;
+                    }
+                    try {
+                        //System.err.println("FIELD: " + f.getName());
+                        reflectiveScan(f.get(tree));
+                    } catch (IllegalAccessException e) {
+                        error(e.toString());
+                    }
+                }
+            } else if (o instanceof List) {
+                List<?> list = (List<?>) o;
+                for (Object item: list)
+                    reflectiveScan(item);
+            } else
+                error("unexpected item: " + o);
+        }
+
+        JavaFileObject sourcefile;
+        Set<Tree> found;
+        Set<Tree> expect;
+    }
+}