while (args != null && args.head != null) { String key = args.head.toString(); if (args.head.getTag() == Tag.LITERAL && key.startsWith("\"")) { key = key.substring(1, key.length() - 1); if (JJavaName.isJavaIdentifier(key)) {
/** Check that given tree is a legal expression statement. */ protected JCExpression checkExprStat(JCExpression t) { switch(t.getTag()) { case JCTree.PREINC: case JCTree.PREDEC: case JCTree.POSTINC: case JCTree.POSTDEC: case JCTree.ASSIGN: 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: case JCTree.APPLY: case JCTree.NEWCLASS: case JCTree.ERRONEOUS: return t; default: log.error(t.pos, "not.stmt"); return F.at(t.pos).Erroneous(List.<JCTree>of(t)); } }
/** AnnotationFieldValue = AnnotationValue * | Identifier "=" AnnotationValue */ JCExpression annotationFieldValue() { if (S.token() == IDENTIFIER) { mode = EXPR; JCExpression t1 = term1(); if (t1.getTag() == JCTree.IDENT && S.token() == EQ) { int pos = S.pos(); accept(EQ); return toP(F.at(pos).Assign(t1, annotationValue())); } else { return t1; } } return annotationValue(); }
/** 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; Name.Table names = md.name.table; 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 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; } }
/** If tree refers to a superclass constructor call, * add all free variables of the superclass. */ public void visitApply(JCMethodInvocation tree) { if (TreeInfo.name(tree.meth) == names._super) { addFreeVars((ClassSymbol) TreeInfo.symbol(tree.meth).owner); Symbol constructor = TreeInfo.symbol(tree.meth); ClassSymbol c = (ClassSymbol)constructor.owner; if (c.hasOuterInstance() && tree.meth.getTag() != JCTree.SELECT && outerThisStack.head != null) visitSymbol(outerThisStack.head); } super.visitApply(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; } }
@Override protected Type typeOf(DeferredType dt) { Type res = super.typeOf(dt); if (!res.isErroneous()) { switch (TreeInfo.skipParens(dt.tree).getTag()) { case LAMBDA: case REFERENCE: return dt; case CONDEXPR: return res == Type.recoveryType ? dt : res; } } return res; } }
public void visitSynchronized(JCSynchronized tree) { try { print("synchronized "); if (tree.lock.getTag() == JCTree.PARENS) { printExpr(tree.lock); } else { print("("); printExpr(tree.lock); print(")"); } print(" "); printStat(tree.body); } catch (IOException e) { throw new UncheckedIOException(e); } }
@Override protected Type typeOf(DeferredType dt) { Type res = super.typeOf(dt); if (!res.isErroneous()) { switch (TreeInfo.skipParens(dt.tree).getTag()) { case LAMBDA: case REFERENCE: return dt; case CONDEXPR: return res == Type.recoveryType ? dt : res; } } return res; } }
public void visitWhileLoop(JCWhileLoop tree) { try { print("while "); if (tree.cond.getTag() == JCTree.PARENS) { printExpr(tree.cond); } else { print("("); printExpr(tree.cond); print(")"); } print(" "); printStat(tree.body); } catch (IOException e) { throw new UncheckedIOException(e); } }
public void visitSelect(JCFieldAccess tree) { // need to special case-access of the form C.super.x // these will always need an access method. boolean qualifiedSuperAccess = tree.selected.getTag() == JCTree.SELECT && TreeInfo.name(tree.selected) == names._super; tree.selected = translate(tree.selected); if (tree.name == names._class) result = classOf(tree.selected); else if (tree.name == names._this || tree.name == names._super) result = makeThis(tree.pos(), tree.selected.type.tsym); else result = access(tree.sym, tree, enclOp, qualifiedSuperAccess); }
public void visitAssign(JCAssign tree) { tree.lhs = translate(tree.lhs, tree); tree.rhs = translate(tree.rhs, tree.lhs.type); // If translated left hand side is an Apply, we are // seeing an access method invocation. In this case, append // right hand side as last argument of the access method. if (tree.lhs.getTag() == JCTree.APPLY) { JCMethodInvocation app = (JCMethodInvocation)tree.lhs; app.args = List.of(tree.rhs).prependList(app.args); result = app; } else { result = tree; } }
private String expr2String(JCExpression tree) { switch(tree.getTag()) { case PARENS: return expr2String(((JCParens)tree).expr); case LAMBDA: case REFERENCE: case CONDEXPR: return Pretty.toSimpleString(tree); default: Assert.error("unexpected tree kind " + tree.getKind()); return null; } }
public void visitExec(JCExpressionStatement tree) { // Optimize x++ to ++x and x-- to --x. JCExpression e = tree.expr; switch (e.getTag()) { case POSTINC: ((JCUnary) e).setTag(PREINC); break; case POSTDEC: ((JCUnary) e).setTag(PREDEC); break; } genExpr(tree.expr, tree.expr.type).drop(); }
public void visitExec(JCExpressionStatement tree) { // Optimize x++ to ++x and x-- to --x. JCExpression e = tree.expr; switch (e.getTag()) { case JCTree.POSTINC: ((JCUnary) e).setTag(JCTree.PREINC); break; case JCTree.POSTDEC: ((JCUnary) e).setTag(JCTree.PREDEC); break; } genExpr(tree.expr, tree.expr.type).drop(); }
private String expr2String(JCExpression tree) { switch(tree.getTag()) { case PARENS: return expr2String(((JCParens)tree).expr); case LAMBDA: case REFERENCE: case CONDEXPR: return Pretty.toSimpleString(tree); default: Assert.error("unexpected tree kind " + tree.getKind()); return null; } }
public void visitExec(JCExpressionStatement tree) { // Optimize x++ to ++x and x-- to --x. JCExpression e = tree.expr; switch (e.getTag()) { case POSTINC: ((JCUnary) e).setTag(PREINC); break; case POSTDEC: ((JCUnary) e).setTag(PREDEC); break; } genExpr(tree.expr, tree.expr.type).drop(); }
/** Skip parens and return the enclosed expression */ public static JCExpression skipParens(JCExpression tree) { while (tree.getTag() == JCTree.PARENS) { tree = ((JCParens) tree).expr; } return tree; }
/** 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; }