/** Removes any enclosing parentheses from the tree. */ public static Tree stripParentheses(Tree tree) { while (tree instanceof ParenthesizedTree) { tree = ((ParenthesizedTree) tree).getExpression(); } return tree; }
/** Given an ExpressionTree, removes any enclosing parentheses. */ public static ExpressionTree stripParentheses(ExpressionTree tree) { while (tree instanceof ParenthesizedTree) { tree = ((ParenthesizedTree) tree).getExpression(); } return tree; }
private static ExpressionTree skipOneParen(ExpressionTree tree) { // javac includes a ParenthesizedTree for the mandatory parens in if statement and loop // conditions, e.g. in `if (true) {}` the condition is a paren tree containing a literal. return tree instanceof ParenthesizedTree ? ((ParenthesizedTree) tree).getExpression() : tree; }
@Override public GuardedByExpression visitParenthesized( ParenthesizedTree node, BinderContext context) { return node.getExpression().accept(this, context); }
@Override public Number visitParenthesized(ParenthesizedTree node, Void p) { return node.getExpression().accept(this, null); }
@Override public Tree visitParenthesized(ParenthesizedTree node, Void v) { return node.getExpression().accept(this, null); }
@Override public Type visitParenthesized(ParenthesizedTree node, Void unused) { return visit(node.getExpression(), unused); }
@Override public UParens visitParenthesized(ParenthesizedTree tree, Void v) { return UParens.create(template(tree.getExpression())); }
@Override public Choice<State<JCParens>> visitParenthesized(ParenthesizedTree node, State<?> state) { return chooseSubtrees(state, s -> unifyExpression(node.getExpression(), s), maker()::Parens); }
/** * Unwraps expressions like `(Foo) foo` or `((Foo) foo)` to return the VarSymbol of `foo`, or * null if the expression wasn't of this form. */ @Nullable private VarSymbol findVariable(Tree tree) { while (tree != null) { switch (tree.getKind()) { case TYPE_CAST: tree = ((TypeCastTree) tree).getExpression(); break; case PARENTHESIZED: tree = ((ParenthesizedTree) tree).getExpression(); break; case IDENTIFIER: Symbol symbol = getSymbol(tree); return symbol instanceof VarSymbol ? (VarSymbol) symbol : null; default: return null; } } return null; } }.scan(state.getPath(), null);
private static boolean matchesThis(ExpressionTree tree) { ExpressionTree receiver = getReceiver(tree); if (receiver == null) { return true; } while (!(receiver instanceof IdentifierTree)) { if (receiver instanceof ParenthesizedTree) { receiver = ((ParenthesizedTree) receiver).getExpression(); } else if (receiver instanceof TypeCastTree) { receiver = ((TypeCastTree) receiver).getExpression(); } else { return false; } } Symbol symbol = getSymbol(receiver); return symbol != null && symbol.getSimpleName().contentEquals("this"); }
/** * strip out enclosing parentheses and type casts. * * @param expr * @return */ private static ExpressionTree stripParensAndCasts(ExpressionTree expr) { boolean someChange = true; while (someChange) { someChange = false; if (expr.getKind().equals(PARENTHESIZED)) { expr = ((ParenthesizedTree) expr).getExpression(); someChange = true; } if (expr.getKind().equals(TYPE_CAST)) { expr = ((TypeCastTree) expr).getExpression(); someChange = true; } } return expr; }
@Override public Description matchParenthesized(ParenthesizedTree tree, VisitorState state) { ExpressionTree expression = tree.getExpression(); if (state.getPath().getParentPath().getLeaf() instanceof StatementTree) { return NO_MATCH; } if (ASTHelpers.requiresParentheses(expression, state)) { return NO_MATCH; } return describeMatch( tree, SuggestedFix.builder() .replace( ((JCTree) tree).getStartPosition(), ((JCTree) expression).getStartPosition(), "") .replace(state.getEndPosition(expression), state.getEndPosition(tree), "") .build()); } }
/** Removes any enclosing parentheses from the tree. */ public static Tree stripParentheses(Tree tree) { while (tree instanceof ParenthesizedTree) { tree = ((ParenthesizedTree) tree).getExpression(); } return tree; }
/** Given an ExpressionTree, removes any enclosing parentheses. */ public static ExpressionTree stripParentheses(ExpressionTree tree) { while (tree instanceof ParenthesizedTree) { tree = ((ParenthesizedTree) tree).getExpression(); } return tree; }
@Override public String visitParenthesized(ParenthesizedTree node, Void v) { StringBuilder out = new StringBuilder(); out.append("("); out.append(node.getExpression().accept(this, v)); if (mode == Mode.USING_CAST) { out.append(" as IMonitorLock"); } out.append(")"); return out.toString(); }
@Override public Void visitParenthesized(ParenthesizedTree expected, Tree actual) { Optional<ParenthesizedTree> other = checkTypeAndCast(expected, actual); if (!other.isPresent()) { addTypeMismatch(expected, actual); return null; } scan(expected.getExpression(), other.get().getExpression()); return null; }
@Override public Void visitParenthesized(ParenthesizedTree expected, Tree actual) { Optional<ParenthesizedTree> other = checkTypeAndCast(expected, actual); if (!other.isPresent()) { addTypeMismatch(expected, actual); return null; } scan(expected.getExpression(), other.get().getExpression()); return null; }
public Boolean visitParenthesized(ParenthesizedTree node, TreePath p) { if (p == null) return super.visitParenthesized(node, p); ParenthesizedTree t = (ParenthesizedTree) p.getLeaf(); return scan(node.getExpression(), t.getExpression(), p); }
@Override public Tree visitParenthesized(ParenthesizedTree tree, Void p) { ParenthesizedTree n = make.Parenthesized(tree.getExpression()); model.setType(n, model.getType(tree)); comments.copyComments(tree, n); model.setPos(n, model.getPos(tree)); return n; }