jdk8-mips64-public/langtools: test/tools/javac/lib/DPrinter.java@9f0ec00514b6 (annotated)

test/tools/javac/lib/DPrinter.java@9f0ec00514b6 (annotated)

test/tools/javac/lib/DPrinter.java

Thu, 21 Feb 2013 15:26:46 +0000

author: mcimadamore
date: Thu, 21 Feb 2013 15:26:46 +0000
changeset 1599: 9f0ec00514b6
parent 1550: 1df20330f6bd
child 1755: ddb4a2bfcd82
permissions: -rw-r--r--

8007461: Regression: bad overload resolution when inner class and outer class have method with same name
Summary: Fix regression in varargs method resolution introduced by bad refactoring
Reviewed-by: jjg

 /*
  * Copyright (c) 2013, 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.
  */
 import java.io.File;
 import java.io.IOException;
 import java.io.PrintWriter;
 import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 import javax.lang.model.element.Name;
 import javax.lang.model.element.TypeElement;
 import javax.tools.FileObject;
 import javax.tools.JavaCompiler;
 import javax.tools.JavaFileObject;
 import javax.tools.StandardJavaFileManager;
 import javax.tools.StandardLocation;
 import javax.tools.ToolProvider;
 import com.sun.source.util.JavacTask;
 import com.sun.source.util.TaskEvent;
 import com.sun.source.util.TaskListener;
 import com.sun.source.util.Trees;
 import com.sun.tools.javac.api.JavacTrees;
 import com.sun.tools.javac.code.Annotations;
 import com.sun.tools.javac.code.Attribute;
 import com.sun.tools.javac.code.Flags;
 import com.sun.tools.javac.code.Kinds;
 import com.sun.tools.javac.code.Printer;
 import com.sun.tools.javac.code.Scope;
 import com.sun.tools.javac.code.Scope.CompoundScope;
 import com.sun.tools.javac.code.Symbol;
 import com.sun.tools.javac.code.Symbol.*;
 import com.sun.tools.javac.code.Type;
 import com.sun.tools.javac.code.Type.*;
 import com.sun.tools.javac.code.TypeTag;
 import com.sun.tools.javac.tree.JCTree;
 import com.sun.tools.javac.tree.JCTree.*;
 import com.sun.tools.javac.tree.Pretty;
 import com.sun.tools.javac.tree.TreeInfo;
 import com.sun.tools.javac.tree.TreeScanner;
 import com.sun.tools.javac.util.Assert;
 import com.sun.tools.javac.util.Context;
 import com.sun.tools.javac.util.Log;
 /**
  * Debug printer for javac internals, for when toString() just isn't enough.
  *
  * <p>
  * The printer provides an API to generate structured views of javac objects,
  * such as AST nodes, symbol, types and annotations. Various aspects of the
  * output can be configured, such as whether to show nulls, empty lists, or
  * a compressed representation of the source code. Visitors are used to walk
  * object hierarchies, and can be replaced with custom visitors if the default
  * visitors are not flexible enough.
  *
  * <p>
  * In general, nodes are printed with an initial line identifying the node
  * followed by indented lines for the child nodes. Currently, graphs are
  * represented by printing a spanning subtree.
  *
  * <p>
  * The printer can be accessed via a simple command-line utility,
  * which makes it easy to see the internal representation of source code,
  * such as simple test programs, during the compilation pipeline.
  *
  *  <p><b>This is NOT part of any supported API.
  *  If you write code that depends on this, you do so at your own risk.
  *  This code and its internal interfaces are subject to change or
  *  deletion without notice.</b>
  */
 public class DPrinter {
     protected final PrintWriter out;
     protected final Trees trees;
     protected Printer printer;
     protected boolean showEmptyItems = true;
     protected boolean showNulls = true;
     protected boolean showPositions = false;
     protected boolean showSrc;
     protected boolean showTreeSymbols;
     protected boolean showTreeTypes;
     protected int maxSrcLength = 32;
     protected Locale locale = Locale.getDefault();
     protected static final String NULL = "#null";
     // <editor-fold defaultstate="collapsed" desc="Configuration">
     public static DPrinter instance(Context context) {
         DPrinter dp = context.get(DPrinter.class);
         if (dp == null) {
             dp = new DPrinter(context);
         }
         return dp;
     }
     protected DPrinter(Context context) {
         context.put(DPrinter.class, this);
         out = context.get(Log.outKey);
         trees = JavacTrees.instance(context);
     }
     public DPrinter(PrintWriter out, Trees trees) {
         this.out = out;
         this.trees = trees;
     }
     public DPrinter emptyItems(boolean showEmptyItems) {
         this.showEmptyItems = showEmptyItems;
         return this;
     }
     public DPrinter nulls(boolean showNulls) {
         this.showNulls = showNulls;
         return this;
     }
     public DPrinter positions(boolean showPositions) {
         this.showPositions = showPositions;
         return this;
     }
     public DPrinter source(boolean showSrc) {
         this.showSrc = showSrc;
         return this;
     }
     public DPrinter source(int maxSrcLength) {
         this.showSrc = true;
         this.maxSrcLength = maxSrcLength;
         return this;
     }
     public DPrinter treeSymbols(boolean showTreeSymbols) {
         this.showTreeSymbols = showTreeSymbols;
         return this;
     }
     public DPrinter treeTypes(boolean showTreeTypes) {
         this.showTreeTypes = showTreeTypes;
         return this;
     }
     public DPrinter typeSymbolPrinter(Printer p) {
         printer = p;
         return this;
     }
     // </editor-fold>
     // <editor-fold defaultstate="collapsed" desc="Printing">
     protected enum Details {
         /** A one-line non-recursive summary */
         SUMMARY,
         /** Multi-line, possibly recursive. */
         FULL
     };
     public void printAnnotations(String label, Annotations annotations) {
         printAnnotations(label, annotations, Details.FULL);
     }
     protected void printAnnotations(String label, Annotations annotations, Details details) {
         if (annotations == null) {
             printNull(label);
         } else {
             // no SUMMARY format currently available to use
             // use reflection to get at private fields
             Object DECL_NOT_STARTED = getField(null, Annotations.class, "DECL_NOT_STARTED");
             Object DECL_IN_PROGRESS = getField(null, Annotations.class, "DECL_IN_PROGRESS");
             Object attributes = getField(annotations, Annotations.class, "attributes");
             Object type_attributes = getField(annotations, Annotations.class, "type_attributes");
             if (!showEmptyItems) {
                 if (attributes instanceof List && ((List) attributes).isEmpty()
                         && attributes != DECL_NOT_STARTED
                         && attributes != DECL_IN_PROGRESS
                         && type_attributes instanceof List && ((List) type_attributes).isEmpty())
                     return;
             }
             printString(label, hashString(annotations));
             indent(+1);
             if (attributes == DECL_NOT_STARTED)
                 printString("attributes", "DECL_NOT_STARTED");
             else if (attributes == DECL_IN_PROGRESS)
                 printString("attributes", "DECL_IN_PROGRESS");
             else if (attributes instanceof List)
                 printList("attributes", (List) attributes);
             else
                 printObject("attributes", attributes, Details.SUMMARY);
             if (attributes instanceof List)
                 printList("type_attributes", (List) type_attributes);
             else
                 printObject("type_attributes", type_attributes, Details.SUMMARY);
             indent(-1);
         }
     }
     public void printAttribute(String label, Attribute attr) {
         if (attr == null) {
             printNull(label);
         } else {
             printString(label, attr.getClass().getSimpleName());
             indent(+1);
             attr.accept(attrVisitor);
             indent(-1);
         }
     }
     public void printFileObject(String label, FileObject fo) {
         if (fo == null) {
             printNull(label);
         } else {
             printString(label, fo.getName());
         }
     }
     protected <T> void printImplClass(T item, Class<? extends T> stdImplClass) {
         if (item.getClass() != stdImplClass)
             printString("impl", item.getClass().getName());
     }
     public void printInt(String label, int i) {
         printString(label, String.valueOf(i));
     }
     public void printList(String label, List<?> list) {
         if (list == null) {
              printNull(label);
         } else if (!list.isEmpty() || showEmptyItems) {
             printString(label, "[" + list.size() + "]");
             indent(+1);
             int i = 0;
             for (Object item: list) {
                 printObject(String.valueOf(i++), item, Details.FULL);
             }
             indent(-1);
         }
     }
     public void printName(String label, Name name) {
         if (name == null) {
             printNull(label);
         } else {
             printString(label, name.toString());
         }
     }
     public void printNull(String label) {
         if (showNulls)
             printString(label, NULL);
     }
     protected void printObject(String label, Object item, Details details) {
         if (item == null) {
             printNull(label);
         } else if (item instanceof Attribute) {
             printAttribute(label, (Attribute) item);
         } else if (item instanceof Symbol) {
             printSymbol(label, (Symbol) item, details);
         } else if (item instanceof Type) {
             printType(label, (Type) item, details);
         } else if (item instanceof JCTree) {
             printTree(label, (JCTree) item);
         } else if (item instanceof List) {
             printList(label, (List) item);
         } else if (item instanceof Name) {
             printName(label, (Name) item);
         } else {
             printString(label, String.valueOf(item));
         }
     }
     public void printScope(String label, Scope scope) {
         printScope(label, scope, Details.FULL);
     }
     public void printScope(String label, Scope scope, Details details) {
         if (scope == null) {
             printNull(label);
         } else {
             switch (details) {
                 case SUMMARY: {
                     indent();
                     out.print(label);
                     out.print(": [");
                     String sep = "";
                     for (Symbol sym: scope.getElements()) {
                         out.print(sep);
                         out.print(sym.name);
                         sep = ",";
                     }
                     out.println("]");
                     break;
                 }
                 case FULL: {
                     indent();
                     out.println(label);
                     indent(+1);
                     printImplClass(scope, Scope.class);
                     printSymbol("owner", scope.owner, Details.SUMMARY);
                     printScope("next", scope.next, Details.SUMMARY);
                     printObject("shared", getField(scope, Scope.class, "shared"), Details.SUMMARY);
                     if (scope instanceof CompoundScope) {
                         printObject("subScopes",
                                 getField(scope, CompoundScope.class, "subScopes"),
                                 Details.FULL);
                     } else {
                         for (Symbol sym : scope.getElements()) {
                             printSymbol(sym.name.toString(), sym, Details.SUMMARY);
                         }
                     }
                     indent(-1);
                     break;
                 }
             }
         }
     }
     public void printSource(String label, JCTree tree) {
         printString(label, Pretty.toSimpleString(tree, maxSrcLength));
     }
     public void printString(String label, String text) {
         indent();
         out.print(label);
         out.print(": ");
         out.print(text);
         out.println();
     }
     public void printSymbol(String label, Symbol symbol) {
         printSymbol(label, symbol, Details.FULL);
     }
     protected void printSymbol(String label, Symbol sym, Details details) {
         if (sym == null) {
             printNull(label);
         } else {
             switch (details) {
             case SUMMARY:
                 printString(label, toString(sym));
                 break;
             case FULL:
                 indent();
                 out.print(label);
                 out.println(": " +
                         info(sym.getClass(),
                             String.format("0x%x--%s", sym.kind, Kinds.kindName(sym)),
                             sym.getKind())
                         + " " + sym.name
                         + " " + hashString(sym));
                 indent(+1);
                 if (showSrc) {
                     JCTree tree = (JCTree) trees.getTree(sym);
                     if (tree != null)
                         printSource("src", tree);
                 }
                 printString("flags", String.format("0x%x--%s",
                         sym.flags_field, Flags.toString(sym.flags_field)));
                 printObject("completer", sym.completer, Details.SUMMARY); // what if too long?
                 printSymbol("owner", sym.owner, Details.SUMMARY);
                 printType("type", sym.type, Details.SUMMARY);
                 printType("erasure", sym.erasure_field, Details.SUMMARY);
                 sym.accept(symVisitor, null);
                 printAnnotations("annotations", sym.annotations, Details.SUMMARY);
                 indent(-1);
             }
         }
     }
     protected String toString(Symbol sym) {
         return (printer != null) ? printer.visit(sym, locale) : String.valueOf(sym);
     }
     protected void printTree(String label, JCTree tree) {
         if (tree == null) {
             printNull(label);
         } else {
             indent();
             String ext;
             try {
                 ext = tree.getKind().name();
             } catch (Throwable t) {
                 ext = "n/a";
             }
             out.print(label + ": " + info(tree.getClass(), tree.getTag(), ext));
             if (showPositions) {
                 // We can always get start position, but to get end position
                 // and/or line+offset, we would need a JCCompilationUnit
                 out.print(" pos:" + tree.pos);
             }
             if (showTreeTypes && tree.type != null)
                 out.print(" type:" + toString(tree.type));
             Symbol sym;
             if (showTreeSymbols && (sym = TreeInfo.symbolFor(tree)) != null)
                 out.print(" sym:" + toString(sym));
             out.println();
             indent(+1);
             if (showSrc) {
                 indent();
                 out.println("src: " + Pretty.toSimpleString(tree, maxSrcLength));
             }
             tree.accept(treeVisitor);
             indent(-1);
         }
     }
     public void printType(String label, Type type) {
         printType(label, type, Details.FULL);
     }
     protected void printType(String label, Type type, Details details) {
         if (type == null)
             printNull(label);
         else {
             switch (details) {
                 case SUMMARY:
                     printString(label, toString(type));
                     break;
                 case FULL:
                     indent();
                     out.print(label);
                     out.println(": " + info(type.getClass(), type.getTag(), type.getKind())
                             + " " + hashString(type));
                     indent(+1);
                     printSymbol("tsym", type.tsym, Details.SUMMARY);
                     printObject("constValue", type.constValue(), Details.SUMMARY);
                     type.accept(typeVisitor, null);
                     indent(-1);
             }
         }
     }
     protected String toString(Type type) {
         return (printer != null) ? printer.visit(type, locale) : String.valueOf(type);
     }
     protected String hashString(Object obj) {
         return String.format("#%x", obj.hashCode());
     }
     protected String info(Class<?> clazz, Object internal, Object external) {
         return String.format("%s,%s,%s", clazz.getSimpleName(), internal, external);
     }
     private int indent = 0;
     protected void indent() {
         for (int i = 0; i < indent; i++) {
             out.print("  ");
         }
     }
     protected void indent(int n) {
         indent += n;
     }
     protected Object getField(Object o, Class<?> clazz, String name) {
         try {
             Field f = clazz.getDeclaredField(name);
             boolean prev = f.isAccessible();
             f.setAccessible(true);
             try {
                 return f.get(o);
             } finally {
                 f.setAccessible(prev);
             }
         } catch (ReflectiveOperationException e) {
             return e;
         } catch (SecurityException e) {
             return e;
         }
     }
     // </editor-fold>
     // <editor-fold defaultstate="collapsed" desc="JCTree visitor methods">
     protected JCTree.Visitor treeVisitor = new TreeVisitor();
     /**
      * Default visitor class for JCTree (AST) objects.
      */
     public class TreeVisitor extends JCTree.Visitor {
         @Override
         public void visitTopLevel(JCCompilationUnit tree) {
             printList("packageAnnotations", tree.packageAnnotations);
             printTree("pid", tree.pid);
             printList("defs", tree.defs);
         }
         @Override
         public void visitImport(JCImport tree) {
             printTree("qualid", tree.qualid);
         }
         @Override
         public void visitClassDef(JCClassDecl tree) {
             printName("name", tree.name);
             printTree("mods", tree.mods);
             printList("typarams", tree.typarams);
             printTree("extending", tree.extending);
             printList("implementing", tree.implementing);
             printList("defs", tree.defs);
         }
         @Override
         public void visitMethodDef(JCMethodDecl tree) {
             printName("name", tree.name);
             printTree("mods", tree.mods);
             printTree("restype", tree.restype);
             printList("typarams", tree.typarams);
             printTree("recvparam", tree.recvparam);
             printList("params", tree.params);
             printList("thrown", tree.thrown);
             printTree("defaultValue", tree.defaultValue);
             printTree("body", tree.body);
         }
         @Override
         public void visitVarDef(JCVariableDecl tree) {
             printName("name", tree.name);
             printTree("mods", tree.mods);
             printTree("vartype", tree.vartype);
             printTree("init", tree.init);
         }
         @Override
         public void visitSkip(JCSkip tree) {
         }
         @Override
         public void visitBlock(JCBlock tree) {
             printList("stats", tree.stats);
         }
         @Override
         public void visitDoLoop(JCDoWhileLoop tree) {
             printTree("body", tree.body);
             printTree("cond", tree.cond);
         }
         @Override
         public void visitWhileLoop(JCWhileLoop tree) {
             printTree("cond", tree.cond);
             printTree("body", tree.body);
         }
         @Override
         public void visitForLoop(JCForLoop tree) {
             printList("init", tree.init);
             printTree("cond", tree.cond);
             printList("step", tree.step);
             printTree("body", tree.body);
         }
         @Override
         public void visitForeachLoop(JCEnhancedForLoop tree) {
             printTree("var", tree.var);
             printTree("expr", tree.expr);
             printTree("body", tree.body);
         }
         @Override
         public void visitLabelled(JCLabeledStatement tree) {
             printTree("body", tree.body);
         }
         @Override
         public void visitSwitch(JCSwitch tree) {
             printTree("selector", tree.selector);
             printList("cases", tree.cases);
         }
         @Override
         public void visitCase(JCCase tree) {
             printTree("pat", tree.pat);
             printList("stats", tree.stats);
         }
         @Override
         public void visitSynchronized(JCSynchronized tree) {
             printTree("lock", tree.lock);
             printTree("body", tree.body);
         }
         @Override
         public void visitTry(JCTry tree) {
             printList("resources", tree.resources);
             printTree("body", tree.body);
             printList("catchers", tree.catchers);
             printTree("finalizer", tree.finalizer);
         }
         @Override
         public void visitCatch(JCCatch tree) {
             printTree("param", tree.param);
             printTree("body", tree.body);
         }
         @Override
         public void visitConditional(JCConditional tree) {
             printTree("cond", tree.cond);
             printTree("truepart", tree.truepart);
             printTree("falsepart", tree.falsepart);
         }
         @Override
         public void visitIf(JCIf tree) {
             printTree("cond", tree.cond);
             printTree("thenpart", tree.thenpart);
             printTree("elsepart", tree.elsepart);
         }
         @Override
         public void visitExec(JCExpressionStatement tree) {
             printTree("expr", tree.expr);
         }
         @Override
         public void visitBreak(JCBreak tree) {
             printName("label", tree.label);
         }
         @Override
         public void visitContinue(JCContinue tree) {
             printName("label", tree.label);
         }
         @Override
         public void visitReturn(JCReturn tree) {
             printTree("expr", tree.expr);
         }
         @Override
         public void visitThrow(JCThrow tree) {
             printTree("expr", tree.expr);
         }
         @Override
         public void visitAssert(JCAssert tree) {
             printTree("cond", tree.cond);
             printTree("detail", tree.detail);
         }
         @Override
         public void visitApply(JCMethodInvocation tree) {
             printList("typeargs", tree.typeargs);
             printTree("meth", tree.meth);
             printList("args", tree.args);
         }
         @Override
         public void visitNewClass(JCNewClass tree) {
             printTree("encl", tree.encl);
             printList("typeargs", tree.typeargs);
             printTree("clazz", tree.clazz);
             printList("args", tree.args);
             printTree("def", tree.def);
         }
         @Override
         public void visitNewArray(JCNewArray tree) {
             printList("annotations", tree.annotations);
             printTree("elemtype", tree.elemtype);
             printList("dims", tree.dims);
             printList("dimAnnotations", tree.dimAnnotations);
             printList("elems", tree.elems);
         }
         @Override
         public void visitLambda(JCLambda tree) {
             printTree("body", tree.body);
             printList("params", tree.params);
         }
         @Override
         public void visitParens(JCParens tree) {
             printTree("expr", tree.expr);
         }
         @Override
         public void visitAssign(JCAssign tree) {
             printTree("lhs", tree.lhs);
             printTree("rhs", tree.rhs);
         }
         @Override
         public void visitAssignop(JCAssignOp tree) {
             printTree("lhs", tree.lhs);
             printTree("rhs", tree.rhs);
         }
         @Override
         public void visitUnary(JCUnary tree) {
             printTree("arg", tree.arg);
         }
         @Override
         public void visitBinary(JCBinary tree) {
             printTree("lhs", tree.lhs);
             printTree("rhs", tree.rhs);
         }
         @Override
         public void visitTypeCast(JCTypeCast tree) {
             printTree("clazz", tree.clazz);
             printTree("expr", tree.expr);
         }
         @Override
         public void visitTypeTest(JCInstanceOf tree) {
             printTree("expr", tree.expr);
             printTree("clazz", tree.clazz);
         }
         @Override
         public void visitIndexed(JCArrayAccess tree) {
             printTree("indexed", tree.indexed);
             printTree("index", tree.index);
         }
         @Override
         public void visitSelect(JCFieldAccess tree) {
             printTree("selected", tree.selected);
         }
         @Override
         public void visitReference(JCMemberReference tree) {
             printTree("expr", tree.expr);
             printList("typeargs", tree.typeargs);
         }
         @Override
         public void visitIdent(JCIdent tree) {
             printName("name", tree.name);
         }
         @Override
         public void visitLiteral(JCLiteral tree) {
             printString("value", Pretty.toSimpleString(tree, 32));
         }
         @Override
         public void visitTypeIdent(JCPrimitiveTypeTree tree) {
             printString("typetag", tree.typetag.name());
         }
         @Override
         public void visitTypeArray(JCArrayTypeTree tree) {
             printTree("elemtype", tree.elemtype);
         }
         @Override
         public void visitTypeApply(JCTypeApply tree) {
             printTree("clazz", tree.clazz);
             printList("arguments", tree.arguments);
         }
         @Override
         public void visitTypeUnion(JCTypeUnion tree) {
             printList("alternatives", tree.alternatives);
         }
         @Override
         public void visitTypeIntersection(JCTypeIntersection tree) {
             printList("bounds", tree.bounds);
         }
         @Override
         public void visitTypeParameter(JCTypeParameter tree) {
             printName("name", tree.name);
             printList("annotations", tree.annotations);
             printList("bounds", tree.bounds);
         }
         @Override
         public void visitWildcard(JCWildcard tree) {
             printTree("kind", tree.kind);
             printTree("inner", tree.inner);
         }
         @Override
         public void visitTypeBoundKind(TypeBoundKind tree) {
             printString("kind", tree.kind.name());
         }
         @Override
         public void visitModifiers(JCModifiers tree) {
             printList("annotations", tree.annotations);
             printString("flags", String.valueOf(Flags.asFlagSet(tree.flags)));
         }
         @Override
         public void visitAnnotation(JCAnnotation tree) {
             printTree("annotationType", tree.annotationType);
             printList("args", tree.args);
         }
         @Override
         public void visitAnnotatedType(JCAnnotatedType tree) {
             printList("annotations", tree.annotations);
             printTree("underlyingType", tree.underlyingType);
         }
         @Override
         public void visitErroneous(JCErroneous tree) {
             printList("errs", tree.errs);
         }
         @Override
         public void visitLetExpr(LetExpr tree) {
             printList("defs", tree.defs);
             printTree("expr", tree.expr);
         }
         @Override
         public void visitTree(JCTree tree) {
             Assert.error();
         }
     }
     // </editor-fold>
     // <editor-fold defaultstate="collapsed" desc="Symbol visitor">
     protected Symbol.Visitor<Void,Void> symVisitor = new SymbolVisitor();
     /**
      * Default visitor class for Symbol objects.
      * Note: each visitXYZ method ends by calling the corresponding
      * visit method for its superclass.
      */
     class SymbolVisitor implements Symbol.Visitor<Void,Void> {
         @Override
         public Void visitClassSymbol(ClassSymbol sym, Void ignore) {
             printName("fullname", sym.fullname);
             printName("flatname", sym.flatname);
             printScope("members", sym.members_field);
             printFileObject("sourcefile", sym.sourcefile);
             printFileObject("classfile", sym.classfile);
             // trans-local?
             // pool?
             return visitTypeSymbol(sym, null);
         }
         @Override
         public Void visitMethodSymbol(MethodSymbol sym, Void ignore) {
             // code
             printList("params", sym.params);
             printList("savedParameterNames", sym.savedParameterNames);
             return visitSymbol(sym, null);
         }
         @Override
         public Void visitPackageSymbol(PackageSymbol sym, Void ignore) {
             printName("fullname", sym.fullname);
             printScope("members", sym.members_field);
             printSymbol("package-info", sym.package_info, Details.SUMMARY);
             return visitTypeSymbol(sym, null);
         }
         @Override
         public Void visitOperatorSymbol(OperatorSymbol sym, Void ignore) {
             printInt("opcode", sym.opcode);
             return visitMethodSymbol(sym, null);
         }
         @Override
         public Void visitVarSymbol(VarSymbol sym, Void ignore) {
             printInt("pos", sym.pos);
             printInt("adm", sym.adr);
             // data is a private field, and the standard accessors may
             // mutate it as part of lazy evaluation. Therefore, use
             // reflection to get the raw data.
             printObject("data", getField(sym, VarSymbol.class, "data"), Details.SUMMARY);
             return visitSymbol(sym, null);
         }
         @Override
         public Void visitTypeSymbol(TypeSymbol sym, Void ignore) {
             return visitSymbol(sym, null);
         }
         @Override
         public Void visitSymbol(Symbol sym, Void ignore) {
             return null;
         }
     }
     // </editor-fold>
     // <editor-fold defaultstate="collapsed" desc="Type visitor">
     protected Type.Visitor<Void,Void> typeVisitor = new TypeVisitor();
     /**
      * Default visitor class for Type objects.
      * Note: each visitXYZ method ends by calling the corresponding
      * visit method for its superclass.
      */
     public class TypeVisitor implements Type.Visitor<Void,Void> {
         public Void visitAnnotatedType(AnnotatedType type, Void ignore) {
             printList("typeAnnotations", type.typeAnnotations);
             printType("underlyingType", type.underlyingType, Details.FULL);
             return visitType(type, null);
         }
         public Void visitArrayType(ArrayType type, Void ignore) {
             printType("elemType", type.elemtype, Details.FULL);
             return visitType(type, null);
         }
         public Void visitCapturedType(CapturedType type, Void ignore) {
             printType("wildcard", type.wildcard, Details.FULL);
             return visitTypeVar(type, null);
         }
         public Void visitClassType(ClassType type, Void ignore) {
             printType("outer", type.getEnclosingType(), Details.SUMMARY);
             printList("typarams", type.typarams_field);
             printList("allparams", type.allparams_field);
             printType("supertype", type.supertype_field, Details.SUMMARY);
             printList("interfaces", type.interfaces_field);
             printList("allinterfaces", type.all_interfaces_field);
             return visitType(type, null);
         }
         public Void visitErrorType(ErrorType type, Void ignore) {
             printType("originalType", type.getOriginalType(), Details.FULL);
             return visitClassType(type, null);
         }
         public Void visitForAll(ForAll type, Void ignore) {
             printList("tvars", type.tvars);
             return visitDelegatedType(type);
         }
         public Void visitMethodType(MethodType type, Void ignore) {
             printList("argtypes", type.argtypes);
             printType("restype", type.restype, Details.FULL);
             printList("thrown", type.thrown);
             return visitType(type, null);
         }
         public Void visitPackageType(PackageType type, Void ignore) {
             return visitType(type, null);
         }
         public Void visitTypeVar(TypeVar type, Void ignore) {
             // For TypeVars (and not subtypes), the bound should always be
             // null or bot. So, only print the bound for subtypes of TypeVar,
             // or if the bound is (erroneously) not null or bot.
             if (!type.hasTag(TypeTag.TYPEVAR)
                     || !(type.bound == null || type.bound.hasTag(TypeTag.BOT))) {
                 printType("bound", type.bound, Details.FULL);
             }
             printType("lower", type.lower, Details.FULL);
             return visitType(type, null);
         }
         public Void visitUndetVar(UndetVar type, Void ignore) {
             for (UndetVar.InferenceBound ib: UndetVar.InferenceBound.values())
                 printList("bounds." + ib, type.getBounds(ib));
             printInt("declaredCount", type.declaredCount);
             printType("inst", type.inst, Details.SUMMARY);
             return visitDelegatedType(type);
         }
         public Void visitWildcardType(WildcardType type, Void ignore) {
             printType("type", type.type, Details.SUMMARY);
             printString("kind", type.kind.name());
             printType("bound", type.bound, Details.SUMMARY);
             return visitType(type, null);
         }
         protected Void visitDelegatedType(DelegatedType type) {
             printType("qtype", type.qtype, Details.FULL);
             return visitType(type, null);
         }
         public Void visitType(Type type, Void ignore) {
             return null;
         }
     }
     // </editor-fold>
     // <editor-fold defaultstate="collapsed" desc="Attribute (annotations) visitor">
     protected Attribute.Visitor attrVisitor = new AttributeVisitor();
     /**
      * Default visitor class for Attribute (annotation) objects.
      */
     public class AttributeVisitor implements Attribute.Visitor {
         public void visitConstant(Attribute.Constant a) {
             printObject("value", a.value, Details.SUMMARY);
             visitAttribute(a);
         }
         public void visitClass(Attribute.Class a) {
             printObject("classType", a.classType, Details.SUMMARY);
             visitAttribute(a);
         }
         public void visitCompound(Attribute.Compound a) {
             if (a instanceof Attribute.TypeCompound) {
                 Attribute.TypeCompound ta = (Attribute.TypeCompound) a;
                 // consider a custom printer?
                 printObject("position", ta.position, Details.SUMMARY);
             }
             printObject("synthesized", a.isSynthesized(), Details.SUMMARY);
             printList("values", a.values);
             visitAttribute(a);
         }
         public void visitArray(Attribute.Array a) {
             printList("values", Arrays.asList(a.values));
             visitAttribute(a);
         }
         public void visitEnum(Attribute.Enum a) {
             printSymbol("value", a.value, Details.SUMMARY);
             visitAttribute(a);
         }
         public void visitError(Attribute.Error a) {
             visitAttribute(a);
         }
         public void visitAttribute(Attribute a) {
             printType("type", a.type, Details.SUMMARY);
         }
     }
     // </editor-fold>
     // <editor-fold defaultstate="collapsed" desc="Utility front end">
     /**
      * Utility class to invoke DPrinter from the command line.
      */
     static class Main {
         public static void main(String... args) throws IOException {
             Main m = new Main();
             PrintWriter out = new PrintWriter(System.out);
             try {
                 if (args.length == 0)
                     m.usage(out);
                 else
                     m.run(out, args);
             } finally {
                 out.flush();
             }
         }
         void usage(PrintWriter out) {
             out.println("Usage:");
             out.println("  java " + Main.class.getName() + " mode [options] [javac-options]");
             out.print("where mode is one of: ");
             String sep = "";
             for (Handler h: getHandlers().values()) {
                 out.print(sep);
                 out.print(h.name);
                 sep = ", ";
             }
             out.println();
             out.println("and where options include:");
             out.println("  -before PARSE|ENTER|ANALYZE|GENERATE|ANNOTATION_PROCESSING|ANNOTATION_PROCESSING_ROUND");
             out.println("  -after PARSE|ENTER|ANALYZE|GENERATE|ANNOTATION_PROCESSING|ANNOTATION_PROCESSING_ROUND");
             out.println("  -showPositions");
             out.println("  -showSource");
             out.println("  -showTreeSymbols");
             out.println("  -showTreeTypes");
             out.println("  -hideEmptyItems");
             out.println("  -hideNulls");
         }
         void run(PrintWriter out, String... args) throws IOException {
             JavaCompiler c = ToolProvider.getSystemJavaCompiler();
             StandardJavaFileManager fm = c.getStandardFileManager(null, null, null);
             // DPrinter options
             final Set<TaskEvent.Kind> before = EnumSet.noneOf(TaskEvent.Kind.class);
             final Set<TaskEvent.Kind> after = EnumSet.noneOf(TaskEvent.Kind.class);
             boolean showPositions = false;
             boolean showSource = false;
             boolean showTreeSymbols = false;
             boolean showTreeTypes = false;
             boolean showEmptyItems = true;
             boolean showNulls = true;
             // javac options
             Collection<String> options = new ArrayList<String>();
             Collection<File> files = new ArrayList<File>();
             String classpath = null;
             String classoutdir = null;
             final Handler h = getHandlers().get(args[0]);
             if (h == null)
                 throw new IllegalArgumentException(args[0]);
             for (int i = 1; i < args.length; i++) {
                 String arg = args[i];
                 if (arg.equals("-before") && i + 1 < args.length) {
                     before.add(getKind(args[++i]));
                 } else if (arg.equals("-after") && i + 1 < args.length) {
                     after.add(getKind(args[++i]));
                 } else if (arg.equals("-showPositions")) {
                     showPositions = true;
                 } else if (arg.equals("-showSource")) {
                     showSource = true;
                 } else if (arg.equals("-showTreeSymbols")) {
                     showTreeSymbols = true;
                 } else if (arg.equals("-showTreeTypes")) {
                     showTreeTypes = true;
                 } else if (arg.equals("-hideEmptyLists")) {
                     showEmptyItems = false;
                 } else if (arg.equals("-hideNulls")) {
                     showNulls = false;
                 } else if (arg.equals("-classpath") && i + 1 < args.length) {
                     classpath = args[++i];
                 } else if (arg.equals("-d") && i + 1 < args.length) {
                     classoutdir = args[++i];
                 } else if (arg.startsWith("-")) {
                     int n = c.isSupportedOption(arg);
                     if (n < 0) throw new IllegalArgumentException(arg);
                     options.add(arg);
                     while (n > 0) options.add(args[++i]);
                 } else if (arg.endsWith(".java")) {
                     files.add(new File(arg));
                 }
             }
             if (classoutdir != null) {
                 fm.setLocation(StandardLocation.CLASS_OUTPUT, Arrays.asList(new File(classoutdir)));
             }
             if (classpath != null) {
                 Collection<File> path = new ArrayList<File>();
                 for (String p: classpath.split(File.pathSeparator)) {
                     if (p.isEmpty()) continue;
                     File f = new File(p);
                     if (f.exists()) path.add(f);
                 }
                 fm.setLocation(StandardLocation.CLASS_PATH, path);
             }
             Iterable<? extends JavaFileObject> fos = fm.getJavaFileObjectsFromFiles(files);
             JavacTask task = (JavacTask) c.getTask(out, fm, null, options, null, fos);
             final Trees trees = Trees.instance(task);
             final DPrinter dprinter = new DPrinter(out, trees);
             dprinter.source(showSource)
                     .emptyItems(showEmptyItems)
                     .nulls(showNulls)
                     .positions(showPositions)
                     .treeSymbols(showTreeSymbols)
                     .treeTypes(showTreeTypes);
             if (before.isEmpty() && after.isEmpty()) {
                 if (h.name.equals("trees") && !showTreeSymbols && !showTreeTypes)
                     after.add(TaskEvent.Kind.PARSE);
                 else
                     after.add(TaskEvent.Kind.ANALYZE);
             }
             task.addTaskListener(new TaskListener() {
                 public void started(TaskEvent e) {
                     if (before.contains(e.getKind()))
                         handle(e);
                 }
                 public void finished(TaskEvent e) {
                     if (after.contains(e.getKind()))
                         handle(e);
                 }
                 private void handle(TaskEvent e) {
                      switch (e.getKind()) {
                          case PARSE:
                          case ENTER:
                              h.handle(e.getSourceFile().getName(),
                                      (JCTree) e.getCompilationUnit(),
                                      dprinter);
                              break;
                          default:
                              TypeElement elem = e.getTypeElement();
                              h.handle(elem.toString(),
                                      (JCTree) trees.getTree(elem),
                                      dprinter);
                              break;
                      }
                 }
             });
             task.call();
         }
         TaskEvent.Kind getKind(String s) {
             return TaskEvent.Kind.valueOf(s.toUpperCase());
         }
         static protected abstract class Handler {
             final String name;
             Handler(String name) {
                 this.name = name;
             }
             abstract void handle(String label, JCTree tree, DPrinter dprinter);
         }
         Map<String,Handler> getHandlers() {
             Map<String,Handler> map = new HashMap<String, Handler>();
             for (Handler h: defaultHandlers) {
                 map.put(h.name, h);
             }
             return map;
         }
         protected final Handler[] defaultHandlers = {
             new Handler("trees") {
                 @Override
                 void handle(String name, JCTree tree, DPrinter dprinter) {
                     dprinter.printTree(name, tree);
                     dprinter.out.println();
                 }
             },
             new Handler("symbols") {
                 @Override
                 void handle(String name, JCTree tree, final DPrinter dprinter) {
                     TreeScanner ds = new TreeScanner() {
                         @Override
                         public void visitClassDef(JCClassDecl tree) {
                             visitDecl(tree, tree.sym);
                             super.visitClassDef(tree);
                         }
                         @Override
                         public void visitMethodDef(JCMethodDecl tree) {
                             visitDecl(tree, tree.sym);
                             super.visitMethodDef(tree);
                         }
                         @Override
                         public void visitVarDef(JCVariableDecl tree) {
                             visitDecl(tree, tree.sym);
                             super.visitVarDef(tree);
                         }
                         void visitDecl(JCTree tree, Symbol sym) {
                             dprinter.printSymbol(sym.name.toString(), sym);
                             dprinter.out.println();
                         }
                     };
                     ds.scan(tree);
                 }
             },
             new Handler("types") {
                 @Override
                 void handle(String name, JCTree tree, final DPrinter dprinter) {
                     TreeScanner ts = new TreeScanner() {
                         @Override
                         public void scan(JCTree tree) {
                             if (tree == null) {
                                 return;
                             }
                             if (tree.type != null) {
                                 String label = Pretty.toSimpleString(tree);
                                 dprinter.printType(label, tree.type);
                                 dprinter.out.println();
                             }
                             super.scan(tree);
                         }
                     };
                     ts.scan(tree);
                 }
             }
         };
     }
     // </editor-fold>
 }

Mercurial > jdk8-mips64-public > langtools / annotate

test/tools/javac/lib/DPrinter.java@9f0ec00514b6 (annotated)

test/tools/javac/lib/DPrinter.java