Refine search
/** Removes any enclosing parentheses from the tree. */ public static Tree stripParentheses(Tree tree) { while (tree instanceof ParenthesizedTree) { tree = ((ParenthesizedTree) tree).getExpression(); } return tree; }
private void insideParens(Env env) throws IOException { TreePath path = env.getPath(); ParenthesizedTree pa = (ParenthesizedTree) path.getLeaf(); SourcePositions sourcePositions = env.getSourcePositions(); CompilationUnitTree root = env.getRoot(); Tree exp = unwrapErrTree(pa.getExpression()); if (exp == null || env.getOffset() <= sourcePositions.getStartPosition(root, exp)) { if (!options.contains(Options.ALL_COMPLETION) && path.getParentPath().getLeaf().getKind() != Tree.Kind.SWITCH) { Set<? extends TypeMirror> smarts = getSmartTypes(env); if (smarts != null) {
@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()); } }
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 Void visitParenthesized(ParenthesizedTree tree, EnumSet<UseTypes> d) { ExpressionTree expr = tree.getExpression(); if (expr instanceof IdentifierTree) { handlePossibleIdentifier(new TreePath(getCurrentPath(), expr), EnumSet.of(UseTypes.READ)); } super.visitParenthesized(tree, d); return null; }
Tree last = null; while (path != null) { if (path.getLeaf().getKind() == Tree.Kind.IF) { IfTree ifTree = (IfTree) path.getLeaf(); if (ifTree.getThenStatement() == last) { Tree cond = ifTree.getCondition(); while (cond.getKind() == Tree.Kind.PARENTHESIZED) { cond = ((ParenthesizedTree)cond).getExpression(); if (element == trees.getElement(new TreePath(path, instTree.getExpression()))) { TypeMirror tm = trees.getTypeMirror(new TreePath(path, instTree.getType())); if (tm != null && tu.isCastable(original, tm)) {
@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()); } }
String prefix = env.getPrefix(); TreePath path = env.getPath(); MemberSelectTree fa = (MemberSelectTree) path.getLeaf(); CompilationController controller = env.getController(); CompilationUnitTree root = env.getRoot(); insideExpression(env, new TreePath(path, fa.getExpression())); TreePath parentPath = path.getParentPath(); Tree parent = parentPath != null ? parentPath.getLeaf() : null; TreePath grandParentPath = parentPath != null ? parentPath.getParentPath() : null; while (b) { if (exp.getKind() == Tree.Kind.PARENTHESIZED) { exp = ((ParenthesizedTree) exp).getExpression(); expPath = new TreePath(expPath, exp); } else if (exp.getKind() == Tree.Kind.TYPE_CAST) {
boolean oldContinuationIndent = continuationIndent; try { switch(getCurrentPath().getParentPath().getLeaf().getKind()) { case IF: spaceWithinParens = cs.spaceWithinIfParens(); scan(node.getExpression(), p); spaces(spaceWithinParens ? 1 : 0); } finally {
/** Given an ExpressionTree, removes any enclosing parentheses. */ public static ExpressionTree stripParentheses(ExpressionTree tree) { while (tree instanceof ParenthesizedTree) { tree = ((ParenthesizedTree) tree).getExpression(); } return tree; }
private void insideExpression(Env env, TreePath exPath) throws IOException { int offset = env.getOffset(); String prefix = env.getPrefix(); Tree et = exPath.getLeaf(); Tree parent = exPath.getParentPath().getLeaf(); final CompilationController controller = env.getController(); int endPos = (int) env.getSourcePositions().getEndPosition(env.getRoot(), et); exp = ((ParenthesizedTree) et).getExpression(); } else if (et.getKind() == Tree.Kind.TYPE_CAST) { if (env.getSourcePositions().getEndPosition(env.getRoot(), ((TypeCastTree) et).getType()) <= offset) { Tree t = ((AssignmentTree) et).getExpression(); if (t.getKind() == Tree.Kind.PARENTHESIZED && env.getSourcePositions().getEndPosition(env.getRoot(), t) < offset) { exp = ((ParenthesizedTree) t).getExpression();
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"); }