@Override public Description visitMethod(MethodTree node, Void aVoid) { BlockTree methodBody = node.getBody(); if (methodBody == null) { return Description.NO_MATCH; } return methodBody.getStatements().stream() .map(tree -> tree.accept(this, null)) .filter(notNull()) .findFirst() .orElse(Description.NO_MATCH); }
private static boolean blockEndsInBreakOrReturn(VisitorState state) { TreePath statementPath = state.findPathToEnclosing(StatementTree.class); if (statementPath == null) { return false; } Tree parent = statementPath.getParentPath().getLeaf(); if (!(parent instanceof BlockTree)) { return false; } StatementTree statement = (StatementTree) statementPath.getLeaf(); List<? extends StatementTree> statements = ((BlockTree) parent).getStatements(); int idx = statements.indexOf(statement); if (idx == -1 || idx == statements.size()) { return false; } switch (getLast(statements).getKind()) { case BREAK: case RETURN: return true; default: return false; } }
case INTERFACE: bracePlacement = cs.getOtherBracePlacement(); if (node.isStatic()) spaceBeforeLeftBrace = cs.spaceBeforeStaticInitLeftBrace(); break; case TRY: bracePlacement = cs.getOtherBracePlacement(); if (((TryTree)getCurrentPath().getParentPath().getLeaf()).getBlock() == node) spaceBeforeLeftBrace = cs.spaceBeforeTryLeftBrace(); else int lastMaxPreservedBlankLines = maxPreservedBlankLines; maxPreservedBlankLines = cs.getMaximumBlankLinesInCode(); for (StatementTree stat : node.getStatements()) { if (stat.getKind() == Tree.Kind.LABELED_STATEMENT && cs.absoluteLabelIndent()) { int o = indent; int oLDiff = lastIndent - indent; appendToDiff(getNewlines(1) + getIndent()); col = indent(); } else if (stat.getKind() == Tree.Kind.EMPTY_STATEMENT || stat.getKind() == Tree.Kind.EXPRESSION_STATEMENT && ((ExpressionStatementTree)stat).getExpression().getKind() == Tree.Kind.ERRONEOUS) { spaces(0, true); } else if (!fieldGroup || stat.getKind() != Tree.Kind.VARIABLE) { newline();
@Override public Description matchForLoop(ForLoopTree forLoopTree, VisitorState visitorState) { List<? extends ExpressionStatementTree> updates = forLoopTree.getUpdate(); // keep track of all the symbols that are updated in the for loop header final Set<Symbol> incrementedSymbols = updates.stream() .filter(expStateTree -> expStateTree.getExpression() instanceof UnaryTree) .map( expStateTree -> ASTHelpers.getSymbol( ((UnaryTree) expStateTree.getExpression()).getExpression())) .collect(Collectors.toCollection(HashSet::new)); // track if they are updated in the body without a conditional surrounding them StatementTree body = forLoopTree.getStatement(); List<? extends StatementTree> statementTrees = body instanceof BlockTree ? ((BlockTree) body).getStatements() : ImmutableList.of(body); for (StatementTree s : statementTrees) { if (!CONDITIONALS.contains(s.getKind())) { Optional<Symbol> opSymbol = returnUnarySym(s); if (opSymbol.isPresent() && incrementedSymbols.contains(opSymbol.get())) { // both ++ and -- return describeMatch(forLoopTree); } } } return Description.NO_MATCH; }
@Override protected void addFix(Description.Builder description, ExpressionTree tree, VisitorState state) { TreePath parentPath = state.getPath().getParentPath(); Tree parent = parentPath.getLeaf(); SuggestedFix.Builder fix = SuggestedFix.builder(); String streamType = SuggestedFixes.prettyType(state, fix, ASTHelpers.getReturnType(tree)); Tree grandParent = parentPath.getParentPath().getLeaf(); if (!(grandParent instanceof BlockTree)) { return; List<? extends StatementTree> statements = ((BlockTree) grandParent).getStatements(); int idx = statements.indexOf(parent); int lastUse = idx; statements .get(i) .accept( new TreeScanner<Void, Void>() { @Override
unconsumedStatements.subList(1, unconsumedStatements.size()); StatementTree firstStatement = unconsumedStatements.get(0); if (firstStatement.getKind() != Kind.IF) { return Choice.none(); Choice<UnifierWithUnconsumedStatements> forwardMatch = getCondition() .unify(ifTree.getCondition(), unifier.fork()) .thenChoose( unifyUStatementWithSingleStatement(getThenStatement(), ifTree.getThenStatement())) .thenChoose( unifierAfterThen -> { if (getElseStatement() != null && ifTree.getElseStatement() == null && ControlFlowVisitor.INSTANCE.visitStatement(ifTree.getThenStatement()) == Result.ALWAYS_RETURNS) {
private void insideBlock(Env env) throws IOException { int offset = env.getOffset(); BlockTree bl = (BlockTree) env.getPath().getLeaf(); SourcePositions sourcePositions = env.getSourcePositions(); CompilationUnitTree root = env.getRoot(); for (StatementTree stat : bl.getStatements()) { int pos = (int) sourcePositions.getStartPosition(root, stat); if (pos == Diagnostic.NOPOS || offset <= pos) { } else if (last.getKind() == Tree.Kind.TRY) { if (((TryTree) last).getFinallyBlock() == null) { addKeyword(env, CATCH_KEYWORD, null, true); } else if (last.getKind() == Tree.Kind.IF) { if (((IfTree) last).getElseStatement() == null) { addKeyword(env, ELSE_KEYWORD, null, true);
@Override public String visitIf(IfTree node, Void v) { StringBuilder out = new StringBuilder(); ExpressionTree cond = node.getCondition(); StatementTree thenStm = node.getThenStatement(); StatementTree elseStm = node.getElseStatement(); out.append("if "); out.append(cond.accept(this, v)); if (thenStm instanceof BlockTree) { out.append(thenStm.accept(this, v)); out.deleteCharAt(out.length() - 1); } else { symTable.pushLocalScope(); appendIndent(out); out.append(thenStm.accept(this, v)); symTable.popLocalScope(); popIndent(); out.append(elseStm.accept(this, v)); if (elseStm instanceof BlockTree) { out.deleteCharAt(out.length() - 1); symTable.pushLocalScope(); appendIndent(out); out.append(elseStm.accept(this, v)); symTable.popLocalScope(); popIndent();
private void insideSwitch(Env env) throws IOException { int offset = env.getOffset(); TreePath path = env.getPath(); SwitchTree st = (SwitchTree) path.getLeaf(); SourcePositions sourcePositions = env.getSourcePositions(); CompilationUnitTree root = env.getRoot(); if (last.getKind() == Tree.Kind.TRY) { if (((TryTree) last).getFinallyBlock() == null) { addKeyword(env, CATCH_KEYWORD, null, false); } else if (last.getKind() == Tree.Kind.IF) { if (((IfTree) last).getElseStatement() == null) { addKeyword(env, ELSE_KEYWORD, null, false);
SuggestedFix.builder().setShortDescription("remove unused variable and any side effects"); for (TreePath usagePath : usagePaths) { StatementTree statement = (StatementTree) usagePath.getLeaf(); if (statement.getKind() == Kind.VARIABLE) { VariableTree variableTree = (VariableTree) statement; ExpressionTree initializer = variableTree.getInitializer(); } else if (statement.getKind() == Kind.EXPRESSION_STATEMENT) { JCTree tree = (JCTree) ((ExpressionStatementTree) statement).getExpression();
token = findFirstNonWhitespaceToken(startOffset, lastPos); if (token != null && !EnumSet.of(JavaTokenId.RBRACE, JavaTokenId.SEMICOLON).contains(token.token().id())) { currentIndent = getStmtIndent(startOffset, endOffset, EnumSet.of(JavaTokenId.RPAREN, JavaTokenId.ELSE), getEndPosition(((IfTree)last).getCondition()) - 1, currentIndent); break; case BLOCK: boolean isStatic = ((BlockTree)last).isStatic(); if (isStatic) { token = findFirstNonWhitespaceToken(startOffset, lastPos); t = null; boolean isNextLabeledStatement = false; Iterator<? extends StatementTree> it = ((BlockTree)last).getStatements().iterator(); while (it.hasNext()) { StatementTree st = it.next(); if (getEndPosition(st) > startOffset) { isNextLabeledStatement = st.getKind() == Kind.LABELED_STATEMENT; break;
@Override public Result visitIf(IfTree node, BreakContext cxt) { Result thenResult = node.getThenStatement().accept(this, cxt); Result elseResult = (node.getElseStatement() == null) ? NEVER_EXITS : node.getElseStatement().accept(this, cxt); return thenResult.or(elseResult); }
StringBuilder out = new StringBuilder(); if (node.isStatic()) { appendAsInlineComment(out, "FIX ME: initializer blocks not allowed in Gosu"); List<? extends StatementTree> statements = node.getStatements(); for (StatementTree stm : statements) { appendIndent(out); out.append(stm.accept(this, v)); out.append("\n");
public UStatement template(StatementTree tree) { return (UStatement) tree.accept(this, null); }
.accept( new TreeScanner<Void, VisitorState>() { @Override if (tree.getBody().getStatements().size() == 1 && tree.getBody().getStatements().get(0).getKind() == Kind.RETURN) { ReturnTree returnTree = (ReturnTree) tree.getBody().getStatements().get(0); if (returnTree.getExpression().getKind() == Kind.CONDITIONAL_EXPRESSION) {
/** * Creates a new BlockTree for provided <tt>bodyText</tt>. * * @param method figures out the scope for attribution. * @param bodyText text which will be used for method body creation. * @return a new tree for <tt>bodyText</tt>. */ public BlockTree createMethodBody(MethodTree method, String bodyText) { SourcePositions[] positions = new SourcePositions[1]; final TreeUtilities treeUtils = copy.getTreeUtilities(); StatementTree body = treeUtils.parseStatement(bodyText, positions); assert Tree.Kind.BLOCK == body.getKind() : "Not a statement block!"; Scope scope = copy.getTrees().getScope(TreePath.getPath(copy.getCompilationUnit(), method)); treeUtils.attributeTree(body, scope); mapComments((BlockTree) body, bodyText, copy, handler, positions[0]); new TreePosCleaner().scan(body, null); return (BlockTree) body; }
public IfTree If(ExpressionTree condition, StatementTree thenStatement, StatementTree elseStatement) { if (thenStatement != null && thenStatement.getKind() == Tree.Kind.IF && elseStatement != null && ((IfTree)thenStatement).getElseStatement() == null) { // Issue #257910: special case - if `thenStatement' is just inserted into the source. // If the nested if contains `else' clause, it gets paired correctly. thenStatement = Block(Collections.singletonList(thenStatement), false); } return make.at(NOPOS).If((JCExpression)condition, (JCStatement)thenStatement, (JCStatement)elseStatement); }
/** Returns true if the default is empty, or contains only a break statement. */ private boolean trivialDefault(List<? extends StatementTree> defaultStatements) { if (defaultStatements.isEmpty()) { return true; } return (defaultStatements.size() == 1 && getOnlyElement(defaultStatements).getKind() == Tree.Kind.BREAK); }
@Override public boolean matches(MethodTree method, VisitorState state) { List<? extends VariableTree> parameters = method.getParameters(); if (!parameters.isEmpty()) { return false; } BlockTree body = method.getBody(); if (body == null) { return false; } List<? extends StatementTree> statements = body.getStatements(); if (statements.size() != 1) { return false; } StatementTree onlyStatement = Iterables.getOnlyElement(statements); if (!onlyStatement.getKind().equals(RETURN)) { return false; } return EMPTY_SET.matches(((ReturnTree) onlyStatement).getExpression(), state); } };
@Override protected void addFix(Description.Builder description, ExpressionTree tree, VisitorState state) { TreePath parentPath = state.getPath().getParentPath(); Tree parent = parentPath.getLeaf(); SuggestedFix.Builder fix = SuggestedFix.builder(); String streamType = SuggestedFixes.prettyType(state, fix, ASTHelpers.getReturnType(tree)); Tree grandParent = parentPath.getParentPath().getLeaf(); if (!(grandParent instanceof BlockTree)) { return; List<? extends StatementTree> statements = ((BlockTree) grandParent).getStatements(); int idx = statements.indexOf(parent); int lastUse = idx; statements .get(i) .accept( new TreeScanner<Void, Void>() { @Override