jdk8-mips64-public/langtools: comparison test/tools/javac/tree/TreePosTest.java

-:11c184155128
+:ca49d50318dc
 /*
-* Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2010, 2011, 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.
 import com.sun.tools.javac.tree.JCTree.JCNewClass;
 import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
 import com.sun.tools.javac.tree.TreeInfo;
 import com.sun.tools.javac.tree.TreeScanner;
+import static com.sun.tools.javac.tree.JCTree.Tag.*;
 import static com.sun.tools.javac.util.Position.NOPOS;
 /**
 * Utility and test program to check validity of tree positions for tree nodes.
 * The program can be run standalone, or as a jtreg test.  In standalone mode,
 void error(String msg) {
 System.err.println(msg);
 errors++;
 }
+/**
+* Names for tree tags.
+*/
+private static String getTagName(JCTree.Tag tag) {
+String name = tag.name();
+return (name == null) ? "??" : name;
+}
 /** Number of files that have been analyzed. */
 int fileCount;
 /** Number of errors reported. */
 int errors;
 /** Flag: don't report irrelevant files. */
 Set<String> tags = new HashSet<String>();
 /** Set of files and directories to be excluded from analysis. */
 Set<File> excludeFiles = new HashSet<File>();
 /** Set of tag names to be excluded from analysis. */
 Set<String> excludeTags = new HashSet<String>();
-/** Table of printable names for tree tag values. */
-TagNames tagNames = new TagNames();
 /**
 * Main class for testing assertions concerning tree positions for tree nodes.
 */
 private class PosTester extends TreeScanner {
 if (check(encl, self)) {
 // Modifiers nodes are present throughout the tree even where
 // there is no corresponding source text.
 // Redundant semicolons in a class definition can cause empty
 // initializer blocks with no positions.
-if ((self.tag == JCTree.MODIFIERS || self.tag == JCTree.BLOCK)
+if ((self.tag == MODIFIERS || self.tag == BLOCK)
 && self.pos == NOPOS) {
 // If pos is NOPOS, so should be the start and end positions
 check("start == NOPOS", encl, self, self.start == NOPOS);
 check("end == NOPOS", encl, self, self.end == NOPOS);
 } else {
 // and because of inconsistent nesting of left and right of
 // array declarations:
 //    e.g.    int[][] a = new int[2][];
 check("encl.start <= start", encl, self, encl.start <= self.start);
 check("start <= pos", encl, self, self.start <= self.pos);
-if (!(self.tag == JCTree.TYPEARRAY
+if (!(self.tag == TYPEARRAY
-&& (encl.tag == JCTree.VARDEF ||
+&& (encl.tag == VARDEF ||
-encl.tag == JCTree.METHODDEF ||
+encl.tag == METHODDEF ||
-encl.tag == JCTree.TYPEARRAY))) {
+encl.tag == TYPEARRAY))) {
 check("encl.pos <= start || end <= encl.pos",
 encl, self, encl.pos <= self.start || self.end <= encl.pos);
 }
 check("pos <= end", encl, self, self.pos <= self.end);
-if (!(self.tag == JCTree.TYPEARRAY && encl.tag == JCTree.TYPEARRAY)) {
+if (!(self.tag == TYPEARRAY && encl.tag == TYPEARRAY)) {
 check("end <= encl.end", encl, self, self.end <= encl.end);
 }
 }
 }
 // skip the synthesized bits and just check parts which came from
 // the original source text
 if ((tree.mods.flags & Flags.ENUM) != 0) {
 scan(tree.mods);
 if (tree.init != null) {
-if (tree.init.getTag() == JCTree.NEWCLASS) {
+if (tree.init.hasTag(NEWCLASS)) {
 JCNewClass init = (JCNewClass) tree.init;
 if (init.args != null && init.args.nonEmpty()) {
 scan(init.args);
 }
 if (init.def != null && init.def.defs != null) {
 super.visitVarDef(tree);
 }
 boolean check(Info encl, Info self) {
 if (excludeTags.size() > 0) {
-if (encl != null && excludeTags.contains(tagNames.get(encl.tag))
+if (encl != null && excludeTags.contains(getTagName(encl.tag))
-|| excludeTags.contains(tagNames.get(self.tag)))
+|| excludeTags.contains(getTagName(self.tag)))
 return false;
 }
-return tags.size() == 0 || tags.contains(tagNames.get(self.tag));
+return tags.size() == 0 || tags.contains(getTagName(self.tag));
 }
 void check(String label, Info encl, Info self, boolean ok) {
 if (!ok) {
 if (gui) {
 * Utility class providing easy access to position and other info for a tree node.
 */
 private class Info {
 Info() {
 tree = null;
-tag = JCTree.ERRONEOUS;
+tag = ERRONEOUS;
 start = 0;
 pos = 0;
 end = Integer.MAX_VALUE;
 }
 end = TreeInfo.getEndPos(tree, endPosTable);
 }
 @Override
 public String toString() {
-return tagNames.get(tree.getTag()) + "[start:" + start + ",pos:" + pos + ",end:" + end + "]";
+return getTagName(tree.getTag()) + "[start:" + start + ",pos:" + pos + ",end:" + end + "]";
 }
 final JCTree tree;
-final int tag;
+final JCTree.Tag tag;
 final int start;
 final int pos;
 final int end;
-}
-/**
-* Names for tree tags.
-* javac does not provide an API to convert tag values to strings, so this class uses
-* reflection to determine names of public static final int values in JCTree.
-*/
-private static class TagNames {
-String get(int tag) {
-if (map == null) {
-map = new HashMap<Integer, String>();
-Class c = JCTree.class;
-for (Field f : c.getDeclaredFields()) {
-if (f.getType().equals(int.class)) {
-int mods = f.getModifiers();
-if (Modifier.isPublic(mods) && Modifier.isStatic(mods) && Modifier.isFinal(mods)) {
-try {
-map.put(f.getInt(null), f.getName());
-} catch (IllegalAccessException e) {
-}
-}
-}
-}
-}
-String name = map.get(tag);
-return (name == null) ? "??" : name;
-}
-private Map<Integer, String> map;
 }
 /**
 * Thrown when errors are found parsing a java file.
 */
 add(addListener(end = createTextField(6)));
 }
 void setInfo(Info info) {
 this.info = info;
-tagName.setText(tagNames.get(info.tag));
+tagName.setText(getTagName(info.tag));
 start.setText(String.valueOf(info.start));
 pos.setText(String.valueOf(info.pos));
 end.setText(String.valueOf(info.end));
 }

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: test/tools/javac/tree/TreePosTest.java

test/tools/javac/tree/TreePosTest.java