diff --git a/src/share/classes/com/sun/source/util/TreeScanner.java b/src/share/classes/com/sun/source/util/TreeScanner.java index dbb2d303809e8ce7a4ec32f43ea710b79f307e7f..3a8f07aca9924422c7b0b7bac7052906721575a4 100644 --- a/src/share/classes/com/sun/source/util/TreeScanner.java +++ b/src/share/classes/com/sun/source/util/TreeScanner.java @@ -141,6 +141,7 @@ public class TreeScanner implements TreeVisitor { 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; } diff --git a/test/tools/javac/api/T6392782.java b/test/tools/javac/api/T6392782.java index 16fddf8bdcd068acf9097489e523ec817a79c132..f3c11d544626d1f2bda6204a85083e87a7b58984 100644 --- a/test/tools/javac/api/T6392782.java +++ b/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 { @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; } diff --git a/test/tools/javac/tree/TreeScannerTest.java b/test/tools/javac/tree/AbstractTreeScannerTest.java similarity index 68% rename from test/tools/javac/tree/TreeScannerTest.java rename to test/tools/javac/tree/AbstractTreeScannerTest.java index efbad262643b2e38833a329ef1d475ab3528ec40..869b5e824e1e5f5eeeb997333bbd99e4e5360535 100644 --- a/test/tools/javac/tree/TreeScannerTest.java +++ b/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. - * - *

- * 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(); - scan(tree); - expect = new HashSet(); - 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 missing = new HashSet(); - missing.addAll(expect); - missing.removeAll(found); - for (JCTree t: missing) - error(tree.sourcefile, t, "missing"); - - Set excess = new HashSet(); - 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 found; - Set expect; - } /** * Thrown when errors are found parsing a java file. diff --git a/test/tools/javac/tree/JavacTreeScannerTest.java b/test/tools/javac/tree/JavacTreeScannerTest.java new file mode 100644 index 0000000000000000000000000000000000000000..86c21aca36bf0e78ac6e82db10ca52e5b239880f --- /dev/null +++ b/test/tools/javac/tree/JavacTreeScannerTest.java @@ -0,0 +1,155 @@ +/* + * 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. + * + *

+ * 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(); + scan(tree); + expect = new HashSet(); + 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 missing = new HashSet(); + missing.addAll(expect); + missing.removeAll(found); + for (JCTree t: missing) + error(tree.sourcefile, t, "missing"); + + Set excess = new HashSet(); + 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 found; + Set expect; + } +} diff --git a/test/tools/javac/tree/SourceTreeScannerTest.java b/test/tools/javac/tree/SourceTreeScannerTest.java new file mode 100644 index 0000000000000000000000000000000000000000..c291c7deffcb6cd35c2790a2d41d8cf0900ec96c --- /dev/null +++ b/test/tools/javac/tree/SourceTreeScannerTest.java @@ -0,0 +1,168 @@ +/* + * 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. + * + *

+ * 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 { + /** Main entry method for the class. */ + int test(JCCompilationUnit tree) { + sourcefile = tree.sourcefile; + found = new HashSet(); + scan(tree, null); + expect = new HashSet(); + 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 missing = new HashSet(); + missing.addAll(expect); + missing.removeAll(found); + for (Tree t: missing) + error(tree.sourcefile, t, "missing"); + + Set excess = new HashSet(); + 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 found; + Set expect; + } +}