private static boolean hasBodySingleIfStatement(StatementTree thenStatement) { if (thenStatement.is(Tree.Kind.BLOCK)) { // thenStatement has curly braces. Let's see what's inside... BlockTree block = (BlockTree) thenStatement; return block.body().size() == 1 && block.body().get(0).is(Tree.Kind.IF_STATEMENT); } else if (thenStatement.is(Tree.Kind.IF_STATEMENT)) { // no curlys on thenStatement; it's a bare if statement return true; } return false; } }
public void addVariables(List<StatementTree> statementTrees) { for (StatementTree statementTree : statementTrees) { if (statementTree.is(Tree.Kind.VARIABLE)) { addVariable((VariableTree) statementTree); } } }
@CheckForNull private static ExpressionTree expressionFromSingleStatementBlock(List<StatementTree> body) { if (body.size() == 1) { StatementTree singleStatement = body.get(0); if (singleStatement.is(Tree.Kind.EXPRESSION_STATEMENT)) { return ((ExpressionStatementTree) singleStatement).expression(); } } return null; }
private void checkStatement(SyntaxToken reportToken, StatementTree statement) { if (!statement.is(Tree.Kind.BLOCK)) { reportIssue(reportToken, "Missing curly brace."); } } }
private static boolean isLastStatement(@Nullable BlockTree blockTree, MethodInvocationTree lastStatementTree) { if (blockTree != null) { StatementTree last = Iterables.getLast(blockTree.body()); if (last.is(Kind.EXPRESSION_STATEMENT)) { return lastStatementTree.equals(((ExpressionStatementTree) last).expression()); } else if (last.is(Kind.TRY_STATEMENT)) { return isLastStatement(((TryStatementTree) last).finallyBlock(), lastStatementTree); } } return false; }
private void checkBlock(BlockTree blockTree) { BlockTree innerBlock = blockTree; while (innerBlock.body().size() == 1 && innerBlock.body().get(0).is(Tree.Kind.BLOCK)) { innerBlock = (BlockTree) innerBlock.body().get(0); } List<StatementTree> statementTreeList = innerBlock.body().stream() .filter(statementTree -> !statementTree.is(Tree.Kind.EMPTY_STATEMENT)) .collect(Collectors.toList()); if (isReturnTrueStatement(statementTreeList)) { reportIssue(statementTreeList.get(0), ISSUE_MESSAGE); } }
private static boolean isReturnBooleanLiteral(StatementTree statementTree) { if (statementTree.is(Kind.RETURN_STATEMENT)) { ExpressionTree expression = ((ReturnStatementTree) statementTree).expression(); return expression != null && expression.is(Tree.Kind.BOOLEAN_LITERAL); } return false; }
private void checkStatements(List<StatementTree> statements) { for (StatementTree statement : statements) { if (statement.is(Tree.Kind.BLOCK)) { context.reportIssue(this, ((BlockTree) statement).openBraceToken(), "Extract this nested code block into a method."); } } }
private static boolean onlyReturnLiteralsOrThrowException(MethodTree methodTree) { BlockTree block = methodTree.block(); if (block == null) { return false; } List<StatementTree> body = block.body(); if (body.size() != 1) { return false; } StatementTree singleStatement = body.get(0); return singleStatement.is(Tree.Kind.THROW_STATEMENT) || returnStatementWithLiteral(singleStatement); }
private static boolean hasOneReturnBoolean(@Nullable StatementTree statementTree) { if (statementTree == null) { return false; } if (statementTree.is(Kind.BLOCK)) { BlockTree block = (BlockTree) statementTree; return block.body().size() == 1 && isReturnBooleanLiteral(block.body().get(0)); } return isReturnBooleanLiteral(statementTree); }
private static boolean onlyRethrows(CatchTree catchTree) { List<StatementTree> catchBody = catchTree.block().body(); if (catchBody.size() == 1) { return catchBody.get(0).is(Tree.Kind.THROW_STATEMENT) && catchTree.parameter().symbol().usages().contains(((ThrowStatementTree) catchBody.get(0)).expression()); } return false; } }
private static boolean isLastStatement(MethodTree methodTree, MethodInvocationTree lastStatementTree) { BlockTree blockTree = methodTree.block(); if (blockTree != null && blockTree.body().stream().anyMatch(statement -> statement.is(Kind.TRY_STATEMENT) && isLastStatement(((TryStatementTree) statement).finallyBlock(), lastStatementTree))) { return true; } return isLastStatement(blockTree, lastStatementTree); }
private static boolean isUselessSuperCall(MethodTree methodTree) { ExpressionTree callToSuper = null; StatementTree statementTree = methodTree.block().body().get(0); if (returnsVoid(methodTree) && statementTree.is(Tree.Kind.EXPRESSION_STATEMENT)) { callToSuper = ((ExpressionStatementTree) statementTree).expression(); } else if (statementTree.is(Tree.Kind.RETURN_STATEMENT)) { callToSuper = ((ReturnStatementTree) statementTree).expression(); } return callToSuper != null && isCallToSuper(methodTree, callToSuper) && sameVisibility(methodTree.symbol(), ((MethodInvocationTree) callToSuper).symbol()); }
private static boolean isLoggingMethod(StatementTree statementTree, IdentifierTree exceptionIdentifier) { if (!statementTree.is(Tree.Kind.EXPRESSION_STATEMENT)) { return false; } ExpressionTree expression = ((ExpressionStatementTree) statementTree).expression(); if (expression.is(Tree.Kind.METHOD_INVOCATION)) { MethodInvocationTree mit = (MethodInvocationTree) expression; return LOGGING_METHODS.anyMatch(mit) && isExceptionUsed(exceptionIdentifier, mit); } return false; }
@Override public void visitNode(Tree tree) { CaseGroupTree cgt = (CaseGroupTree) tree; for (StatementTree statementTree : cgt.body()) { if (statementTree.is(LABELED_STATEMENT)) { IdentifierTree label = ((LabeledStatementTree) statementTree).label(); reportIssue(label, "Remove this misleading \"" + label.name() + "\" label."); } } } }
private void checkForReport(StatementTree statement, Tree startTree, Tree endTree, String name) { if (!(statement.is(Tree.Kind.BLOCK) || statement.firstToken().column() > startTree.firstToken().column())) { context.reportIssue(this, startTree, endTree, "Use indentation to denote the code conditionally executed by this \"" + name + "\".", Collections.singletonList(new JavaFileScannerContext.Location("", statement)), null); } } }
private static boolean isUnsupportedCloneOverride(MethodTree methodTree) { if (isOneStatementMethod(methodTree)) { StatementTree statementTree = methodTree.block().body().get(0); return statementTree.is(Tree.Kind.THROW_STATEMENT) && ((ThrowStatementTree) statementTree).expression().symbolType().is("java.lang.CloneNotSupportedException"); } return false; }
@Override public void visitNode(Tree tree) { IfStatementTree treeIfStmt = (IfStatementTree) tree; StatementTree elseStmt = treeIfStmt.elseStatement(); if (elseStmt != null && elseStmt.is(Tree.Kind.IF_STATEMENT)) { IfStatementTree ifStmt = (IfStatementTree) elseStmt; if (ifStmt.elseStatement() == null) { reportIssue(treeIfStmt.elseKeyword(), ifStmt.ifKeyword(), "\"if ... else if\" constructs should end with \"else\" clauses."); } } } }
private void addLineOfCloseBrace(SyntaxToken startToken, StatementTree tree) { if (tree.is(Tree.Kind.BLOCK)) { SyntaxToken closeBraceToken = ((BlockTree) tree).closeBraceToken(); if (startToken.line() != closeBraceToken.line() && !statementsPerLine.contains(closeBraceToken.line())) { addLine(closeBraceToken); } } }
private void visit(IfStatementTree tree) { scan(tree.condition()); scan(tree.thenStatement()); StatementTree elseStatementTree = tree.elseStatement(); if (elseStatementTree != null && elseStatementTree.is(Tree.Kind.IF_STATEMENT)) { visit((IfStatementTree) elseStatementTree); } else { scan(elseStatementTree); } }