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

 /*

  * Copyright (c) 1999, 2017, 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.  Oracle designates this

  * particular file as subject to the "Classpath" exception as provided

  * by Oracle in the LICENSE file that accompanied this code.

  *

  * 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.

  */

 package com.sun.tools.javac.tree;

 import com.sun.source.tree.Tree;

 import com.sun.source.util.TreePath;

 import com.sun.tools.javac.code.*;

 import com.sun.tools.javac.comp.AttrContext;

 import com.sun.tools.javac.comp.Env;

 import com.sun.tools.javac.tree.JCTree.*;

 import com.sun.tools.javac.tree.JCTree.JCPolyExpression.*;

 import com.sun.tools.javac.util.*;

 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;

 import static com.sun.tools.javac.code.Flags.*;

 import static com.sun.tools.javac.code.TypeTag.BOT;

 import static com.sun.tools.javac.tree.JCTree.Tag.*;

 import static com.sun.tools.javac.tree.JCTree.Tag.BLOCK;

 import static com.sun.tools.javac.tree.JCTree.Tag.SYNCHRONIZED;

 /** Utility class containing inspector methods for trees.

  *

  *  <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 TreeInfo {

     protected static final Context.Key<TreeInfo> treeInfoKey =

         new Context.Key<TreeInfo>();

     public static TreeInfo instance(Context context) {

         TreeInfo instance = context.get(treeInfoKey);

         if (instance == null)

             instance = new TreeInfo(context);

         return instance;

     }

     /** The names of all operators.

      */

     private Name[] opname = new Name[Tag.getNumberOfOperators()];

     private void setOpname(Tag tag, String name, Names names) {

          setOpname(tag, names.fromString(name));

      }

      private void setOpname(Tag tag, Name name) {

          opname[tag.operatorIndex()] = name;

      }

     private TreeInfo(Context context) {

         context.put(treeInfoKey, this);

         Names names = Names.instance(context);

         /*  Internally we use +++, --- for unary +, - to reduce +, - operators

          *  overloading

          */

         setOpname(POS, "+++", names);

         setOpname(NEG, "---", names);

         setOpname(NOT, "!", names);

         setOpname(COMPL, "~", names);

         setOpname(PREINC, "++", names);

         setOpname(PREDEC, "--", names);

         setOpname(POSTINC, "++", names);

         setOpname(POSTDEC, "--", names);

         setOpname(NULLCHK, "<*nullchk*>", names);

         setOpname(OR, "||", names);

         setOpname(AND, "&&", names);

         setOpname(EQ, "==", names);

         setOpname(NE, "!=", names);

         setOpname(LT, "<", names);

         setOpname(GT, ">", names);

         setOpname(LE, "<=", names);

         setOpname(GE, ">=", names);

         setOpname(BITOR, "|", names);

         setOpname(BITXOR, "^", names);

         setOpname(BITAND, "&", names);

         setOpname(SL, "<<", names);

         setOpname(SR, ">>", names);

         setOpname(USR, ">>>", names);

         setOpname(PLUS, "+", names);

         setOpname(MINUS, names.hyphen);

         setOpname(MUL, names.asterisk);

         setOpname(DIV, names.slash);

         setOpname(MOD, "%", names);

     }

     public static List<JCExpression> args(JCTree t) {

         switch (t.getTag()) {

             case APPLY:

                 return ((JCMethodInvocation)t).args;

             case NEWCLASS:

                 return ((JCNewClass)t).args;

             default:

                 return null;

         }

     }

     /** Return name of operator with given tree tag.

      */

     public Name operatorName(JCTree.Tag tag) {

         return opname[tag.operatorIndex()];

     }

     /** Is tree a constructor declaration?

      */

     public static boolean isConstructor(JCTree tree) {

         if (tree.hasTag(METHODDEF)) {

             Name name = ((JCMethodDecl) tree).name;

             return name == name.table.names.init;

         } else {

             return false;

         }

     }

     public static boolean isReceiverParam(JCTree tree) {

         if (tree.hasTag(VARDEF)) {

             return ((JCVariableDecl)tree).nameexpr != null;

         } else {

             return false;

         }

     }

     /** Is there a constructor declaration in the given list of trees?

      */

     public static boolean hasConstructors(List<JCTree> trees) {

         for (List<JCTree> l = trees; l.nonEmpty(); l = l.tail)

             if (isConstructor(l.head)) return true;

         return false;

     }

     public static boolean isMultiCatch(JCCatch catchClause) {

         return catchClause.param.vartype.hasTag(TYPEUNION);

     }

     /** Is statement an initializer for a synthetic field?

      */

     public static boolean isSyntheticInit(JCTree stat) {

         if (stat.hasTag(EXEC)) {

             JCExpressionStatement exec = (JCExpressionStatement)stat;

             if (exec.expr.hasTag(ASSIGN)) {

                 JCAssign assign = (JCAssign)exec.expr;

                 if (assign.lhs.hasTag(SELECT)) {

                     JCFieldAccess select = (JCFieldAccess)assign.lhs;

                     if (select.sym != null &&

                         (select.sym.flags() & SYNTHETIC) != 0) {

                         Name selected = name(select.selected);

                         if (selected != null && selected == selected.table.names._this)

                             return true;

                     }

                 }

             }

         }

         return false;

     }

     /** If the expression is a method call, return the method name, null

      *  otherwise. */

     public static Name calledMethodName(JCTree tree) {

         if (tree.hasTag(EXEC)) {

             JCExpressionStatement exec = (JCExpressionStatement)tree;

             if (exec.expr.hasTag(APPLY)) {

                 Name mname = TreeInfo.name(((JCMethodInvocation) exec.expr).meth);

                 return mname;

             }

         }

         return null;

     }

     /** Is this a call to this or super?

      */

     public static boolean isSelfCall(JCTree tree) {

         Name name = calledMethodName(tree);

         if (name != null) {

             Names names = name.table.names;

             return name==names._this || name==names._super;

         } else {

             return false;

         }

     }

     /** Is this a call to super?

      */

     public static boolean isSuperCall(JCTree tree) {

         Name name = calledMethodName(tree);

         if (name != null) {

             Names names = name.table.names;

             return name==names._super;

         } else {

             return false;

         }

     }

     /** Is this a constructor whose first (non-synthetic) statement is not

      *  of the form this(...)?

      */

     public static boolean isInitialConstructor(JCTree tree) {

         JCMethodInvocation app = firstConstructorCall(tree);

         if (app == null) return false;

         Name meth = name(app.meth);

         return meth == null || meth != meth.table.names._this;

     }

     /** Return the first call in a constructor definition. */

     public static JCMethodInvocation firstConstructorCall(JCTree tree) {

         if (!tree.hasTag(METHODDEF)) return null;

         JCMethodDecl md = (JCMethodDecl) tree;

         Names names = md.name.table.names;

         if (md.name != names.init) return null;

         if (md.body == null) return null;

         List<JCStatement> stats = md.body.stats;

         // Synthetic initializations can appear before the super call.

         while (stats.nonEmpty() && isSyntheticInit(stats.head))

             stats = stats.tail;

         if (stats.isEmpty()) return null;

         if (!stats.head.hasTag(EXEC)) return null;

         JCExpressionStatement exec = (JCExpressionStatement) stats.head;

         if (!exec.expr.hasTag(APPLY)) return null;

         return (JCMethodInvocation)exec.expr;

     }

     /** Return true if a tree represents a diamond new expr. */

     public static boolean isDiamond(JCTree tree) {

         switch(tree.getTag()) {

             case TYPEAPPLY: return ((JCTypeApply)tree).getTypeArguments().isEmpty();

             case NEWCLASS: return isDiamond(((JCNewClass)tree).clazz);

             case ANNOTATED_TYPE: return isDiamond(((JCAnnotatedType)tree).underlyingType);

             default: return false;

         }

     }

     public static boolean isEnumInit(JCTree tree) {

         switch (tree.getTag()) {

             case VARDEF:

                 return (((JCVariableDecl)tree).mods.flags & ENUM) != 0;

             default:

                 return false;

         }

     }

     /** set 'polyKind' on given tree */

     public static void setPolyKind(JCTree tree, PolyKind pkind) {

         switch (tree.getTag()) {

             case APPLY:

                 ((JCMethodInvocation)tree).polyKind = pkind;

                 break;

             case NEWCLASS:

                 ((JCNewClass)tree).polyKind = pkind;

                 break;

             case REFERENCE:

                 ((JCMemberReference)tree).refPolyKind = pkind;

                 break;

             default:

                 throw new AssertionError("Unexpected tree: " + tree);

         }

     }

     /** set 'varargsElement' on given tree */

     public static void setVarargsElement(JCTree tree, Type varargsElement) {

         switch (tree.getTag()) {

             case APPLY:

                 ((JCMethodInvocation)tree).varargsElement = varargsElement;

                 break;

             case NEWCLASS:

                 ((JCNewClass)tree).varargsElement = varargsElement;

                 break;

             case REFERENCE:

                 ((JCMemberReference)tree).varargsElement = varargsElement;

                 break;

             default:

                 throw new AssertionError("Unexpected tree: " + tree);

         }

     }

     /** Return true if the tree corresponds to an expression statement */

     public static boolean isExpressionStatement(JCExpression tree) {

         switch(tree.getTag()) {

             case PREINC: case PREDEC:

             case POSTINC: case POSTDEC:

             case ASSIGN:

             case BITOR_ASG: case BITXOR_ASG: case BITAND_ASG:

             case SL_ASG: case SR_ASG: case USR_ASG:

             case PLUS_ASG: case MINUS_ASG:

             case MUL_ASG: case DIV_ASG: case MOD_ASG:

             case APPLY: case NEWCLASS:

             case ERRONEOUS:

                 return true;

             default:

                 return false;

         }

     }

     /**

      * Return true if the AST corresponds to a static select of the kind A.B

      */

     public static boolean isStaticSelector(JCTree base, Names names) {

         if (base == null)

             return false;

         switch (base.getTag()) {

             case IDENT:

                 JCIdent id = (JCIdent)base;

                 return id.name != names._this &&

                         id.name != names._super &&

                         isStaticSym(base);

             case SELECT:

                 return isStaticSym(base) &&

                     isStaticSelector(((JCFieldAccess)base).selected, names);

             case TYPEAPPLY:

             case TYPEARRAY:

                 return true;

             case ANNOTATED_TYPE:

                 return isStaticSelector(((JCAnnotatedType)base).underlyingType, names);

             default:

                 return false;

         }

     }

     //where

         private static boolean isStaticSym(JCTree tree) {

             Symbol sym = symbol(tree);

             return (sym.kind == Kinds.TYP ||

                     sym.kind == Kinds.PCK);

         }

     /** Return true if a tree represents the null literal. */

     public static boolean isNull(JCTree tree) {

         if (!tree.hasTag(LITERAL))

             return false;

         JCLiteral lit = (JCLiteral) tree;

         return (lit.typetag == BOT);

     }

     /** Return true iff this tree is a child of some annotation. */

     public static boolean isInAnnotation(Env<?> env, JCTree tree) {

         TreePath tp = TreePath.getPath(env.toplevel, tree);

         if (tp != null) {

             for (Tree t : tp) {

                 if (t.getKind() == Tree.Kind.ANNOTATION)

                     return true;

             }

         }

         return false;

     }

     public static String getCommentText(Env<?> env, JCTree tree) {

         DocCommentTable docComments = (tree.hasTag(JCTree.Tag.TOPLEVEL))

                 ? ((JCCompilationUnit) tree).docComments

                 : env.toplevel.docComments;

         return (docComments == null) ? null : docComments.getCommentText(tree);

     }

     public static DCTree.DCDocComment getCommentTree(Env<?> env, JCTree tree) {

         DocCommentTable docComments = (tree.hasTag(JCTree.Tag.TOPLEVEL))

                 ? ((JCCompilationUnit) tree).docComments

                 : env.toplevel.docComments;

         return (docComments == null) ? null : docComments.getCommentTree(tree);

     }

     /** The position of the first statement in a block, or the position of

      *  the block itself if it is empty.

      */

     public static int firstStatPos(JCTree tree) {

         if (tree.hasTag(BLOCK) && ((JCBlock) tree).stats.nonEmpty())

             return ((JCBlock) tree).stats.head.pos;

         else

             return tree.pos;

     }

     /** The end position of given tree, if it is a block with

      *  defined endpos.

      */

     public static int endPos(JCTree tree) {

         if (tree.hasTag(BLOCK) && ((JCBlock) tree).endpos != Position.NOPOS)

             return ((JCBlock) tree).endpos;

         else if (tree.hasTag(SYNCHRONIZED))

             return endPos(((JCSynchronized) tree).body);

         else if (tree.hasTag(TRY)) {

             JCTry t = (JCTry) tree;

             return endPos((t.finalizer != null) ? t.finalizer

                           : (t.catchers.nonEmpty() ? t.catchers.last().body : t.body));

         } else

             return tree.pos;

     }

     /** Get the start position for a tree node.  The start position is

      * defined to be the position of the first character of the first

      * token of the node's source text.

      * @param tree  The tree node

      */

     public static int getStartPos(JCTree tree) {

         if (tree == null)

             return Position.NOPOS;

         switch(tree.getTag()) {

             case APPLY:

                 return getStartPos(((JCMethodInvocation) tree).meth);

             case ASSIGN:

                 return getStartPos(((JCAssign) tree).lhs);

             case BITOR_ASG: case BITXOR_ASG: case BITAND_ASG:

             case SL_ASG: case SR_ASG: case USR_ASG:

             case PLUS_ASG: case MINUS_ASG: case MUL_ASG:

             case DIV_ASG: case MOD_ASG:

                 return getStartPos(((JCAssignOp) tree).lhs);

             case OR: case AND: case BITOR:

             case BITXOR: case BITAND: case EQ:

             case NE: case LT: case GT:

             case LE: case GE: case SL:

             case SR: case USR: case PLUS:

             case MINUS: case MUL: case DIV:

             case MOD:

                 return getStartPos(((JCBinary) tree).lhs);

             case CLASSDEF: {

                 JCClassDecl node = (JCClassDecl)tree;

                 if (node.mods.pos != Position.NOPOS)

                     return node.mods.pos;

                 break;

             }

             case CONDEXPR:

                 return getStartPos(((JCConditional) tree).cond);

             case EXEC:

                 return getStartPos(((JCExpressionStatement) tree).expr);

             case INDEXED:

                 return getStartPos(((JCArrayAccess) tree).indexed);

             case METHODDEF: {

                 JCMethodDecl node = (JCMethodDecl)tree;

                 if (node.mods.pos != Position.NOPOS)

                     return node.mods.pos;

                 if (node.typarams.nonEmpty()) // List.nil() used for no typarams

                     return getStartPos(node.typarams.head);

                 return node.restype == null ? node.pos : getStartPos(node.restype);

             }

             case SELECT:

                 return getStartPos(((JCFieldAccess) tree).selected);

             case TYPEAPPLY:

                 return getStartPos(((JCTypeApply) tree).clazz);

             case TYPEARRAY:

                 return getStartPos(((JCArrayTypeTree) tree).elemtype);

             case TYPETEST:

                 return getStartPos(((JCInstanceOf) tree).expr);

             case POSTINC:

             case POSTDEC:

                 return getStartPos(((JCUnary) tree).arg);

             case ANNOTATED_TYPE: {

                 JCAnnotatedType node = (JCAnnotatedType) tree;

                 if (node.annotations.nonEmpty()) {

                     if (node.underlyingType.hasTag(TYPEARRAY) ||

                             node.underlyingType.hasTag(SELECT)) {

                         return getStartPos(node.underlyingType);

                     } else {

                         return getStartPos(node.annotations.head);

                     }

                 } else {

                     return getStartPos(node.underlyingType);

                 }

             }

             case NEWCLASS: {

                 JCNewClass node = (JCNewClass)tree;

                 if (node.encl != null)

                     return getStartPos(node.encl);

                 break;

             }

             case VARDEF: {

                 JCVariableDecl node = (JCVariableDecl)tree;

                 if (node.mods.pos != Position.NOPOS) {

                     return node.mods.pos;

                 } else if (node.vartype == null) {

                     //if there's no type (partially typed lambda parameter)

                     //simply return node position

                     return node.pos;

                 } else {

                     return getStartPos(node.vartype);

                 }

             }

             case ERRONEOUS: {

                 JCErroneous node = (JCErroneous)tree;

                 if (node.errs != null && node.errs.nonEmpty())

                     return getStartPos(node.errs.head);

             }

         }

         return tree.pos;

     }

     /** The end position of given tree, given  a table of end positions generated by the parser

      */

     public static int getEndPos(JCTree tree, EndPosTable endPosTable) {

         if (tree == null)

             return Position.NOPOS;

         if (endPosTable == null) {

             // fall back on limited info in the tree

             return endPos(tree);

         }

         int mapPos = endPosTable.getEndPos(tree);

         if (mapPos != Position.NOPOS)

             return mapPos;

         switch(tree.getTag()) {

             case BITOR_ASG: case BITXOR_ASG: case BITAND_ASG:

             case SL_ASG: case SR_ASG: case USR_ASG:

             case PLUS_ASG: case MINUS_ASG: case MUL_ASG:

             case DIV_ASG: case MOD_ASG:

                 return getEndPos(((JCAssignOp) tree).rhs, endPosTable);

             case OR: case AND: case BITOR:

             case BITXOR: case BITAND: case EQ:

             case NE: case LT: case GT:

             case LE: case GE: case SL:

             case SR: case USR: case PLUS:

             case MINUS: case MUL: case DIV:

             case MOD:

                 return getEndPos(((JCBinary) tree).rhs, endPosTable);

             case CASE:

                 return getEndPos(((JCCase) tree).stats.last(), endPosTable);

             case CATCH:

                 return getEndPos(((JCCatch) tree).body, endPosTable);

             case CONDEXPR:

                 return getEndPos(((JCConditional) tree).falsepart, endPosTable);

             case FORLOOP:

                 return getEndPos(((JCForLoop) tree).body, endPosTable);

             case FOREACHLOOP:

                 return getEndPos(((JCEnhancedForLoop) tree).body, endPosTable);

             case IF: {

                 JCIf node = (JCIf)tree;

                 if (node.elsepart == null) {

                     return getEndPos(node.thenpart, endPosTable);

                 } else {

                     return getEndPos(node.elsepart, endPosTable);

                 }

             }

             case LABELLED:

                 return getEndPos(((JCLabeledStatement) tree).body, endPosTable);

             case MODIFIERS:

                 return getEndPos(((JCModifiers) tree).annotations.last(), endPosTable);

             case SYNCHRONIZED:

                 return getEndPos(((JCSynchronized) tree).body, endPosTable);

             case TOPLEVEL:

                 return getEndPos(((JCCompilationUnit) tree).defs.last(), endPosTable);

             case TRY: {

                 JCTry node = (JCTry)tree;

                 if (node.finalizer != null) {

                     return getEndPos(node.finalizer, endPosTable);

                 } else if (!node.catchers.isEmpty()) {

                     return getEndPos(node.catchers.last(), endPosTable);

                 } else {

                     return getEndPos(node.body, endPosTable);

                 }

             }

             case WILDCARD:

                 return getEndPos(((JCWildcard) tree).inner, endPosTable);

             case TYPECAST:

                 return getEndPos(((JCTypeCast) tree).expr, endPosTable);

             case TYPETEST:

                 return getEndPos(((JCInstanceOf) tree).clazz, endPosTable);

             case POS:

             case NEG:

             case NOT:

             case COMPL:

             case PREINC:

             case PREDEC:

                 return getEndPos(((JCUnary) tree).arg, endPosTable);

             case WHILELOOP:

                 return getEndPos(((JCWhileLoop) tree).body, endPosTable);

             case ANNOTATED_TYPE:

                 return getEndPos(((JCAnnotatedType) tree).underlyingType, endPosTable);

             case ERRONEOUS: {

                 JCErroneous node = (JCErroneous)tree;

                 if (node.errs != null && node.errs.nonEmpty())

                     return getEndPos(node.errs.last(), endPosTable);

             }

         }

         return Position.NOPOS;

     }

     /** A DiagnosticPosition with the preferred position set to the

      *  end position of given tree, if it is a block with

      *  defined endpos.

      */

     public static DiagnosticPosition diagEndPos(final JCTree tree) {

         final int endPos = TreeInfo.endPos(tree);

         return new DiagnosticPosition() {

             public JCTree getTree() { return tree; }

             public int getStartPosition() { return TreeInfo.getStartPos(tree); }

             public int getPreferredPosition() { return endPos; }

             public int getEndPosition(EndPosTable endPosTable) {

                 return TreeInfo.getEndPos(tree, endPosTable);

             }

         };

     }

     public enum PosKind {

         START_POS() { int  toPos(JCTree tree) { return TreeInfo.getStartPos(tree); } },

         FIRST_STAT_POS() { int  toPos(JCTree tree) { return firstStatPos(tree); } },

         END_POS() { int  toPos(JCTree tree) { return endPos(tree); } };

         abstract int toPos(JCTree tree);

     }

     /** The position of the finalizer of given try/synchronized statement.

      */

     public static int finalizerPos(JCTree tree, PosKind posKind) {

         if (tree.hasTag(TRY)) {

             JCTry t = (JCTry) tree;

             Assert.checkNonNull(t.finalizer);

             return posKind.toPos(t.finalizer);

         } else if (tree.hasTag(SYNCHRONIZED)) {

             return endPos(((JCSynchronized) tree).body);

         } else {

             throw new AssertionError();

         }

     }

     /** Find the position for reporting an error about a symbol, where

      *  that symbol is defined somewhere in the given tree. */

     public static int positionFor(final Symbol sym, final JCTree tree) {

         JCTree decl = declarationFor(sym, tree);

         return ((decl != null) ? decl : tree).pos;

     }

     /** Find the position for reporting an error about a symbol, where

      *  that symbol is defined somewhere in the given tree. */

     public static DiagnosticPosition diagnosticPositionFor(final Symbol sym, final JCTree tree) {

         JCTree decl = declarationFor(sym, tree);

         return ((decl != null) ? decl : tree).pos();

     }

     /** Find the declaration for a symbol, where

      *  that symbol is defined somewhere in the given tree. */

     public static JCTree declarationFor(final Symbol sym, final JCTree tree) {

         class DeclScanner extends TreeScanner {

             JCTree result = null;

             public void scan(JCTree tree) {

                 if (tree!=null && result==null)

                     tree.accept(this);

             }

             public void visitTopLevel(JCCompilationUnit that) {

                 if (that.packge == sym) result = that;

                 else super.visitTopLevel(that);

             }

             public void visitClassDef(JCClassDecl that) {

                 if (that.sym == sym) result = that;

                 else super.visitClassDef(that);

             }

             public void visitMethodDef(JCMethodDecl that) {

                 if (that.sym == sym) result = that;

                 else super.visitMethodDef(that);

             }

             public void visitVarDef(JCVariableDecl that) {

                 if (that.sym == sym) result = that;

                 else super.visitVarDef(that);

             }

             public void visitTypeParameter(JCTypeParameter that) {

                 if (that.type != null && that.type.tsym == sym) result = that;

                 else super.visitTypeParameter(that);

             }

         }

         DeclScanner s = new DeclScanner();

         tree.accept(s);

         return s.result;

     }

     public static Env<AttrContext> scopeFor(JCTree node, JCCompilationUnit unit) {

         return scopeFor(pathFor(node, unit));

     }

     public static Env<AttrContext> scopeFor(List<JCTree> path) {

         // TODO: not implemented yet

         throw new UnsupportedOperationException("not implemented yet");

     }

     public static List<JCTree> pathFor(final JCTree node, final JCCompilationUnit unit) {

         class Result extends Error {

             static final long serialVersionUID = -5942088234594905625L;

             List<JCTree> path;

             Result(List<JCTree> path) {

                 this.path = path;

             }

         }

         class PathFinder extends TreeScanner {

             List<JCTree> path = List.nil();

             public void scan(JCTree tree) {

                 if (tree != null) {

                     path = path.prepend(tree);

                     if (tree == node)

                         throw new Result(path);

                     super.scan(tree);

                     path = path.tail;

                 }

             }

         }

         try {

             new PathFinder().scan(unit);

         } catch (Result result) {

             return result.path;

         }

         return List.nil();

     }

     /** Return the statement referenced by a label.

      *  If the label refers to a loop or switch, return that switch

      *  otherwise return the labelled statement itself

      */

     public static JCTree referencedStatement(JCLabeledStatement tree) {

         JCTree t = tree;

         do t = ((JCLabeledStatement) t).body;

         while (t.hasTag(LABELLED));

         switch (t.getTag()) {

         case DOLOOP: case WHILELOOP: case FORLOOP: case FOREACHLOOP: case SWITCH:

             return t;

         default:

             return tree;

         }

     }

     /** Skip parens and return the enclosed expression

      */

     public static JCExpression skipParens(JCExpression tree) {

         while (tree.hasTag(PARENS)) {

             tree = ((JCParens) tree).expr;

         }

         return tree;

     }

     /** Skip parens and return the enclosed expression

      */

     public static JCTree skipParens(JCTree tree) {

         if (tree.hasTag(PARENS))

             return skipParens((JCParens)tree);

         else

             return tree;

     }

     /** Return the types of a list of trees.

      */

     public static List<Type> types(List<? extends JCTree> trees) {

         ListBuffer<Type> ts = new ListBuffer<Type>();

         for (List<? extends JCTree> l = trees; l.nonEmpty(); l = l.tail)

             ts.append(l.head.type);

         return ts.toList();

     }

     /** If this tree is an identifier or a field or a parameterized type,

      *  return its name, otherwise return null.

      */

     public static Name name(JCTree tree) {

         switch (tree.getTag()) {

         case IDENT:

             return ((JCIdent) tree).name;

         case SELECT:

             return ((JCFieldAccess) tree).name;

         case TYPEAPPLY:

             return name(((JCTypeApply) tree).clazz);

         default:

             return null;

         }

     }

     /** If this tree is a qualified identifier, its return fully qualified name,

      *  otherwise return null.

      */

     public static Name fullName(JCTree tree) {

         tree = skipParens(tree);

         switch (tree.getTag()) {

         case IDENT:

             return ((JCIdent) tree).name;

         case SELECT:

             Name sname = fullName(((JCFieldAccess) tree).selected);

             return sname == null ? null : sname.append('.', name(tree));

         default:

             return null;

         }

     }

     public static Symbol symbolFor(JCTree node) {

         Symbol sym = symbolForImpl(node);

         return sym != null ? sym.baseSymbol() : null;

     }

     private static Symbol symbolForImpl(JCTree node) {

         node = skipParens(node);

         switch (node.getTag()) {

         case TOPLEVEL:

             return ((JCCompilationUnit) node).packge;

         case CLASSDEF:

             return ((JCClassDecl) node).sym;

         case METHODDEF:

             return ((JCMethodDecl) node).sym;

         case VARDEF:

             return ((JCVariableDecl) node).sym;

         case IDENT:

             return ((JCIdent) node).sym;

         case SELECT:

             return ((JCFieldAccess) node).sym;

         case REFERENCE:

             return ((JCMemberReference) node).sym;

         case NEWCLASS:

             return ((JCNewClass) node).constructor;

         case APPLY:

             return symbolFor(((JCMethodInvocation) node).meth);

         case TYPEAPPLY:

             return symbolFor(((JCTypeApply) node).clazz);

         case ANNOTATION:

         case TYPE_ANNOTATION:

         case TYPEPARAMETER:

             if (node.type != null)

                 return node.type.tsym;

             return null;

         default:

             return null;

         }

     }

     public static boolean isDeclaration(JCTree node) {

         node = skipParens(node);

         switch (node.getTag()) {

         case CLASSDEF:

         case METHODDEF:

         case VARDEF:

             return true;

         default:

             return false;

         }

     }

     /** If this tree is an identifier or a field, return its symbol,

      *  otherwise return null.

      */

     public static Symbol symbol(JCTree tree) {

         tree = skipParens(tree);

         switch (tree.getTag()) {

         case IDENT:

             return ((JCIdent) tree).sym;

         case SELECT:

             return ((JCFieldAccess) tree).sym;

         case TYPEAPPLY:

             return symbol(((JCTypeApply) tree).clazz);

         case ANNOTATED_TYPE:

             return symbol(((JCAnnotatedType) tree).underlyingType);

         case REFERENCE:

             return ((JCMemberReference) tree).sym;

         default:

             return null;

         }

     }

     /** Return true if this is a nonstatic selection. */

     public static boolean nonstaticSelect(JCTree tree) {

         tree = skipParens(tree);

         if (!tree.hasTag(SELECT)) return false;

         JCFieldAccess s = (JCFieldAccess) tree;

         Symbol e = symbol(s.selected);

         return e == null || (e.kind != Kinds.PCK && e.kind != Kinds.TYP);

     }

     /** If this tree is an identifier or a field, set its symbol, otherwise skip.

      */

     public static void setSymbol(JCTree tree, Symbol sym) {

         tree = skipParens(tree);

         switch (tree.getTag()) {

         case IDENT:

             ((JCIdent) tree).sym = sym; break;

         case SELECT:

             ((JCFieldAccess) tree).sym = sym; break;

         default:

         }

     }

     /** If this tree is a declaration or a block, return its flags field,

      *  otherwise return 0.

      */

     public static long flags(JCTree tree) {

         switch (tree.getTag()) {

         case VARDEF:

             return ((JCVariableDecl) tree).mods.flags;

         case METHODDEF:

             return ((JCMethodDecl) tree).mods.flags;

         case CLASSDEF:

             return ((JCClassDecl) tree).mods.flags;

         case BLOCK:

             return ((JCBlock) tree).flags;

         default:

             return 0;

         }

     }

     /** Return first (smallest) flag in `flags':

      *  pre: flags != 0

      */

     public static long firstFlag(long flags) {

         long flag = 1;

         while ((flag & flags & ExtendedStandardFlags) == 0)

             flag = flag << 1;

         return flag;

     }

     /** Return flags as a string, separated by " ".

      */

     public static String flagNames(long flags) {

         return Flags.toString(flags & ExtendedStandardFlags).trim();

     }

     /** Operator precedences values.

      */

     public static final int

         notExpression = -1,   // not an expression

         noPrec = 0,           // no enclosing expression

         assignPrec = 1,

         assignopPrec = 2,

         condPrec = 3,

         orPrec = 4,

         andPrec = 5,

         bitorPrec = 6,

         bitxorPrec = 7,

         bitandPrec = 8,

         eqPrec = 9,

         ordPrec = 10,

         shiftPrec = 11,

         addPrec = 12,

         mulPrec = 13,

         prefixPrec = 14,

         postfixPrec = 15,

         precCount = 16;

     /** Map operators to their precedence levels.

      */

     public static int opPrec(JCTree.Tag op) {

         switch(op) {

         case POS:

         case NEG:

         case NOT:

         case COMPL:

         case PREINC:

         case PREDEC: return prefixPrec;

         case POSTINC:

         case POSTDEC:

         case NULLCHK: return postfixPrec;

         case ASSIGN: return assignPrec;

         case BITOR_ASG:

         case BITXOR_ASG:

         case BITAND_ASG:

         case SL_ASG:

         case SR_ASG:

         case USR_ASG:

         case PLUS_ASG:

         case MINUS_ASG:

         case MUL_ASG:

         case DIV_ASG:

         case MOD_ASG: return assignopPrec;

         case OR: return orPrec;

         case AND: return andPrec;

         case EQ:

         case NE: return eqPrec;

         case LT:

         case GT:

         case LE:

         case GE: return ordPrec;

         case BITOR: return bitorPrec;

         case BITXOR: return bitxorPrec;

         case BITAND: return bitandPrec;

         case SL:

         case SR:

         case USR: return shiftPrec;

         case PLUS:

         case MINUS: return addPrec;

         case MUL:

         case DIV:

         case MOD: return mulPrec;

         case TYPETEST: return ordPrec;

         default: throw new AssertionError();

         }

     }

     static Tree.Kind tagToKind(JCTree.Tag tag) {

         switch (tag) {

         // Postfix expressions

         case POSTINC:           // _ ++

             return Tree.Kind.POSTFIX_INCREMENT;

         case POSTDEC:           // _ --

             return Tree.Kind.POSTFIX_DECREMENT;

         // Unary operators

         case PREINC:            // ++ _

             return Tree.Kind.PREFIX_INCREMENT;

         case PREDEC:            // -- _

             return Tree.Kind.PREFIX_DECREMENT;

         case POS:               // +

             return Tree.Kind.UNARY_PLUS;

         case NEG:               // -

             return Tree.Kind.UNARY_MINUS;

         case COMPL:             // ~

             return Tree.Kind.BITWISE_COMPLEMENT;

         case NOT:               // !

             return Tree.Kind.LOGICAL_COMPLEMENT;

         // Binary operators

         // Multiplicative operators

         case MUL:               // *

             return Tree.Kind.MULTIPLY;

         case DIV:               // /

             return Tree.Kind.DIVIDE;

         case MOD:               // %

             return Tree.Kind.REMAINDER;

         // Additive operators

         case PLUS:              // +

             return Tree.Kind.PLUS;

         case MINUS:             // -

             return Tree.Kind.MINUS;

         // Shift operators

         case SL:                // <<

             return Tree.Kind.LEFT_SHIFT;

         case SR:                // >>

             return Tree.Kind.RIGHT_SHIFT;

         case USR:               // >>>

             return Tree.Kind.UNSIGNED_RIGHT_SHIFT;

         // Relational operators

         case LT:                // <

             return Tree.Kind.LESS_THAN;

         case GT:                // >

             return Tree.Kind.GREATER_THAN;

         case LE:                // <=

             return Tree.Kind.LESS_THAN_EQUAL;

         case GE:                // >=

             return Tree.Kind.GREATER_THAN_EQUAL;

         // Equality operators

         case EQ:                // ==

             return Tree.Kind.EQUAL_TO;

         case NE:                // !=

             return Tree.Kind.NOT_EQUAL_TO;

         // Bitwise and logical operators

         case BITAND:            // &

             return Tree.Kind.AND;

         case BITXOR:            // ^

             return Tree.Kind.XOR;

         case BITOR:             // |

             return Tree.Kind.OR;

         // Conditional operators

         case AND:               // &&

             return Tree.Kind.CONDITIONAL_AND;

         case OR:                // ||

             return Tree.Kind.CONDITIONAL_OR;

         // Assignment operators

         case MUL_ASG:           // *=

             return Tree.Kind.MULTIPLY_ASSIGNMENT;

         case DIV_ASG:           // /=

             return Tree.Kind.DIVIDE_ASSIGNMENT;

         case MOD_ASG:           // %=

             return Tree.Kind.REMAINDER_ASSIGNMENT;

         case PLUS_ASG:          // +=

             return Tree.Kind.PLUS_ASSIGNMENT;

         case MINUS_ASG:         // -=

             return Tree.Kind.MINUS_ASSIGNMENT;

         case SL_ASG:            // <<=

             return Tree.Kind.LEFT_SHIFT_ASSIGNMENT;

         case SR_ASG:            // >>=

             return Tree.Kind.RIGHT_SHIFT_ASSIGNMENT;

         case USR_ASG:           // >>>=

             return Tree.Kind.UNSIGNED_RIGHT_SHIFT_ASSIGNMENT;

         case BITAND_ASG:        // &=

             return Tree.Kind.AND_ASSIGNMENT;

         case BITXOR_ASG:        // ^=

             return Tree.Kind.XOR_ASSIGNMENT;

         case BITOR_ASG:         // |=

             return Tree.Kind.OR_ASSIGNMENT;

         // Null check (implementation detail), for example, __.getClass()

         case NULLCHK:

             return Tree.Kind.OTHER;

         case ANNOTATION:

             return Tree.Kind.ANNOTATION;

         case TYPE_ANNOTATION:

             return Tree.Kind.TYPE_ANNOTATION;

         default:

             return null;

         }

     }

     /**

      * Returns the underlying type of the tree if it is an annotated type,

      * or the tree itself otherwise.

      */

     public static JCExpression typeIn(JCExpression tree) {

         switch (tree.getTag()) {

         case ANNOTATED_TYPE:

             return ((JCAnnotatedType)tree).underlyingType;

         case IDENT: /* simple names */

         case TYPEIDENT: /* primitive name */

         case SELECT: /* qualified name */

         case TYPEARRAY: /* array types */

         case WILDCARD: /* wild cards */

         case TYPEPARAMETER: /* type parameters */

         case TYPEAPPLY: /* parameterized types */

         case ERRONEOUS: /* error tree TODO: needed for BadCast JSR308 test case. Better way? */

             return tree;

         default:

             throw new AssertionError("Unexpected type tree: " + tree);

         }

     }

     /* Return the inner-most type of a type tree.

      * For an array that contains an annotated type, return that annotated type.

      * TODO: currently only used by Pretty. Describe behavior better.

      */

     public static JCTree innermostType(JCTree type) {

         JCTree lastAnnotatedType = null;

         JCTree cur = type;

         loop: while (true) {

             switch (cur.getTag()) {

             case TYPEARRAY:

                 lastAnnotatedType = null;

                 cur = ((JCArrayTypeTree)cur).elemtype;

                 break;

             case WILDCARD:

                 lastAnnotatedType = null;

                 cur = ((JCWildcard)cur).inner;

                 break;

             case ANNOTATED_TYPE:

                 lastAnnotatedType = cur;

                 cur = ((JCAnnotatedType)cur).underlyingType;

                 break;

             default:

                 break loop;

             }

         }

         if (lastAnnotatedType!=null) {

             return lastAnnotatedType;

         } else {

             return cur;

         }

     }

     private static class TypeAnnotationFinder extends TreeScanner {

         public boolean foundTypeAnno = false;

         @Override

         public void scan(JCTree tree) {

             if (foundTypeAnno || tree == null)

                 return;

             super.scan(tree);

         }

         public void visitAnnotation(JCAnnotation tree) {

             foundTypeAnno = foundTypeAnno || tree.hasTag(TYPE_ANNOTATION);

         }

     }

     public static boolean containsTypeAnnotation(JCTree e) {

         TypeAnnotationFinder finder = new TypeAnnotationFinder();

         finder.scan(e);

         return finder.foundTypeAnno;

     }

 }