src/share/classes/com/sun/tools/javac/tree/TreeInfo.java
Print this page
*** 54,110 ****
return instance;
}
/** The names of all operators.
*/
! private Name[] opname = new Name[JCTree.MOD - JCTree.POS + 1];
private TreeInfo(Context context) {
context.put(treeInfoKey, this);
Names names = Names.instance(context);
! opname[JCTree.POS - JCTree.POS] = names.fromString("+");
! opname[JCTree.NEG - JCTree.POS] = names.hyphen;
! opname[JCTree.NOT - JCTree.POS] = names.fromString("!");
! opname[JCTree.COMPL - JCTree.POS] = names.fromString("~");
! opname[JCTree.PREINC - JCTree.POS] = names.fromString("++");
! opname[JCTree.PREDEC - JCTree.POS] = names.fromString("--");
! opname[JCTree.POSTINC - JCTree.POS] = names.fromString("++");
! opname[JCTree.POSTDEC - JCTree.POS] = names.fromString("--");
! opname[JCTree.NULLCHK - JCTree.POS] = names.fromString("<*nullchk*>");
! opname[JCTree.OR - JCTree.POS] = names.fromString("||");
! opname[JCTree.AND - JCTree.POS] = names.fromString("&&");
! opname[JCTree.EQ - JCTree.POS] = names.fromString("==");
! opname[JCTree.NE - JCTree.POS] = names.fromString("!=");
! opname[JCTree.LT - JCTree.POS] = names.fromString("<");
! opname[JCTree.GT - JCTree.POS] = names.fromString(">");
! opname[JCTree.LE - JCTree.POS] = names.fromString("<=");
! opname[JCTree.GE - JCTree.POS] = names.fromString(">=");
! opname[JCTree.BITOR - JCTree.POS] = names.fromString("|");
! opname[JCTree.BITXOR - JCTree.POS] = names.fromString("^");
! opname[JCTree.BITAND - JCTree.POS] = names.fromString("&");
! opname[JCTree.SL - JCTree.POS] = names.fromString("<<");
! opname[JCTree.SR - JCTree.POS] = names.fromString(">>");
! opname[JCTree.USR - JCTree.POS] = names.fromString(">>>");
! opname[JCTree.PLUS - JCTree.POS] = names.fromString("+");
! opname[JCTree.MINUS - JCTree.POS] = names.hyphen;
! opname[JCTree.MUL - JCTree.POS] = names.asterisk;
! opname[JCTree.DIV - JCTree.POS] = names.slash;
! opname[JCTree.MOD - JCTree.POS] = names.fromString("%");
}
/** Return name of operator with given tree tag.
*/
! public Name operatorName(int tag) {
! return opname[tag - JCTree.POS];
}
/** Is tree a constructor declaration?
*/
public static boolean isConstructor(JCTree tree) {
! if (tree.getTag() == JCTree.METHODDEF) {
Name name = ((JCMethodDecl) tree).name;
return name == name.table.names.init;
} else {
return false;
}
--- 54,110 ----
return instance;
}
/** The names of all operators.
*/
! private Name[] opname = new Name[JCTree.Tag.MOD.ordinal() - JCTree.Tag.POS.ordinal() + 1];
private TreeInfo(Context context) {
context.put(treeInfoKey, this);
Names names = Names.instance(context);
! opname[JCTree.Tag.POS.ordinal() - JCTree.Tag.POS.ordinal()] = names.fromString("+");
! opname[JCTree.Tag.NEG.ordinal() - JCTree.Tag.POS.ordinal()] = names.hyphen;
! opname[JCTree.Tag.NOT.ordinal() - JCTree.Tag.POS.ordinal()] = names.fromString("!");
! opname[JCTree.Tag.COMPL.ordinal() - JCTree.Tag.POS.ordinal()] = names.fromString("~");
! opname[JCTree.Tag.PREINC.ordinal() - JCTree.Tag.POS.ordinal()] = names.fromString("++");
! opname[JCTree.Tag.PREDEC.ordinal() - JCTree.Tag.POS.ordinal()] = names.fromString("--");
! opname[JCTree.Tag.POSTINC.ordinal() - JCTree.Tag.POS.ordinal()] = names.fromString("++");
! opname[JCTree.Tag.POSTDEC.ordinal() - JCTree.Tag.POS.ordinal()] = names.fromString("--");
! opname[JCTree.Tag.NULLCHK.ordinal() - JCTree.Tag.POS.ordinal()] = names.fromString("<*nullchk*>");
! opname[JCTree.Tag.OR.ordinal() - JCTree.Tag.POS.ordinal()] = names.fromString("||");
! opname[JCTree.Tag.AND.ordinal() - JCTree.Tag.POS.ordinal()] = names.fromString("&&");
! opname[JCTree.Tag.EQ.ordinal() - JCTree.Tag.POS.ordinal()] = names.fromString("==");
! opname[JCTree.Tag.NE.ordinal() - JCTree.Tag.POS.ordinal()] = names.fromString("!=");
! opname[JCTree.Tag.LT.ordinal() - JCTree.Tag.POS.ordinal()] = names.fromString("<");
! opname[JCTree.Tag.GT.ordinal() - JCTree.Tag.POS.ordinal()] = names.fromString(">");
! opname[JCTree.Tag.LE.ordinal() - JCTree.Tag.POS.ordinal()] = names.fromString("<=");
! opname[JCTree.Tag.GE.ordinal() - JCTree.Tag.POS.ordinal()] = names.fromString(">=");
! opname[JCTree.Tag.BITOR.ordinal() - JCTree.Tag.POS.ordinal()] = names.fromString("|");
! opname[JCTree.Tag.BITXOR.ordinal() - JCTree.Tag.POS.ordinal()] = names.fromString("^");
! opname[JCTree.Tag.BITAND.ordinal() - JCTree.Tag.POS.ordinal()] = names.fromString("&");
! opname[JCTree.Tag.SL.ordinal() - JCTree.Tag.POS.ordinal()] = names.fromString("<<");
! opname[JCTree.Tag.SR.ordinal() - JCTree.Tag.POS.ordinal()] = names.fromString(">>");
! opname[JCTree.Tag.USR.ordinal() - JCTree.Tag.POS.ordinal()] = names.fromString(">>>");
! opname[JCTree.Tag.PLUS.ordinal() - JCTree.Tag.POS.ordinal()] = names.fromString("+");
! opname[JCTree.Tag.MINUS.ordinal() - JCTree.Tag.POS.ordinal()] = names.hyphen;
! opname[JCTree.Tag.MUL.ordinal() - JCTree.Tag.POS.ordinal()] = names.asterisk;
! opname[JCTree.Tag.DIV.ordinal() - JCTree.Tag.POS.ordinal()] = names.slash;
! opname[JCTree.Tag.MOD.ordinal() - JCTree.Tag.POS.ordinal()] = names.fromString("%");
}
/** Return name of operator with given tree tag.
*/
! public Name operatorName(JCTree.Tag tag) {
! return opname[tag.ordinal() - JCTree.Tag.POS.ordinal()];
}
/** Is tree a constructor declaration?
*/
public static boolean isConstructor(JCTree tree) {
! if (tree.getTag() == JCTree.Tag.METHODDEF) {
Name name = ((JCMethodDecl) tree).name;
return name == name.table.names.init;
} else {
return false;
}
*** 117,137 ****
if (isConstructor(l.head)) return true;
return false;
}
public static boolean isMultiCatch(JCCatch catchClause) {
! return catchClause.param.vartype.getTag() == JCTree.TYPEUNION;
}
/** Is statement an initializer for a synthetic field?
*/
public static boolean isSyntheticInit(JCTree stat) {
! if (stat.getTag() == JCTree.EXEC) {
JCExpressionStatement exec = (JCExpressionStatement)stat;
! if (exec.expr.getTag() == JCTree.ASSIGN) {
JCAssign assign = (JCAssign)exec.expr;
! if (assign.lhs.getTag() == JCTree.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)
--- 117,137 ----
if (isConstructor(l.head)) return true;
return false;
}
public static boolean isMultiCatch(JCCatch catchClause) {
! return catchClause.param.vartype.getTag() == JCTree.Tag.TYPEUNION;
}
/** Is statement an initializer for a synthetic field?
*/
public static boolean isSyntheticInit(JCTree stat) {
! if (stat.getTag() == JCTree.Tag.EXEC) {
JCExpressionStatement exec = (JCExpressionStatement)stat;
! if (exec.expr.getTag() == JCTree.Tag.ASSIGN) {
JCAssign assign = (JCAssign)exec.expr;
! if (assign.lhs.getTag() == JCTree.Tag.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)
*** 144,156 ****
}
/** If the expression is a method call, return the method name, null
* otherwise. */
public static Name calledMethodName(JCTree tree) {
! if (tree.getTag() == JCTree.EXEC) {
JCExpressionStatement exec = (JCExpressionStatement)tree;
! if (exec.expr.getTag() == JCTree.APPLY) {
Name mname = TreeInfo.name(((JCMethodInvocation) exec.expr).meth);
return mname;
}
}
return null;
--- 144,156 ----
}
/** If the expression is a method call, return the method name, null
* otherwise. */
public static Name calledMethodName(JCTree tree) {
! if (tree.getTag() == JCTree.Tag.EXEC) {
JCExpressionStatement exec = (JCExpressionStatement)tree;
! if (exec.expr.getTag() == JCTree.Tag.APPLY) {
Name mname = TreeInfo.name(((JCMethodInvocation) exec.expr).meth);
return mname;
}
}
return null;
*** 190,251 ****
return meth == null || meth != meth.table.names._this;
}
/** Return the first call in a constructor definition. */
public static JCMethodInvocation firstConstructorCall(JCTree tree) {
! if (tree.getTag() != JCTree.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.getTag() != JCTree.EXEC) return null;
JCExpressionStatement exec = (JCExpressionStatement) stats.head;
! if (exec.expr.getTag() != JCTree.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 JCTree.TYPEAPPLY: return ((JCTypeApply)tree).getTypeArguments().isEmpty();
! case JCTree.NEWCLASS: return isDiamond(((JCNewClass)tree).clazz);
default: return false;
}
}
/** Return true if a tree represents the null literal. */
public static boolean isNull(JCTree tree) {
! if (tree.getTag() != JCTree.LITERAL)
return false;
JCLiteral lit = (JCLiteral) tree;
return (lit.typetag == TypeTags.BOT);
}
/** 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.getTag() == JCTree.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.getTag() == JCTree.BLOCK && ((JCBlock) tree).endpos != Position.NOPOS)
return ((JCBlock) tree).endpos;
! else if (tree.getTag() == JCTree.SYNCHRONIZED)
return endPos(((JCSynchronized) tree).body);
! else if (tree.getTag() == JCTree.TRY) {
JCTry t = (JCTry) tree;
return endPos((t.finalizer != null)
? t.finalizer
: t.catchers.last().body);
} else
--- 190,251 ----
return meth == null || meth != meth.table.names._this;
}
/** Return the first call in a constructor definition. */
public static JCMethodInvocation firstConstructorCall(JCTree tree) {
! if (tree.getTag() != JCTree.Tag.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.getTag() != JCTree.Tag.EXEC) return null;
JCExpressionStatement exec = (JCExpressionStatement) stats.head;
! if (exec.expr.getTag() != JCTree.Tag.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);
default: return false;
}
}
/** Return true if a tree represents the null literal. */
public static boolean isNull(JCTree tree) {
! if (tree.getTag() != JCTree.Tag.LITERAL)
return false;
JCLiteral lit = (JCLiteral) tree;
return (lit.typetag == TypeTags.BOT);
}
/** 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.getTag() == JCTree.Tag.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.getTag() == JCTree.Tag.BLOCK && ((JCBlock) tree).endpos != Position.NOPOS)
return ((JCBlock) tree).endpos;
! else if (tree.getTag() == JCTree.Tag.SYNCHRONIZED)
return endPos(((JCSynchronized) tree).body);
! else if (tree.getTag() == JCTree.Tag.TRY) {
JCTry t = (JCTry) tree;
return endPos((t.finalizer != null)
? t.finalizer
: t.catchers.last().body);
} else
*** 261,333 ****
public static int getStartPos(JCTree tree) {
if (tree == null)
return Position.NOPOS;
switch(tree.getTag()) {
! case(JCTree.APPLY):
return getStartPos(((JCMethodInvocation) tree).meth);
! case(JCTree.ASSIGN):
return getStartPos(((JCAssign) tree).lhs);
! case(JCTree.BITOR_ASG): case(JCTree.BITXOR_ASG): case(JCTree.BITAND_ASG):
! case(JCTree.SL_ASG): case(JCTree.SR_ASG): case(JCTree.USR_ASG):
! case(JCTree.PLUS_ASG): case(JCTree.MINUS_ASG): case(JCTree.MUL_ASG):
! case(JCTree.DIV_ASG): case(JCTree.MOD_ASG):
return getStartPos(((JCAssignOp) tree).lhs);
! case(JCTree.OR): case(JCTree.AND): case(JCTree.BITOR):
! case(JCTree.BITXOR): case(JCTree.BITAND): case(JCTree.EQ):
! case(JCTree.NE): case(JCTree.LT): case(JCTree.GT):
! case(JCTree.LE): case(JCTree.GE): case(JCTree.SL):
! case(JCTree.SR): case(JCTree.USR): case(JCTree.PLUS):
! case(JCTree.MINUS): case(JCTree.MUL): case(JCTree.DIV):
! case(JCTree.MOD):
return getStartPos(((JCBinary) tree).lhs);
! case(JCTree.CLASSDEF): {
JCClassDecl node = (JCClassDecl)tree;
if (node.mods.pos != Position.NOPOS)
return node.mods.pos;
break;
}
! case(JCTree.CONDEXPR):
return getStartPos(((JCConditional) tree).cond);
! case(JCTree.EXEC):
return getStartPos(((JCExpressionStatement) tree).expr);
! case(JCTree.INDEXED):
return getStartPos(((JCArrayAccess) tree).indexed);
! case(JCTree.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(JCTree.SELECT):
return getStartPos(((JCFieldAccess) tree).selected);
! case(JCTree.TYPEAPPLY):
return getStartPos(((JCTypeApply) tree).clazz);
! case(JCTree.TYPEARRAY):
return getStartPos(((JCArrayTypeTree) tree).elemtype);
! case(JCTree.TYPETEST):
return getStartPos(((JCInstanceOf) tree).expr);
! case(JCTree.POSTINC):
! case(JCTree.POSTDEC):
return getStartPos(((JCUnary) tree).arg);
! case(JCTree.NEWCLASS): {
JCNewClass node = (JCNewClass)tree;
if (node.encl != null)
return getStartPos(node.encl);
break;
}
! case(JCTree.VARDEF): {
JCVariableDecl node = (JCVariableDecl)tree;
if (node.mods.pos != Position.NOPOS) {
return node.mods.pos;
} else {
return getStartPos(node.vartype);
}
}
! case(JCTree.ERRONEOUS): {
JCErroneous node = (JCErroneous)tree;
if (node.errs != null && node.errs.nonEmpty())
return getStartPos(node.errs.head);
}
}
--- 261,333 ----
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 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 {
return getStartPos(node.vartype);
}
}
! case ERRONEOUS: {
JCErroneous node = (JCErroneous)tree;
if (node.errs != null && node.errs.nonEmpty())
return getStartPos(node.errs.head);
}
}
*** 348,422 ****
Integer mapPos = endPositions.get(tree);
if (mapPos != null)
return mapPos;
switch(tree.getTag()) {
! case(JCTree.BITOR_ASG): case(JCTree.BITXOR_ASG): case(JCTree.BITAND_ASG):
! case(JCTree.SL_ASG): case(JCTree.SR_ASG): case(JCTree.USR_ASG):
! case(JCTree.PLUS_ASG): case(JCTree.MINUS_ASG): case(JCTree.MUL_ASG):
! case(JCTree.DIV_ASG): case(JCTree.MOD_ASG):
return getEndPos(((JCAssignOp) tree).rhs, endPositions);
! case(JCTree.OR): case(JCTree.AND): case(JCTree.BITOR):
! case(JCTree.BITXOR): case(JCTree.BITAND): case(JCTree.EQ):
! case(JCTree.NE): case(JCTree.LT): case(JCTree.GT):
! case(JCTree.LE): case(JCTree.GE): case(JCTree.SL):
! case(JCTree.SR): case(JCTree.USR): case(JCTree.PLUS):
! case(JCTree.MINUS): case(JCTree.MUL): case(JCTree.DIV):
! case(JCTree.MOD):
return getEndPos(((JCBinary) tree).rhs, endPositions);
! case(JCTree.CASE):
return getEndPos(((JCCase) tree).stats.last(), endPositions);
! case(JCTree.CATCH):
return getEndPos(((JCCatch) tree).body, endPositions);
! case(JCTree.CONDEXPR):
return getEndPos(((JCConditional) tree).falsepart, endPositions);
! case(JCTree.FORLOOP):
return getEndPos(((JCForLoop) tree).body, endPositions);
! case(JCTree.FOREACHLOOP):
return getEndPos(((JCEnhancedForLoop) tree).body, endPositions);
! case(JCTree.IF): {
JCIf node = (JCIf)tree;
if (node.elsepart == null) {
return getEndPos(node.thenpart, endPositions);
} else {
return getEndPos(node.elsepart, endPositions);
}
}
! case(JCTree.LABELLED):
return getEndPos(((JCLabeledStatement) tree).body, endPositions);
! case(JCTree.MODIFIERS):
return getEndPos(((JCModifiers) tree).annotations.last(), endPositions);
! case(JCTree.SYNCHRONIZED):
return getEndPos(((JCSynchronized) tree).body, endPositions);
! case(JCTree.TOPLEVEL):
return getEndPos(((JCCompilationUnit) tree).defs.last(), endPositions);
! case(JCTree.TRY): {
JCTry node = (JCTry)tree;
if (node.finalizer != null) {
return getEndPos(node.finalizer, endPositions);
} else if (!node.catchers.isEmpty()) {
return getEndPos(node.catchers.last(), endPositions);
} else {
return getEndPos(node.body, endPositions);
}
}
! case(JCTree.WILDCARD):
return getEndPos(((JCWildcard) tree).inner, endPositions);
! case(JCTree.TYPECAST):
return getEndPos(((JCTypeCast) tree).expr, endPositions);
! case(JCTree.TYPETEST):
return getEndPos(((JCInstanceOf) tree).clazz, endPositions);
! case(JCTree.POS):
! case(JCTree.NEG):
! case(JCTree.NOT):
! case(JCTree.COMPL):
! case(JCTree.PREINC):
! case(JCTree.PREDEC):
return getEndPos(((JCUnary) tree).arg, endPositions);
! case(JCTree.WHILELOOP):
return getEndPos(((JCWhileLoop) tree).body, endPositions);
! case(JCTree.ERRONEOUS): {
JCErroneous node = (JCErroneous)tree;
if (node.errs != null && node.errs.nonEmpty())
return getEndPos(node.errs.last(), endPositions);
}
}
--- 348,422 ----
Integer mapPos = endPositions.get(tree);
if (mapPos != null)
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, endPositions);
! 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, endPositions);
! case CASE:
return getEndPos(((JCCase) tree).stats.last(), endPositions);
! case CATCH:
return getEndPos(((JCCatch) tree).body, endPositions);
! case CONDEXPR:
return getEndPos(((JCConditional) tree).falsepart, endPositions);
! case FORLOOP:
return getEndPos(((JCForLoop) tree).body, endPositions);
! case FOREACHLOOP:
return getEndPos(((JCEnhancedForLoop) tree).body, endPositions);
! case IF: {
JCIf node = (JCIf)tree;
if (node.elsepart == null) {
return getEndPos(node.thenpart, endPositions);
} else {
return getEndPos(node.elsepart, endPositions);
}
}
! case LABELLED:
return getEndPos(((JCLabeledStatement) tree).body, endPositions);
! case MODIFIERS:
return getEndPos(((JCModifiers) tree).annotations.last(), endPositions);
! case SYNCHRONIZED:
return getEndPos(((JCSynchronized) tree).body, endPositions);
! case TOPLEVEL:
return getEndPos(((JCCompilationUnit) tree).defs.last(), endPositions);
! case TRY: {
JCTry node = (JCTry)tree;
if (node.finalizer != null) {
return getEndPos(node.finalizer, endPositions);
} else if (!node.catchers.isEmpty()) {
return getEndPos(node.catchers.last(), endPositions);
} else {
return getEndPos(node.body, endPositions);
}
}
! case WILDCARD:
return getEndPos(((JCWildcard) tree).inner, endPositions);
! case TYPECAST:
return getEndPos(((JCTypeCast) tree).expr, endPositions);
! case TYPETEST:
return getEndPos(((JCInstanceOf) tree).clazz, endPositions);
! case POS:
! case NEG:
! case NOT:
! case COMPL:
! case PREINC:
! case PREDEC:
return getEndPos(((JCUnary) tree).arg, endPositions);
! case WHILELOOP:
return getEndPos(((JCWhileLoop) tree).body, endPositions);
! case ERRONEOUS: {
JCErroneous node = (JCErroneous)tree;
if (node.errs != null && node.errs.nonEmpty())
return getEndPos(node.errs.last(), endPositions);
}
}
*** 441,455 ****
}
/** The position of the finalizer of given try/synchronized statement.
*/
public static int finalizerPos(JCTree tree) {
! if (tree.getTag() == JCTree.TRY) {
JCTry t = (JCTry) tree;
Assert.checkNonNull(t.finalizer);
return firstStatPos(t.finalizer);
! } else if (tree.getTag() == JCTree.SYNCHRONIZED) {
return endPos(((JCSynchronized) tree).body);
} else {
throw new AssertionError();
}
}
--- 441,455 ----
}
/** The position of the finalizer of given try/synchronized statement.
*/
public static int finalizerPos(JCTree tree) {
! if (tree.getTag() == JCTree.Tag.TRY) {
JCTry t = (JCTry) tree;
Assert.checkNonNull(t.finalizer);
return firstStatPos(t.finalizer);
! } else if (tree.getTag() == JCTree.Tag.SYNCHRONIZED) {
return endPos(((JCSynchronized) tree).body);
} else {
throw new AssertionError();
}
}
*** 545,576 ****
* otherwise return the labelled statement itself
*/
public static JCTree referencedStatement(JCLabeledStatement tree) {
JCTree t = tree;
do t = ((JCLabeledStatement) t).body;
! while (t.getTag() == JCTree.LABELLED);
switch (t.getTag()) {
! case JCTree.DOLOOP: case JCTree.WHILELOOP: case JCTree.FORLOOP: case JCTree.FOREACHLOOP: case JCTree.SWITCH:
return t;
default:
return tree;
}
}
/** Skip parens and return the enclosed expression
*/
public static JCExpression skipParens(JCExpression tree) {
! while (tree.getTag() == JCTree.PARENS) {
tree = ((JCParens) tree).expr;
}
return tree;
}
/** Skip parens and return the enclosed expression
*/
public static JCTree skipParens(JCTree tree) {
! if (tree.getTag() == JCTree.PARENS)
return skipParens((JCParens)tree);
else
return tree;
}
--- 545,576 ----
* otherwise return the labelled statement itself
*/
public static JCTree referencedStatement(JCLabeledStatement tree) {
JCTree t = tree;
do t = ((JCLabeledStatement) t).body;
! while (t.getTag() == JCTree.Tag.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.getTag() == JCTree.Tag.PARENS) {
tree = ((JCParens) tree).expr;
}
return tree;
}
/** Skip parens and return the enclosed expression
*/
public static JCTree skipParens(JCTree tree) {
! if (tree.getTag() == JCTree.Tag.PARENS)
return skipParens((JCParens)tree);
else
return tree;
}
*** 586,600 ****
/** 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 JCTree.IDENT:
return ((JCIdent) tree).name;
! case JCTree.SELECT:
return ((JCFieldAccess) tree).name;
! case JCTree.TYPEAPPLY:
return name(((JCTypeApply) tree).clazz);
default:
return null;
}
}
--- 586,600 ----
/** 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;
}
}
*** 603,642 ****
* otherwise return null.
*/
public static Name fullName(JCTree tree) {
tree = skipParens(tree);
switch (tree.getTag()) {
! case JCTree.IDENT:
return ((JCIdent) tree).name;
! case JCTree.SELECT:
Name sname = fullName(((JCFieldAccess) tree).selected);
return sname == null ? null : sname.append('.', name(tree));
default:
return null;
}
}
public static Symbol symbolFor(JCTree node) {
node = skipParens(node);
switch (node.getTag()) {
! case JCTree.CLASSDEF:
return ((JCClassDecl) node).sym;
! case JCTree.METHODDEF:
return ((JCMethodDecl) node).sym;
! case JCTree.VARDEF:
return ((JCVariableDecl) node).sym;
default:
return null;
}
}
public static boolean isDeclaration(JCTree node) {
node = skipParens(node);
switch (node.getTag()) {
! case JCTree.CLASSDEF:
! case JCTree.METHODDEF:
! case JCTree.VARDEF:
return true;
default:
return false;
}
}
--- 603,642 ----
* 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) {
node = skipParens(node);
switch (node.getTag()) {
! case CLASSDEF:
return ((JCClassDecl) node).sym;
! case METHODDEF:
return ((JCMethodDecl) node).sym;
! case VARDEF:
return ((JCVariableDecl) node).sym;
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;
}
}
*** 645,699 ****
* otherwise return null.
*/
public static Symbol symbol(JCTree tree) {
tree = skipParens(tree);
switch (tree.getTag()) {
! case JCTree.IDENT:
return ((JCIdent) tree).sym;
! case JCTree.SELECT:
return ((JCFieldAccess) tree).sym;
! case JCTree.TYPEAPPLY:
return symbol(((JCTypeApply) tree).clazz);
default:
return null;
}
}
/** Return true if this is a nonstatic selection. */
public static boolean nonstaticSelect(JCTree tree) {
tree = skipParens(tree);
! if (tree.getTag() != JCTree.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 JCTree.IDENT:
((JCIdent) tree).sym = sym; break;
! case JCTree.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 JCTree.VARDEF:
return ((JCVariableDecl) tree).mods.flags;
! case JCTree.METHODDEF:
return ((JCMethodDecl) tree).mods.flags;
! case JCTree.CLASSDEF:
return ((JCClassDecl) tree).mods.flags;
! case JCTree.BLOCK:
return ((JCBlock) tree).flags;
default:
return 0;
}
}
--- 645,699 ----
* 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);
default:
return null;
}
}
/** Return true if this is a nonstatic selection. */
public static boolean nonstaticSelect(JCTree tree) {
tree = skipParens(tree);
! if (tree.getTag() != JCTree.Tag.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;
}
}
*** 737,895 ****
precCount = 16;
/** Map operators to their precedence levels.
*/
! public static int opPrec(int op) {
switch(op) {
! case JCTree.POS:
! case JCTree.NEG:
! case JCTree.NOT:
! case JCTree.COMPL:
! case JCTree.PREINC:
! case JCTree.PREDEC: return prefixPrec;
! case JCTree.POSTINC:
! case JCTree.POSTDEC:
! case JCTree.NULLCHK: return postfixPrec;
! case JCTree.ASSIGN: return assignPrec;
! case JCTree.BITOR_ASG:
! case JCTree.BITXOR_ASG:
! case JCTree.BITAND_ASG:
! case JCTree.SL_ASG:
! case JCTree.SR_ASG:
! case JCTree.USR_ASG:
! case JCTree.PLUS_ASG:
! case JCTree.MINUS_ASG:
! case JCTree.MUL_ASG:
! case JCTree.DIV_ASG:
! case JCTree.MOD_ASG: return assignopPrec;
! case JCTree.OR: return orPrec;
! case JCTree.AND: return andPrec;
! case JCTree.EQ:
! case JCTree.NE: return eqPrec;
! case JCTree.LT:
! case JCTree.GT:
! case JCTree.LE:
! case JCTree.GE: return ordPrec;
! case JCTree.BITOR: return bitorPrec;
! case JCTree.BITXOR: return bitxorPrec;
! case JCTree.BITAND: return bitandPrec;
! case JCTree.SL:
! case JCTree.SR:
! case JCTree.USR: return shiftPrec;
! case JCTree.PLUS:
! case JCTree.MINUS: return addPrec;
! case JCTree.MUL:
! case JCTree.DIV:
! case JCTree.MOD: return mulPrec;
! case JCTree.TYPETEST: return ordPrec;
default: throw new AssertionError();
}
}
! static Tree.Kind tagToKind(int tag) {
switch (tag) {
// Postfix expressions
! case JCTree.POSTINC: // _ ++
return Tree.Kind.POSTFIX_INCREMENT;
! case JCTree.POSTDEC: // _ --
return Tree.Kind.POSTFIX_DECREMENT;
// Unary operators
! case JCTree.PREINC: // ++ _
return Tree.Kind.PREFIX_INCREMENT;
! case JCTree.PREDEC: // -- _
return Tree.Kind.PREFIX_DECREMENT;
! case JCTree.POS: // +
return Tree.Kind.UNARY_PLUS;
! case JCTree.NEG: // -
return Tree.Kind.UNARY_MINUS;
! case JCTree.COMPL: // ~
return Tree.Kind.BITWISE_COMPLEMENT;
! case JCTree.NOT: // !
return Tree.Kind.LOGICAL_COMPLEMENT;
// Binary operators
// Multiplicative operators
! case JCTree.MUL: // *
return Tree.Kind.MULTIPLY;
! case JCTree.DIV: // /
return Tree.Kind.DIVIDE;
! case JCTree.MOD: // %
return Tree.Kind.REMAINDER;
// Additive operators
! case JCTree.PLUS: // +
return Tree.Kind.PLUS;
! case JCTree.MINUS: // -
return Tree.Kind.MINUS;
// Shift operators
! case JCTree.SL: // <<
return Tree.Kind.LEFT_SHIFT;
! case JCTree.SR: // >>
return Tree.Kind.RIGHT_SHIFT;
! case JCTree.USR: // >>>
return Tree.Kind.UNSIGNED_RIGHT_SHIFT;
// Relational operators
! case JCTree.LT: // <
return Tree.Kind.LESS_THAN;
! case JCTree.GT: // >
return Tree.Kind.GREATER_THAN;
! case JCTree.LE: // <=
return Tree.Kind.LESS_THAN_EQUAL;
! case JCTree.GE: // >=
return Tree.Kind.GREATER_THAN_EQUAL;
// Equality operators
! case JCTree.EQ: // ==
return Tree.Kind.EQUAL_TO;
! case JCTree.NE: // !=
return Tree.Kind.NOT_EQUAL_TO;
// Bitwise and logical operators
! case JCTree.BITAND: // &
return Tree.Kind.AND;
! case JCTree.BITXOR: // ^
return Tree.Kind.XOR;
! case JCTree.BITOR: // |
return Tree.Kind.OR;
// Conditional operators
! case JCTree.AND: // &&
return Tree.Kind.CONDITIONAL_AND;
! case JCTree.OR: // ||
return Tree.Kind.CONDITIONAL_OR;
// Assignment operators
! case JCTree.MUL_ASG: // *=
return Tree.Kind.MULTIPLY_ASSIGNMENT;
! case JCTree.DIV_ASG: // /=
return Tree.Kind.DIVIDE_ASSIGNMENT;
! case JCTree.MOD_ASG: // %=
return Tree.Kind.REMAINDER_ASSIGNMENT;
! case JCTree.PLUS_ASG: // +=
return Tree.Kind.PLUS_ASSIGNMENT;
! case JCTree.MINUS_ASG: // -=
return Tree.Kind.MINUS_ASSIGNMENT;
! case JCTree.SL_ASG: // <<=
return Tree.Kind.LEFT_SHIFT_ASSIGNMENT;
! case JCTree.SR_ASG: // >>=
return Tree.Kind.RIGHT_SHIFT_ASSIGNMENT;
! case JCTree.USR_ASG: // >>>=
return Tree.Kind.UNSIGNED_RIGHT_SHIFT_ASSIGNMENT;
! case JCTree.BITAND_ASG: // &=
return Tree.Kind.AND_ASSIGNMENT;
! case JCTree.BITXOR_ASG: // ^=
return Tree.Kind.XOR_ASSIGNMENT;
! case JCTree.BITOR_ASG: // |=
return Tree.Kind.OR_ASSIGNMENT;
// Null check (implementation detail), for example, __.getClass()
! case JCTree.NULLCHK:
return Tree.Kind.OTHER;
default:
return null;
}
--- 737,895 ----
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;
default:
return null;
}
*** 899,926 ****
* Returns the underlying type of the tree if it is annotated type,
* or the tree itself otherwise
*/
public static JCExpression typeIn(JCExpression tree) {
switch (tree.getTag()) {
! case JCTree.IDENT: /* simple names */
! case JCTree.TYPEIDENT: /* primitive name */
! case JCTree.SELECT: /* qualified name */
! case JCTree.TYPEARRAY: /* array types */
! case JCTree.WILDCARD: /* wild cards */
! case JCTree.TYPEPARAMETER: /* type parameters */
! case JCTree.TYPEAPPLY: /* parameterized types */
return tree;
default:
throw new AssertionError("Unexpected type tree: " + tree);
}
}
public static JCTree innermostType(JCTree type) {
switch (type.getTag()) {
! case JCTree.TYPEARRAY:
return innermostType(((JCArrayTypeTree)type).elemtype);
! case JCTree.WILDCARD:
return innermostType(((JCWildcard)type).inner);
default:
return type;
}
}
--- 899,926 ----
* Returns the underlying type of the tree if it is annotated type,
* or the tree itself otherwise
*/
public static JCExpression typeIn(JCExpression tree) {
switch (tree.getTag()) {
! 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 */
return tree;
default:
throw new AssertionError("Unexpected type tree: " + tree);
}
}
public static JCTree innermostType(JCTree type) {
switch (type.getTag()) {
! case TYPEARRAY:
return innermostType(((JCArrayTypeTree)type).elemtype);
! case WILDCARD:
return innermostType(((JCWildcard)type).inner);
default:
return type;
}
}