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

comparison: src/share/classes/com/sun/tools/javac/tree/TreeInfo.java

src/share/classes/com/sun/tools/javac/tree/TreeInfo.java

changeset 1127
ca49d50318dc
parent 969
8cc5b440fdde
child 1138
7375d4979bd3
equal deleted inserted replaced
1126:11c184155128 1127:ca49d50318dc
33 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition; 33 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
34 import com.sun.tools.javac.code.*; 34 import com.sun.tools.javac.code.*;
35 import com.sun.tools.javac.tree.JCTree.*; 35 import com.sun.tools.javac.tree.JCTree.*;
36 36
37 import static com.sun.tools.javac.code.Flags.*; 37 import static com.sun.tools.javac.code.Flags.*;
38 import static com.sun.tools.javac.tree.JCTree.Tag.*;
39 import static com.sun.tools.javac.tree.JCTree.Tag.BLOCK;
40 import static com.sun.tools.javac.tree.JCTree.Tag.SYNCHRONIZED;
38 41
39 /** Utility class containing inspector methods for trees. 42 /** Utility class containing inspector methods for trees.
40 * 43 *
41 * <p><b>This is NOT part of any supported API. 44 * <p><b>This is NOT part of any supported API.
42 * If you write code that depends on this, you do so at your own risk. 45 * If you write code that depends on this, you do so at your own risk.
54 return instance; 57 return instance;
55 } 58 }
56 59
57 /** The names of all operators. 60 /** The names of all operators.
58 */ 61 */
59 private Name[] opname = new Name[JCTree.MOD - JCTree.POS + 1]; 62 private Name[] opname = new Name[Tag.getNumberOfOperators()];
63
64 private void setOpname(Tag tag, String name, Names names) {
65 setOpname(tag, names.fromString(name));
66 }
67 private void setOpname(Tag tag, Name name) {
68 opname[tag.operatorIndex()] = name;
69 }
60 70
61 private TreeInfo(Context context) { 71 private TreeInfo(Context context) {
62 context.put(treeInfoKey, this); 72 context.put(treeInfoKey, this);
63 73
64 Names names = Names.instance(context); 74 Names names = Names.instance(context);
65 opname[JCTree.POS - JCTree.POS] = names.fromString("+"); 75 setOpname(POS, "+", names);
66 opname[JCTree.NEG - JCTree.POS] = names.hyphen; 76 setOpname(NEG, names.hyphen);
67 opname[JCTree.NOT - JCTree.POS] = names.fromString("!"); 77 setOpname(NOT, "!", names);
68 opname[JCTree.COMPL - JCTree.POS] = names.fromString("~"); 78 setOpname(COMPL, "~", names);
69 opname[JCTree.PREINC - JCTree.POS] = names.fromString("++"); 79 setOpname(PREINC, "++", names);
70 opname[JCTree.PREDEC - JCTree.POS] = names.fromString("--"); 80 setOpname(PREDEC, "--", names);
71 opname[JCTree.POSTINC - JCTree.POS] = names.fromString("++"); 81 setOpname(POSTINC, "++", names);
72 opname[JCTree.POSTDEC - JCTree.POS] = names.fromString("--"); 82 setOpname(POSTDEC, "--", names);
73 opname[JCTree.NULLCHK - JCTree.POS] = names.fromString("<*nullchk*>"); 83 setOpname(NULLCHK, "<*nullchk*>", names);
74 opname[JCTree.OR - JCTree.POS] = names.fromString("||"); 84 setOpname(OR, "||", names);
75 opname[JCTree.AND - JCTree.POS] = names.fromString("&&"); 85 setOpname(AND, "&&", names);
76 opname[JCTree.EQ - JCTree.POS] = names.fromString("=="); 86 setOpname(EQ, "==", names);
77 opname[JCTree.NE - JCTree.POS] = names.fromString("!="); 87 setOpname(NE, "!=", names);
78 opname[JCTree.LT - JCTree.POS] = names.fromString("<"); 88 setOpname(LT, "<", names);
79 opname[JCTree.GT - JCTree.POS] = names.fromString(">"); 89 setOpname(GT, ">", names);
80 opname[JCTree.LE - JCTree.POS] = names.fromString("<="); 90 setOpname(LE, "<=", names);
81 opname[JCTree.GE - JCTree.POS] = names.fromString(">="); 91 setOpname(GE, ">=", names);
82 opname[JCTree.BITOR - JCTree.POS] = names.fromString("|"); 92 setOpname(BITOR, "|", names);
83 opname[JCTree.BITXOR - JCTree.POS] = names.fromString("^"); 93 setOpname(BITXOR, "^", names);
84 opname[JCTree.BITAND - JCTree.POS] = names.fromString("&"); 94 setOpname(BITAND, "&", names);
85 opname[JCTree.SL - JCTree.POS] = names.fromString("<<"); 95 setOpname(SL, "<<", names);
86 opname[JCTree.SR - JCTree.POS] = names.fromString(">>"); 96 setOpname(SR, ">>", names);
87 opname[JCTree.USR - JCTree.POS] = names.fromString(">>>"); 97 setOpname(USR, ">>>", names);
88 opname[JCTree.PLUS - JCTree.POS] = names.fromString("+"); 98 setOpname(PLUS, "+", names);
89 opname[JCTree.MINUS - JCTree.POS] = names.hyphen; 99 setOpname(MINUS, names.hyphen);
90 opname[JCTree.MUL - JCTree.POS] = names.asterisk; 100 setOpname(MUL, names.asterisk);
91 opname[JCTree.DIV - JCTree.POS] = names.slash; 101 setOpname(DIV, names.slash);
92 opname[JCTree.MOD - JCTree.POS] = names.fromString("%"); 102 setOpname(MOD, "%", names);
93 } 103 }
94 104
95 105
96 /** Return name of operator with given tree tag. 106 /** Return name of operator with given tree tag.
97 */ 107 */
98 public Name operatorName(int tag) { 108 public Name operatorName(JCTree.Tag tag) {
99 return opname[tag - JCTree.POS]; 109 return opname[tag.operatorIndex()];
100 } 110 }
101 111
102 /** Is tree a constructor declaration? 112 /** Is tree a constructor declaration?
103 */ 113 */
104 public static boolean isConstructor(JCTree tree) { 114 public static boolean isConstructor(JCTree tree) {
105 if (tree.getTag() == JCTree.METHODDEF) { 115 if (tree.hasTag(METHODDEF)) {
106 Name name = ((JCMethodDecl) tree).name; 116 Name name = ((JCMethodDecl) tree).name;
107 return name == name.table.names.init; 117 return name == name.table.names.init;
108 } else { 118 } else {
109 return false; 119 return false;
110 } 120 }
117 if (isConstructor(l.head)) return true; 127 if (isConstructor(l.head)) return true;
118 return false; 128 return false;
119 } 129 }
120 130
121 public static boolean isMultiCatch(JCCatch catchClause) { 131 public static boolean isMultiCatch(JCCatch catchClause) {
122 return catchClause.param.vartype.getTag() == JCTree.TYPEUNION; 132 return catchClause.param.vartype.hasTag(TYPEUNION);
123 } 133 }
124 134
125 /** Is statement an initializer for a synthetic field? 135 /** Is statement an initializer for a synthetic field?
126 */ 136 */
127 public static boolean isSyntheticInit(JCTree stat) { 137 public static boolean isSyntheticInit(JCTree stat) {
128 if (stat.getTag() == JCTree.EXEC) { 138 if (stat.hasTag(EXEC)) {
129 JCExpressionStatement exec = (JCExpressionStatement)stat; 139 JCExpressionStatement exec = (JCExpressionStatement)stat;
130 if (exec.expr.getTag() == JCTree.ASSIGN) { 140 if (exec.expr.hasTag(ASSIGN)) {
131 JCAssign assign = (JCAssign)exec.expr; 141 JCAssign assign = (JCAssign)exec.expr;
132 if (assign.lhs.getTag() == JCTree.SELECT) { 142 if (assign.lhs.hasTag(SELECT)) {
133 JCFieldAccess select = (JCFieldAccess)assign.lhs; 143 JCFieldAccess select = (JCFieldAccess)assign.lhs;
134 if (select.sym != null && 144 if (select.sym != null &&
135 (select.sym.flags() & SYNTHETIC) != 0) { 145 (select.sym.flags() & SYNTHETIC) != 0) {
136 Name selected = name(select.selected); 146 Name selected = name(select.selected);
137 if (selected != null && selected == selected.table.names._this) 147 if (selected != null && selected == selected.table.names._this)
144 } 154 }
145 155
146 /** If the expression is a method call, return the method name, null 156 /** If the expression is a method call, return the method name, null
147 * otherwise. */ 157 * otherwise. */
148 public static Name calledMethodName(JCTree tree) { 158 public static Name calledMethodName(JCTree tree) {
149 if (tree.getTag() == JCTree.EXEC) { 159 if (tree.hasTag(EXEC)) {
150 JCExpressionStatement exec = (JCExpressionStatement)tree; 160 JCExpressionStatement exec = (JCExpressionStatement)tree;
151 if (exec.expr.getTag() == JCTree.APPLY) { 161 if (exec.expr.hasTag(APPLY)) {
152 Name mname = TreeInfo.name(((JCMethodInvocation) exec.expr).meth); 162 Name mname = TreeInfo.name(((JCMethodInvocation) exec.expr).meth);
153 return mname; 163 return mname;
154 } 164 }
155 } 165 }
156 return null; 166 return null;
190 return meth == null || meth != meth.table.names._this; 200 return meth == null || meth != meth.table.names._this;
191 } 201 }
192 202
193 /** Return the first call in a constructor definition. */ 203 /** Return the first call in a constructor definition. */
194 public static JCMethodInvocation firstConstructorCall(JCTree tree) { 204 public static JCMethodInvocation firstConstructorCall(JCTree tree) {
195 if (tree.getTag() != JCTree.METHODDEF) return null; 205 if (!tree.hasTag(METHODDEF)) return null;
196 JCMethodDecl md = (JCMethodDecl) tree; 206 JCMethodDecl md = (JCMethodDecl) tree;
197 Names names = md.name.table.names; 207 Names names = md.name.table.names;
198 if (md.name != names.init) return null; 208 if (md.name != names.init) return null;
199 if (md.body == null) return null; 209 if (md.body == null) return null;
200 List<JCStatement> stats = md.body.stats; 210 List<JCStatement> stats = md.body.stats;
201 // Synthetic initializations can appear before the super call. 211 // Synthetic initializations can appear before the super call.
202 while (stats.nonEmpty() && isSyntheticInit(stats.head)) 212 while (stats.nonEmpty() && isSyntheticInit(stats.head))
203 stats = stats.tail; 213 stats = stats.tail;
204 if (stats.isEmpty()) return null; 214 if (stats.isEmpty()) return null;
205 if (stats.head.getTag() != JCTree.EXEC) return null; 215 if (!stats.head.hasTag(EXEC)) return null;
206 JCExpressionStatement exec = (JCExpressionStatement) stats.head; 216 JCExpressionStatement exec = (JCExpressionStatement) stats.head;
207 if (exec.expr.getTag() != JCTree.APPLY) return null; 217 if (!exec.expr.hasTag(APPLY)) return null;
208 return (JCMethodInvocation)exec.expr; 218 return (JCMethodInvocation)exec.expr;
209 } 219 }
210 220
211 /** Return true if a tree represents a diamond new expr. */ 221 /** Return true if a tree represents a diamond new expr. */
212 public static boolean isDiamond(JCTree tree) { 222 public static boolean isDiamond(JCTree tree) {
213 switch(tree.getTag()) { 223 switch(tree.getTag()) {
214 case JCTree.TYPEAPPLY: return ((JCTypeApply)tree).getTypeArguments().isEmpty(); 224 case TYPEAPPLY: return ((JCTypeApply)tree).getTypeArguments().isEmpty();
215 case JCTree.NEWCLASS: return isDiamond(((JCNewClass)tree).clazz); 225 case NEWCLASS: return isDiamond(((JCNewClass)tree).clazz);
216 default: return false; 226 default: return false;
217 } 227 }
218 } 228 }
219 229
220 /** Return true if a tree represents the null literal. */ 230 /** Return true if a tree represents the null literal. */
221 public static boolean isNull(JCTree tree) { 231 public static boolean isNull(JCTree tree) {
222 if (tree.getTag() != JCTree.LITERAL) 232 if (!tree.hasTag(LITERAL))
223 return false; 233 return false;
224 JCLiteral lit = (JCLiteral) tree; 234 JCLiteral lit = (JCLiteral) tree;
225 return (lit.typetag == TypeTags.BOT); 235 return (lit.typetag == TypeTags.BOT);
226 } 236 }
227 237
228 /** The position of the first statement in a block, or the position of 238 /** The position of the first statement in a block, or the position of
229 * the block itself if it is empty. 239 * the block itself if it is empty.
230 */ 240 */
231 public static int firstStatPos(JCTree tree) { 241 public static int firstStatPos(JCTree tree) {
232 if (tree.getTag() == JCTree.BLOCK && ((JCBlock) tree).stats.nonEmpty()) 242 if (tree.hasTag(BLOCK) && ((JCBlock) tree).stats.nonEmpty())
233 return ((JCBlock) tree).stats.head.pos; 243 return ((JCBlock) tree).stats.head.pos;
234 else 244 else
235 return tree.pos; 245 return tree.pos;
236 } 246 }
237 247
238 /** The end position of given tree, if it is a block with 248 /** The end position of given tree, if it is a block with
239 * defined endpos. 249 * defined endpos.
240 */ 250 */
241 public static int endPos(JCTree tree) { 251 public static int endPos(JCTree tree) {
242 if (tree.getTag() == JCTree.BLOCK && ((JCBlock) tree).endpos != Position.NOPOS) 252 if (tree.hasTag(BLOCK) && ((JCBlock) tree).endpos != Position.NOPOS)
243 return ((JCBlock) tree).endpos; 253 return ((JCBlock) tree).endpos;
244 else if (tree.getTag() == JCTree.SYNCHRONIZED) 254 else if (tree.hasTag(SYNCHRONIZED))
245 return endPos(((JCSynchronized) tree).body); 255 return endPos(((JCSynchronized) tree).body);
246 else if (tree.getTag() == JCTree.TRY) { 256 else if (tree.hasTag(TRY)) {
247 JCTry t = (JCTry) tree; 257 JCTry t = (JCTry) tree;
248 return endPos((t.finalizer != null) 258 return endPos((t.finalizer != null)
249 ? t.finalizer 259 ? t.finalizer
250 : t.catchers.last().body); 260 : t.catchers.last().body);
251 } else 261 } else
261 public static int getStartPos(JCTree tree) { 271 public static int getStartPos(JCTree tree) {
262 if (tree == null) 272 if (tree == null)
263 return Position.NOPOS; 273 return Position.NOPOS;
264 274
265 switch(tree.getTag()) { 275 switch(tree.getTag()) {
266 case(JCTree.APPLY): 276 case APPLY:
267 return getStartPos(((JCMethodInvocation) tree).meth); 277 return getStartPos(((JCMethodInvocation) tree).meth);
268 case(JCTree.ASSIGN): 278 case ASSIGN:
269 return getStartPos(((JCAssign) tree).lhs); 279 return getStartPos(((JCAssign) tree).lhs);
270 case(JCTree.BITOR_ASG): case(JCTree.BITXOR_ASG): case(JCTree.BITAND_ASG): 280 case BITOR_ASG: case BITXOR_ASG: case BITAND_ASG:
271 case(JCTree.SL_ASG): case(JCTree.SR_ASG): case(JCTree.USR_ASG): 281 case SL_ASG: case SR_ASG: case USR_ASG:
272 case(JCTree.PLUS_ASG): case(JCTree.MINUS_ASG): case(JCTree.MUL_ASG): 282 case PLUS_ASG: case MINUS_ASG: case MUL_ASG:
273 case(JCTree.DIV_ASG): case(JCTree.MOD_ASG): 283 case DIV_ASG: case MOD_ASG:
274 return getStartPos(((JCAssignOp) tree).lhs); 284 return getStartPos(((JCAssignOp) tree).lhs);
275 case(JCTree.OR): case(JCTree.AND): case(JCTree.BITOR): 285 case OR: case AND: case BITOR:
276 case(JCTree.BITXOR): case(JCTree.BITAND): case(JCTree.EQ): 286 case BITXOR: case BITAND: case EQ:
277 case(JCTree.NE): case(JCTree.LT): case(JCTree.GT): 287 case NE: case LT: case GT:
278 case(JCTree.LE): case(JCTree.GE): case(JCTree.SL): 288 case LE: case GE: case SL:
279 case(JCTree.SR): case(JCTree.USR): case(JCTree.PLUS): 289 case SR: case USR: case PLUS:
280 case(JCTree.MINUS): case(JCTree.MUL): case(JCTree.DIV): 290 case MINUS: case MUL: case DIV:
281 case(JCTree.MOD): 291 case MOD:
282 return getStartPos(((JCBinary) tree).lhs); 292 return getStartPos(((JCBinary) tree).lhs);
283 case(JCTree.CLASSDEF): { 293 case CLASSDEF: {
284 JCClassDecl node = (JCClassDecl)tree; 294 JCClassDecl node = (JCClassDecl)tree;
285 if (node.mods.pos != Position.NOPOS) 295 if (node.mods.pos != Position.NOPOS)
286 return node.mods.pos; 296 return node.mods.pos;
287 break; 297 break;
288 } 298 }
289 case(JCTree.CONDEXPR): 299 case CONDEXPR:
290 return getStartPos(((JCConditional) tree).cond); 300 return getStartPos(((JCConditional) tree).cond);
291 case(JCTree.EXEC): 301 case EXEC:
292 return getStartPos(((JCExpressionStatement) tree).expr); 302 return getStartPos(((JCExpressionStatement) tree).expr);
293 case(JCTree.INDEXED): 303 case INDEXED:
294 return getStartPos(((JCArrayAccess) tree).indexed); 304 return getStartPos(((JCArrayAccess) tree).indexed);
295 case(JCTree.METHODDEF): { 305 case METHODDEF: {
296 JCMethodDecl node = (JCMethodDecl)tree; 306 JCMethodDecl node = (JCMethodDecl)tree;
297 if (node.mods.pos != Position.NOPOS) 307 if (node.mods.pos != Position.NOPOS)
298 return node.mods.pos; 308 return node.mods.pos;
299 if (node.typarams.nonEmpty()) // List.nil() used for no typarams 309 if (node.typarams.nonEmpty()) // List.nil() used for no typarams
300 return getStartPos(node.typarams.head); 310 return getStartPos(node.typarams.head);
301 return node.restype == null ? node.pos : getStartPos(node.restype); 311 return node.restype == null ? node.pos : getStartPos(node.restype);
302 } 312 }
303 case(JCTree.SELECT): 313 case SELECT:
304 return getStartPos(((JCFieldAccess) tree).selected); 314 return getStartPos(((JCFieldAccess) tree).selected);
305 case(JCTree.TYPEAPPLY): 315 case TYPEAPPLY:
306 return getStartPos(((JCTypeApply) tree).clazz); 316 return getStartPos(((JCTypeApply) tree).clazz);
307 case(JCTree.TYPEARRAY): 317 case TYPEARRAY:
308 return getStartPos(((JCArrayTypeTree) tree).elemtype); 318 return getStartPos(((JCArrayTypeTree) tree).elemtype);
309 case(JCTree.TYPETEST): 319 case TYPETEST:
310 return getStartPos(((JCInstanceOf) tree).expr); 320 return getStartPos(((JCInstanceOf) tree).expr);
311 case(JCTree.POSTINC): 321 case POSTINC:
312 case(JCTree.POSTDEC): 322 case POSTDEC:
313 return getStartPos(((JCUnary) tree).arg); 323 return getStartPos(((JCUnary) tree).arg);
314 case(JCTree.NEWCLASS): { 324 case NEWCLASS: {
315 JCNewClass node = (JCNewClass)tree; 325 JCNewClass node = (JCNewClass)tree;
316 if (node.encl != null) 326 if (node.encl != null)
317 return getStartPos(node.encl); 327 return getStartPos(node.encl);
318 break; 328 break;
319 } 329 }
320 case(JCTree.VARDEF): { 330 case VARDEF: {
321 JCVariableDecl node = (JCVariableDecl)tree; 331 JCVariableDecl node = (JCVariableDecl)tree;
322 if (node.mods.pos != Position.NOPOS) { 332 if (node.mods.pos != Position.NOPOS) {
323 return node.mods.pos; 333 return node.mods.pos;
324 } else { 334 } else {
325 return getStartPos(node.vartype); 335 return getStartPos(node.vartype);
326 } 336 }
327 } 337 }
328 case(JCTree.ERRONEOUS): { 338 case ERRONEOUS: {
329 JCErroneous node = (JCErroneous)tree; 339 JCErroneous node = (JCErroneous)tree;
330 if (node.errs != null && node.errs.nonEmpty()) 340 if (node.errs != null && node.errs.nonEmpty())
331 return getStartPos(node.errs.head); 341 return getStartPos(node.errs.head);
332 } 342 }
333 } 343 }
334 return tree.pos; 344 return tree.pos;
335 } 345 }
336 346
337 /** The end position of given tree, given a table of end positions generated by the parser 347 /** The end position of given tree, given a table of end positions generated by the parser
348 Integer mapPos = endPositions.get(tree); 358 Integer mapPos = endPositions.get(tree);
349 if (mapPos != null) 359 if (mapPos != null)
350 return mapPos; 360 return mapPos;
351 361
352 switch(tree.getTag()) { 362 switch(tree.getTag()) {
353 case(JCTree.BITOR_ASG): case(JCTree.BITXOR_ASG): case(JCTree.BITAND_ASG): 363 case BITOR_ASG: case BITXOR_ASG: case BITAND_ASG:
354 case(JCTree.SL_ASG): case(JCTree.SR_ASG): case(JCTree.USR_ASG): 364 case SL_ASG: case SR_ASG: case USR_ASG:
355 case(JCTree.PLUS_ASG): case(JCTree.MINUS_ASG): case(JCTree.MUL_ASG): 365 case PLUS_ASG: case MINUS_ASG: case MUL_ASG:
356 case(JCTree.DIV_ASG): case(JCTree.MOD_ASG): 366 case DIV_ASG: case MOD_ASG:
357 return getEndPos(((JCAssignOp) tree).rhs, endPositions); 367 return getEndPos(((JCAssignOp) tree).rhs, endPositions);
358 case(JCTree.OR): case(JCTree.AND): case(JCTree.BITOR): 368 case OR: case AND: case BITOR:
359 case(JCTree.BITXOR): case(JCTree.BITAND): case(JCTree.EQ): 369 case BITXOR: case BITAND: case EQ:
360 case(JCTree.NE): case(JCTree.LT): case(JCTree.GT): 370 case NE: case LT: case GT:
361 case(JCTree.LE): case(JCTree.GE): case(JCTree.SL): 371 case LE: case GE: case SL:
362 case(JCTree.SR): case(JCTree.USR): case(JCTree.PLUS): 372 case SR: case USR: case PLUS:
363 case(JCTree.MINUS): case(JCTree.MUL): case(JCTree.DIV): 373 case MINUS: case MUL: case DIV:
364 case(JCTree.MOD): 374 case MOD:
365 return getEndPos(((JCBinary) tree).rhs, endPositions); 375 return getEndPos(((JCBinary) tree).rhs, endPositions);
366 case(JCTree.CASE): 376 case CASE:
367 return getEndPos(((JCCase) tree).stats.last(), endPositions); 377 return getEndPos(((JCCase) tree).stats.last(), endPositions);
368 case(JCTree.CATCH): 378 case CATCH:
369 return getEndPos(((JCCatch) tree).body, endPositions); 379 return getEndPos(((JCCatch) tree).body, endPositions);
370 case(JCTree.CONDEXPR): 380 case CONDEXPR:
371 return getEndPos(((JCConditional) tree).falsepart, endPositions); 381 return getEndPos(((JCConditional) tree).falsepart, endPositions);
372 case(JCTree.FORLOOP): 382 case FORLOOP:
373 return getEndPos(((JCForLoop) tree).body, endPositions); 383 return getEndPos(((JCForLoop) tree).body, endPositions);
374 case(JCTree.FOREACHLOOP): 384 case FOREACHLOOP:
375 return getEndPos(((JCEnhancedForLoop) tree).body, endPositions); 385 return getEndPos(((JCEnhancedForLoop) tree).body, endPositions);
376 case(JCTree.IF): { 386 case IF: {
377 JCIf node = (JCIf)tree; 387 JCIf node = (JCIf)tree;
378 if (node.elsepart == null) { 388 if (node.elsepart == null) {
379 return getEndPos(node.thenpart, endPositions); 389 return getEndPos(node.thenpart, endPositions);
380 } else { 390 } else {
381 return getEndPos(node.elsepart, endPositions); 391 return getEndPos(node.elsepart, endPositions);
382 } 392 }
383 } 393 }
384 case(JCTree.LABELLED): 394 case LABELLED:
385 return getEndPos(((JCLabeledStatement) tree).body, endPositions); 395 return getEndPos(((JCLabeledStatement) tree).body, endPositions);
386 case(JCTree.MODIFIERS): 396 case MODIFIERS:
387 return getEndPos(((JCModifiers) tree).annotations.last(), endPositions); 397 return getEndPos(((JCModifiers) tree).annotations.last(), endPositions);
388 case(JCTree.SYNCHRONIZED): 398 case SYNCHRONIZED:
389 return getEndPos(((JCSynchronized) tree).body, endPositions); 399 return getEndPos(((JCSynchronized) tree).body, endPositions);
390 case(JCTree.TOPLEVEL): 400 case TOPLEVEL:
391 return getEndPos(((JCCompilationUnit) tree).defs.last(), endPositions); 401 return getEndPos(((JCCompilationUnit) tree).defs.last(), endPositions);
392 case(JCTree.TRY): { 402 case TRY: {
393 JCTry node = (JCTry)tree; 403 JCTry node = (JCTry)tree;
394 if (node.finalizer != null) { 404 if (node.finalizer != null) {
395 return getEndPos(node.finalizer, endPositions); 405 return getEndPos(node.finalizer, endPositions);
396 } else if (!node.catchers.isEmpty()) { 406 } else if (!node.catchers.isEmpty()) {
397 return getEndPos(node.catchers.last(), endPositions); 407 return getEndPos(node.catchers.last(), endPositions);
398 } else { 408 } else {
399 return getEndPos(node.body, endPositions); 409 return getEndPos(node.body, endPositions);
400 } 410 }
401 } 411 }
402 case(JCTree.WILDCARD): 412 case WILDCARD:
403 return getEndPos(((JCWildcard) tree).inner, endPositions); 413 return getEndPos(((JCWildcard) tree).inner, endPositions);
404 case(JCTree.TYPECAST): 414 case TYPECAST:
405 return getEndPos(((JCTypeCast) tree).expr, endPositions); 415 return getEndPos(((JCTypeCast) tree).expr, endPositions);
406 case(JCTree.TYPETEST): 416 case TYPETEST:
407 return getEndPos(((JCInstanceOf) tree).clazz, endPositions); 417 return getEndPos(((JCInstanceOf) tree).clazz, endPositions);
408 case(JCTree.POS): 418 case POS:
409 case(JCTree.NEG): 419 case NEG:
410 case(JCTree.NOT): 420 case NOT:
411 case(JCTree.COMPL): 421 case COMPL:
412 case(JCTree.PREINC): 422 case PREINC:
413 case(JCTree.PREDEC): 423 case PREDEC:
414 return getEndPos(((JCUnary) tree).arg, endPositions); 424 return getEndPos(((JCUnary) tree).arg, endPositions);
415 case(JCTree.WHILELOOP): 425 case WHILELOOP:
416 return getEndPos(((JCWhileLoop) tree).body, endPositions); 426 return getEndPos(((JCWhileLoop) tree).body, endPositions);
417 case(JCTree.ERRONEOUS): { 427 case ERRONEOUS: {
418 JCErroneous node = (JCErroneous)tree; 428 JCErroneous node = (JCErroneous)tree;
419 if (node.errs != null && node.errs.nonEmpty()) 429 if (node.errs != null && node.errs.nonEmpty())
420 return getEndPos(node.errs.last(), endPositions); 430 return getEndPos(node.errs.last(), endPositions);
421 } 431 }
422 } 432 }
423 return Position.NOPOS; 433 return Position.NOPOS;
424 } 434 }
425 435
426 436
441 } 451 }
442 452
443 /** The position of the finalizer of given try/synchronized statement. 453 /** The position of the finalizer of given try/synchronized statement.
444 */ 454 */
445 public static int finalizerPos(JCTree tree) { 455 public static int finalizerPos(JCTree tree) {
446 if (tree.getTag() == JCTree.TRY) { 456 if (tree.hasTag(TRY)) {
447 JCTry t = (JCTry) tree; 457 JCTry t = (JCTry) tree;
448 Assert.checkNonNull(t.finalizer); 458 Assert.checkNonNull(t.finalizer);
449 return firstStatPos(t.finalizer); 459 return firstStatPos(t.finalizer);
450 } else if (tree.getTag() == JCTree.SYNCHRONIZED) { 460 } else if (tree.hasTag(SYNCHRONIZED)) {
451 return endPos(((JCSynchronized) tree).body); 461 return endPos(((JCSynchronized) tree).body);
452 } else { 462 } else {
453 throw new AssertionError(); 463 throw new AssertionError();
454 } 464 }
455 } 465 }
545 * otherwise return the labelled statement itself 555 * otherwise return the labelled statement itself
546 */ 556 */
547 public static JCTree referencedStatement(JCLabeledStatement tree) { 557 public static JCTree referencedStatement(JCLabeledStatement tree) {
548 JCTree t = tree; 558 JCTree t = tree;
549 do t = ((JCLabeledStatement) t).body; 559 do t = ((JCLabeledStatement) t).body;
550 while (t.getTag() == JCTree.LABELLED); 560 while (t.hasTag(LABELLED));
551 switch (t.getTag()) { 561 switch (t.getTag()) {
552 case JCTree.DOLOOP: case JCTree.WHILELOOP: case JCTree.FORLOOP: case JCTree.FOREACHLOOP: case JCTree.SWITCH: 562 case DOLOOP: case WHILELOOP: case FORLOOP: case FOREACHLOOP: case SWITCH:
553 return t; 563 return t;
554 default: 564 default:
555 return tree; 565 return tree;
556 } 566 }
557 } 567 }
558 568
559 /** Skip parens and return the enclosed expression 569 /** Skip parens and return the enclosed expression
560 */ 570 */
561 public static JCExpression skipParens(JCExpression tree) { 571 public static JCExpression skipParens(JCExpression tree) {
562 while (tree.getTag() == JCTree.PARENS) { 572 while (tree.hasTag(PARENS)) {
563 tree = ((JCParens) tree).expr; 573 tree = ((JCParens) tree).expr;
564 } 574 }
565 return tree; 575 return tree;
566 } 576 }
567 577
568 /** Skip parens and return the enclosed expression 578 /** Skip parens and return the enclosed expression
569 */ 579 */
570 public static JCTree skipParens(JCTree tree) { 580 public static JCTree skipParens(JCTree tree) {
571 if (tree.getTag() == JCTree.PARENS) 581 if (tree.hasTag(PARENS))
572 return skipParens((JCParens)tree); 582 return skipParens((JCParens)tree);
573 else 583 else
574 return tree; 584 return tree;
575 } 585 }
576 586
586 /** If this tree is an identifier or a field or a parameterized type, 596 /** If this tree is an identifier or a field or a parameterized type,
587 * return its name, otherwise return null. 597 * return its name, otherwise return null.
588 */ 598 */
589 public static Name name(JCTree tree) { 599 public static Name name(JCTree tree) {
590 switch (tree.getTag()) { 600 switch (tree.getTag()) {
591 case JCTree.IDENT: 601 case IDENT:
592 return ((JCIdent) tree).name; 602 return ((JCIdent) tree).name;
593 case JCTree.SELECT: 603 case SELECT:
594 return ((JCFieldAccess) tree).name; 604 return ((JCFieldAccess) tree).name;
595 case JCTree.TYPEAPPLY: 605 case TYPEAPPLY:
596 return name(((JCTypeApply) tree).clazz); 606 return name(((JCTypeApply) tree).clazz);
597 default: 607 default:
598 return null; 608 return null;
599 } 609 }
600 } 610 }
603 * otherwise return null. 613 * otherwise return null.
604 */ 614 */
605 public static Name fullName(JCTree tree) { 615 public static Name fullName(JCTree tree) {
606 tree = skipParens(tree); 616 tree = skipParens(tree);
607 switch (tree.getTag()) { 617 switch (tree.getTag()) {
608 case JCTree.IDENT: 618 case IDENT:
609 return ((JCIdent) tree).name; 619 return ((JCIdent) tree).name;
610 case JCTree.SELECT: 620 case SELECT:
611 Name sname = fullName(((JCFieldAccess) tree).selected); 621 Name sname = fullName(((JCFieldAccess) tree).selected);
612 return sname == null ? null : sname.append('.', name(tree)); 622 return sname == null ? null : sname.append('.', name(tree));
613 default: 623 default:
614 return null; 624 return null;
615 } 625 }
616 } 626 }
617 627
618 public static Symbol symbolFor(JCTree node) { 628 public static Symbol symbolFor(JCTree node) {
619 node = skipParens(node); 629 node = skipParens(node);
620 switch (node.getTag()) { 630 switch (node.getTag()) {
621 case JCTree.CLASSDEF: 631 case CLASSDEF:
622 return ((JCClassDecl) node).sym; 632 return ((JCClassDecl) node).sym;
623 case JCTree.METHODDEF: 633 case METHODDEF:
624 return ((JCMethodDecl) node).sym; 634 return ((JCMethodDecl) node).sym;
625 case JCTree.VARDEF: 635 case VARDEF:
626 return ((JCVariableDecl) node).sym; 636 return ((JCVariableDecl) node).sym;
627 default: 637 default:
628 return null; 638 return null;
629 } 639 }
630 } 640 }
631 641
632 public static boolean isDeclaration(JCTree node) { 642 public static boolean isDeclaration(JCTree node) {
633 node = skipParens(node); 643 node = skipParens(node);
634 switch (node.getTag()) { 644 switch (node.getTag()) {
635 case JCTree.CLASSDEF: 645 case CLASSDEF:
636 case JCTree.METHODDEF: 646 case METHODDEF:
637 case JCTree.VARDEF: 647 case VARDEF:
638 return true; 648 return true;
639 default: 649 default:
640 return false; 650 return false;
641 } 651 }
642 } 652 }
645 * otherwise return null. 655 * otherwise return null.
646 */ 656 */
647 public static Symbol symbol(JCTree tree) { 657 public static Symbol symbol(JCTree tree) {
648 tree = skipParens(tree); 658 tree = skipParens(tree);
649 switch (tree.getTag()) { 659 switch (tree.getTag()) {
650 case JCTree.IDENT: 660 case IDENT:
651 return ((JCIdent) tree).sym; 661 return ((JCIdent) tree).sym;
652 case JCTree.SELECT: 662 case SELECT:
653 return ((JCFieldAccess) tree).sym; 663 return ((JCFieldAccess) tree).sym;
654 case JCTree.TYPEAPPLY: 664 case TYPEAPPLY:
655 return symbol(((JCTypeApply) tree).clazz); 665 return symbol(((JCTypeApply) tree).clazz);
656 default: 666 default:
657 return null; 667 return null;
658 } 668 }
659 } 669 }
660 670
661 /** Return true if this is a nonstatic selection. */ 671 /** Return true if this is a nonstatic selection. */
662 public static boolean nonstaticSelect(JCTree tree) { 672 public static boolean nonstaticSelect(JCTree tree) {
663 tree = skipParens(tree); 673 tree = skipParens(tree);
664 if (tree.getTag() != JCTree.SELECT) return false; 674 if (!tree.hasTag(SELECT)) return false;
665 JCFieldAccess s = (JCFieldAccess) tree; 675 JCFieldAccess s = (JCFieldAccess) tree;
666 Symbol e = symbol(s.selected); 676 Symbol e = symbol(s.selected);
667 return e == null || (e.kind != Kinds.PCK && e.kind != Kinds.TYP); 677 return e == null || (e.kind != Kinds.PCK && e.kind != Kinds.TYP);
668 } 678 }
669 679
670 /** If this tree is an identifier or a field, set its symbol, otherwise skip. 680 /** If this tree is an identifier or a field, set its symbol, otherwise skip.
671 */ 681 */
672 public static void setSymbol(JCTree tree, Symbol sym) { 682 public static void setSymbol(JCTree tree, Symbol sym) {
673 tree = skipParens(tree); 683 tree = skipParens(tree);
674 switch (tree.getTag()) { 684 switch (tree.getTag()) {
675 case JCTree.IDENT: 685 case IDENT:
676 ((JCIdent) tree).sym = sym; break; 686 ((JCIdent) tree).sym = sym; break;
677 case JCTree.SELECT: 687 case SELECT:
678 ((JCFieldAccess) tree).sym = sym; break; 688 ((JCFieldAccess) tree).sym = sym; break;
679 default: 689 default:
680 } 690 }
681 } 691 }
682 692
683 /** If this tree is a declaration or a block, return its flags field, 693 /** If this tree is a declaration or a block, return its flags field,
684 * otherwise return 0. 694 * otherwise return 0.
685 */ 695 */
686 public static long flags(JCTree tree) { 696 public static long flags(JCTree tree) {
687 switch (tree.getTag()) { 697 switch (tree.getTag()) {
688 case JCTree.VARDEF: 698 case VARDEF:
689 return ((JCVariableDecl) tree).mods.flags; 699 return ((JCVariableDecl) tree).mods.flags;
690 case JCTree.METHODDEF: 700 case METHODDEF:
691 return ((JCMethodDecl) tree).mods.flags; 701 return ((JCMethodDecl) tree).mods.flags;
692 case JCTree.CLASSDEF: 702 case CLASSDEF:
693 return ((JCClassDecl) tree).mods.flags; 703 return ((JCClassDecl) tree).mods.flags;
694 case JCTree.BLOCK: 704 case BLOCK:
695 return ((JCBlock) tree).flags; 705 return ((JCBlock) tree).flags;
696 default: 706 default:
697 return 0; 707 return 0;
698 } 708 }
699 } 709 }
737 precCount = 16; 747 precCount = 16;
738 748
739 749
740 /** Map operators to their precedence levels. 750 /** Map operators to their precedence levels.
741 */ 751 */
742 public static int opPrec(int op) { 752 public static int opPrec(JCTree.Tag op) {
743 switch(op) { 753 switch(op) {
744 case JCTree.POS: 754 case POS:
745 case JCTree.NEG: 755 case NEG:
746 case JCTree.NOT: 756 case NOT:
747 case JCTree.COMPL: 757 case COMPL:
748 case JCTree.PREINC: 758 case PREINC:
749 case JCTree.PREDEC: return prefixPrec; 759 case PREDEC: return prefixPrec;
750 case JCTree.POSTINC: 760 case POSTINC:
751 case JCTree.POSTDEC: 761 case POSTDEC:
752 case JCTree.NULLCHK: return postfixPrec; 762 case NULLCHK: return postfixPrec;
753 case JCTree.ASSIGN: return assignPrec; 763 case ASSIGN: return assignPrec;
754 case JCTree.BITOR_ASG: 764 case BITOR_ASG:
755 case JCTree.BITXOR_ASG: 765 case BITXOR_ASG:
756 case JCTree.BITAND_ASG: 766 case BITAND_ASG:
757 case JCTree.SL_ASG: 767 case SL_ASG:
758 case JCTree.SR_ASG: 768 case SR_ASG:
759 case JCTree.USR_ASG: 769 case USR_ASG:
760 case JCTree.PLUS_ASG: 770 case PLUS_ASG:
761 case JCTree.MINUS_ASG: 771 case MINUS_ASG:
762 case JCTree.MUL_ASG: 772 case MUL_ASG:
763 case JCTree.DIV_ASG: 773 case DIV_ASG:
764 case JCTree.MOD_ASG: return assignopPrec; 774 case MOD_ASG: return assignopPrec;
765 case JCTree.OR: return orPrec; 775 case OR: return orPrec;
766 case JCTree.AND: return andPrec; 776 case AND: return andPrec;
767 case JCTree.EQ: 777 case EQ:
768 case JCTree.NE: return eqPrec; 778 case NE: return eqPrec;
769 case JCTree.LT: 779 case LT:
770 case JCTree.GT: 780 case GT:
771 case JCTree.LE: 781 case LE:
772 case JCTree.GE: return ordPrec; 782 case GE: return ordPrec;
773 case JCTree.BITOR: return bitorPrec; 783 case BITOR: return bitorPrec;
774 case JCTree.BITXOR: return bitxorPrec; 784 case BITXOR: return bitxorPrec;
775 case JCTree.BITAND: return bitandPrec; 785 case BITAND: return bitandPrec;
776 case JCTree.SL: 786 case SL:
777 case JCTree.SR: 787 case SR:
778 case JCTree.USR: return shiftPrec; 788 case USR: return shiftPrec;
779 case JCTree.PLUS: 789 case PLUS:
780 case JCTree.MINUS: return addPrec; 790 case MINUS: return addPrec;
781 case JCTree.MUL: 791 case MUL:
782 case JCTree.DIV: 792 case DIV:
783 case JCTree.MOD: return mulPrec; 793 case MOD: return mulPrec;
784 case JCTree.TYPETEST: return ordPrec; 794 case TYPETEST: return ordPrec;
785 default: throw new AssertionError(); 795 default: throw new AssertionError();
786 } 796 }
787 } 797 }
788 798
789 static Tree.Kind tagToKind(int tag) { 799 static Tree.Kind tagToKind(JCTree.Tag tag) {
790 switch (tag) { 800 switch (tag) {
791 // Postfix expressions 801 // Postfix expressions
792 case JCTree.POSTINC: // _ ++ 802 case POSTINC: // _ ++
793 return Tree.Kind.POSTFIX_INCREMENT; 803 return Tree.Kind.POSTFIX_INCREMENT;
794 case JCTree.POSTDEC: // _ -- 804 case POSTDEC: // _ --
795 return Tree.Kind.POSTFIX_DECREMENT; 805 return Tree.Kind.POSTFIX_DECREMENT;
796 806
797 // Unary operators 807 // Unary operators
798 case JCTree.PREINC: // ++ _ 808 case PREINC: // ++ _
799 return Tree.Kind.PREFIX_INCREMENT; 809 return Tree.Kind.PREFIX_INCREMENT;
800 case JCTree.PREDEC: // -- _ 810 case PREDEC: // -- _
801 return Tree.Kind.PREFIX_DECREMENT; 811 return Tree.Kind.PREFIX_DECREMENT;
802 case JCTree.POS: // + 812 case POS: // +
803 return Tree.Kind.UNARY_PLUS; 813 return Tree.Kind.UNARY_PLUS;
804 case JCTree.NEG: // - 814 case NEG: // -
805 return Tree.Kind.UNARY_MINUS; 815 return Tree.Kind.UNARY_MINUS;
806 case JCTree.COMPL: // ~ 816 case COMPL: // ~
807 return Tree.Kind.BITWISE_COMPLEMENT; 817 return Tree.Kind.BITWISE_COMPLEMENT;
808 case JCTree.NOT: // ! 818 case NOT: // !
809 return Tree.Kind.LOGICAL_COMPLEMENT; 819 return Tree.Kind.LOGICAL_COMPLEMENT;
810 820
811 // Binary operators 821 // Binary operators
812 822
813 // Multiplicative operators 823 // Multiplicative operators
814 case JCTree.MUL: // * 824 case MUL: // *
815 return Tree.Kind.MULTIPLY; 825 return Tree.Kind.MULTIPLY;
816 case JCTree.DIV: // / 826 case DIV: // /
817 return Tree.Kind.DIVIDE; 827 return Tree.Kind.DIVIDE;
818 case JCTree.MOD: // % 828 case MOD: // %
819 return Tree.Kind.REMAINDER; 829 return Tree.Kind.REMAINDER;
820 830
821 // Additive operators 831 // Additive operators
822 case JCTree.PLUS: // + 832 case PLUS: // +
823 return Tree.Kind.PLUS; 833 return Tree.Kind.PLUS;
824 case JCTree.MINUS: // - 834 case MINUS: // -
825 return Tree.Kind.MINUS; 835 return Tree.Kind.MINUS;
826 836
827 // Shift operators 837 // Shift operators
828 case JCTree.SL: // << 838 case SL: // <<
829 return Tree.Kind.LEFT_SHIFT; 839 return Tree.Kind.LEFT_SHIFT;
830 case JCTree.SR: // >> 840 case SR: // >>
831 return Tree.Kind.RIGHT_SHIFT; 841 return Tree.Kind.RIGHT_SHIFT;
832 case JCTree.USR: // >>> 842 case USR: // >>>
833 return Tree.Kind.UNSIGNED_RIGHT_SHIFT; 843 return Tree.Kind.UNSIGNED_RIGHT_SHIFT;
834 844
835 // Relational operators 845 // Relational operators
836 case JCTree.LT: // < 846 case LT: // <
837 return Tree.Kind.LESS_THAN; 847 return Tree.Kind.LESS_THAN;
838 case JCTree.GT: // > 848 case GT: // >
839 return Tree.Kind.GREATER_THAN; 849 return Tree.Kind.GREATER_THAN;
840 case JCTree.LE: // <= 850 case LE: // <=
841 return Tree.Kind.LESS_THAN_EQUAL; 851 return Tree.Kind.LESS_THAN_EQUAL;
842 case JCTree.GE: // >= 852 case GE: // >=
843 return Tree.Kind.GREATER_THAN_EQUAL; 853 return Tree.Kind.GREATER_THAN_EQUAL;
844 854
845 // Equality operators 855 // Equality operators
846 case JCTree.EQ: // == 856 case EQ: // ==
847 return Tree.Kind.EQUAL_TO; 857 return Tree.Kind.EQUAL_TO;
848 case JCTree.NE: // != 858 case NE: // !=
849 return Tree.Kind.NOT_EQUAL_TO; 859 return Tree.Kind.NOT_EQUAL_TO;
850 860
851 // Bitwise and logical operators 861 // Bitwise and logical operators
852 case JCTree.BITAND: // & 862 case BITAND: // &
853 return Tree.Kind.AND; 863 return Tree.Kind.AND;
854 case JCTree.BITXOR: // ^ 864 case BITXOR: // ^
855 return Tree.Kind.XOR; 865 return Tree.Kind.XOR;
856 case JCTree.BITOR: // | 866 case BITOR: // |
857 return Tree.Kind.OR; 867 return Tree.Kind.OR;
858 868
859 // Conditional operators 869 // Conditional operators
860 case JCTree.AND: // && 870 case AND: // &&
861 return Tree.Kind.CONDITIONAL_AND; 871 return Tree.Kind.CONDITIONAL_AND;
862 case JCTree.OR: // || 872 case OR: // ||
863 return Tree.Kind.CONDITIONAL_OR; 873 return Tree.Kind.CONDITIONAL_OR;
864 874
865 // Assignment operators 875 // Assignment operators
866 case JCTree.MUL_ASG: // *= 876 case MUL_ASG: // *=
867 return Tree.Kind.MULTIPLY_ASSIGNMENT; 877 return Tree.Kind.MULTIPLY_ASSIGNMENT;
868 case JCTree.DIV_ASG: // /= 878 case DIV_ASG: // /=
869 return Tree.Kind.DIVIDE_ASSIGNMENT; 879 return Tree.Kind.DIVIDE_ASSIGNMENT;
870 case JCTree.MOD_ASG: // %= 880 case MOD_ASG: // %=
871 return Tree.Kind.REMAINDER_ASSIGNMENT; 881 return Tree.Kind.REMAINDER_ASSIGNMENT;
872 case JCTree.PLUS_ASG: // += 882 case PLUS_ASG: // +=
873 return Tree.Kind.PLUS_ASSIGNMENT; 883 return Tree.Kind.PLUS_ASSIGNMENT;
874 case JCTree.MINUS_ASG: // -= 884 case MINUS_ASG: // -=
875 return Tree.Kind.MINUS_ASSIGNMENT; 885 return Tree.Kind.MINUS_ASSIGNMENT;
876 case JCTree.SL_ASG: // <<= 886 case SL_ASG: // <<=
877 return Tree.Kind.LEFT_SHIFT_ASSIGNMENT; 887 return Tree.Kind.LEFT_SHIFT_ASSIGNMENT;
878 case JCTree.SR_ASG: // >>= 888 case SR_ASG: // >>=
879 return Tree.Kind.RIGHT_SHIFT_ASSIGNMENT; 889 return Tree.Kind.RIGHT_SHIFT_ASSIGNMENT;
880 case JCTree.USR_ASG: // >>>= 890 case USR_ASG: // >>>=
881 return Tree.Kind.UNSIGNED_RIGHT_SHIFT_ASSIGNMENT; 891 return Tree.Kind.UNSIGNED_RIGHT_SHIFT_ASSIGNMENT;
882 case JCTree.BITAND_ASG: // &= 892 case BITAND_ASG: // &=
883 return Tree.Kind.AND_ASSIGNMENT; 893 return Tree.Kind.AND_ASSIGNMENT;
884 case JCTree.BITXOR_ASG: // ^= 894 case BITXOR_ASG: // ^=
885 return Tree.Kind.XOR_ASSIGNMENT; 895 return Tree.Kind.XOR_ASSIGNMENT;
886 case JCTree.BITOR_ASG: // |= 896 case BITOR_ASG: // |=
887 return Tree.Kind.OR_ASSIGNMENT; 897 return Tree.Kind.OR_ASSIGNMENT;
888 898
889 // Null check (implementation detail), for example, __.getClass() 899 // Null check (implementation detail), for example, __.getClass()
890 case JCTree.NULLCHK: 900 case NULLCHK:
891 return Tree.Kind.OTHER; 901 return Tree.Kind.OTHER;
892 902
893 default: 903 default:
894 return null; 904 return null;
895 } 905 }
899 * Returns the underlying type of the tree if it is annotated type, 909 * Returns the underlying type of the tree if it is annotated type,
900 * or the tree itself otherwise 910 * or the tree itself otherwise
901 */ 911 */
902 public static JCExpression typeIn(JCExpression tree) { 912 public static JCExpression typeIn(JCExpression tree) {
903 switch (tree.getTag()) { 913 switch (tree.getTag()) {
904 case JCTree.IDENT: /* simple names */ 914 case IDENT: /* simple names */
905 case JCTree.TYPEIDENT: /* primitive name */ 915 case TYPEIDENT: /* primitive name */
906 case JCTree.SELECT: /* qualified name */ 916 case SELECT: /* qualified name */
907 case JCTree.TYPEARRAY: /* array types */ 917 case TYPEARRAY: /* array types */
908 case JCTree.WILDCARD: /* wild cards */ 918 case WILDCARD: /* wild cards */
909 case JCTree.TYPEPARAMETER: /* type parameters */ 919 case TYPEPARAMETER: /* type parameters */
910 case JCTree.TYPEAPPLY: /* parameterized types */ 920 case TYPEAPPLY: /* parameterized types */
911 return tree; 921 return tree;
912 default: 922 default:
913 throw new AssertionError("Unexpected type tree: " + tree); 923 throw new AssertionError("Unexpected type tree: " + tree);
914 } 924 }
915 } 925 }
916 926
917 public static JCTree innermostType(JCTree type) { 927 public static JCTree innermostType(JCTree type) {
918 switch (type.getTag()) { 928 switch (type.getTag()) {
919 case JCTree.TYPEARRAY: 929 case TYPEARRAY:
920 return innermostType(((JCArrayTypeTree)type).elemtype); 930 return innermostType(((JCArrayTypeTree)type).elemtype);
921 case JCTree.WILDCARD: 931 case WILDCARD:
922 return innermostType(((JCWildcard)type).inner); 932 return innermostType(((JCWildcard)type).inner);
923 default: 933 default:
924 return type; 934 return type;
925 } 935 }
926 } 936 }

Mercurial Repository: jdk8-mips64-public/langtools

mercurial