@Override public void visitReturnStatement(ReturnStatementTree tree) { checkExpression(returnType, tree.expression()); } }
@Override public void visitReturnStatement(ReturnStatementTree tree) { if (returnsIntegerMinValue(tree.expression())) { reportIssue(tree.expression(), "Simply return -1"); } }
@Override public void visitReturnStatement(ReturnStatementTree tree) { if (tree.expression().is(Kind.NULL_LITERAL)) { reportIssue(tree.expression(), "Null is returned but a \"Boolean\" is expected."); } }
private static boolean isReturnWithExpression(Tree tree) { if (tree.is(Tree.Kind.RETURN_STATEMENT)) { return ((ReturnStatementTree) tree).expression() != null; } return false; }
private static boolean isReturnTrueStatement(List<StatementTree> statementTreeList) { if (statementTreeList.size() == 1 && statementTreeList.get(0).is(Tree.Kind.RETURN_STATEMENT)) { ExpressionTree expression = ((ReturnStatementTree) statementTreeList.get(0)).expression(); return isTrueLiteral(expression); } return false; }
@Override public void visitReturnStatement(ReturnStatementTree tree) { ExpressionTree returnedExpression = tree.expression(); if (ExpressionUtils.isThis(returnedExpression)) { issueLocations.add(returnedExpression); } super.visitReturnStatement(tree); } }
@Override public void visitReturnStatement(ReturnStatementTree tree) { returnCount++; ExpressionTree returnExpression = tree.expression(); if (returnExpression != null && returnExpression.is(Tree.Kind.IDENTIFIER)) { returnsVariable = ((IdentifierTree) returnExpression).symbol().equals(variableSymbol); } }
private static Optional<String> getNullCheckFromReturn(Tree statement, LambdaExpressionTree lambda) { if (statement.is(Tree.Kind.RETURN_STATEMENT)) { return getNullCheck(((ReturnStatementTree) statement).expression(), lambda); } return Optional.empty(); }
@Override public void visitReturnStatement(ReturnStatementTree syntaxNode) { ExpressionTree expression = syntaxNode.expression(); if (expression != null) { closeResource(programState.peekValue()); } }
@Override public void visitReturnStatement(ReturnStatementTree tree) { ExpressionTree expression = tree.expression(); if(expression == null || !isIncrementOrDecrement(expression)) { scan(expression); } }
@Override public void visitReturnStatement(ReturnStatementTree returnStatement) { checkNull(returnStatement.expression()); super.visitReturnStatement(returnStatement); }
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; }
@Override public void visitReturnStatement(ReturnStatementTree tree) { ExpressionTree expression = tree.expression(); if (expression != null && !expression.symbolType().isUnknown()) { types.add(expression.symbolType()); } } }
private static boolean referencePrivateProperty(ReturnStatementTree returnStatementTree, ClassTree classTree) { ExpressionTree expression = returnStatementTree.expression(); String variableName = ""; if (expression == null) { return false; } else if (expression.is(Tree.Kind.IDENTIFIER)) { variableName = ((IdentifierTree) expression).name(); } return !StringUtils.isEmpty(variableName) && referencePrivateProperty(variableName, classTree); }
private void categorizeBasedOnConstructor(ReturnStatementTree returnStatement) { ExpressionTree returnedExpression = returnStatement.expression(); if (returnedExpression != null && returnedExpression.is(Tree.Kind.NEW_CLASS)) { NewClassTree newClass = (NewClassTree) returnedExpression; if (!isIgnoredCookieName(newClass.arguments()) && !isCompliantConstructorCall(newClass) && CLASSES.stream().anyMatch(newClass.symbolType()::isSubtypeOf)) { newClassToReport.add(newClass); } } }
@Override public void visitReturnStatement(ReturnStatementTree tree) { ExpressionTree expression = tree.expression(); if (expression.symbolType().is("byte")) { reportIssue(expression, "Convert this signed byte into an unsigned byte."); } }
private void buildReturnStatement(ReturnStatementTree returnStatement) { currentBlock = createUnconditionalJump(returnStatement, exitBlock(), currentBlock); ExpressionTree expression = returnStatement.expression(); if (expression != null) { build(expression); } }
private void addToUnsecuredReturns(ReturnStatementTree tree) { ExpressionTree returnedExpression = tree.expression(); if (returnedExpression != null && returnedExpression.is(Tree.Kind.NEW_CLASS) && isCookieClass(returnedExpression.symbolType()) && isSecureParamFalse((NewClassTree) returnedExpression)) { unsecuredReturns.add((NewClassTree) returnedExpression); } }
@Override public void visitReturnStatement(ReturnStatementTree tree) { super.visitReturnStatement(tree); ExpressionTree expressionTree = tree.expression(); if (expressionTree == null || !isMutableType(expressionTree)) { return; } checkReturnedExpression(expressionTree); }
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()); }