private static final Set<BinaryOp> NEGATABLE_OPS = EnumSet.of(EQ, NE, GT, LT, GE, LE);

public SimplifyBooleanReturnsRule() {

super(ASTReturnStatement.class);

}

@Override

public Object visit(ASTReturnStatement node, Object data) {

ASTExpression expr = node.getExpr();

if (expr == null

|| !expr.getTypeMirror().isPrimitive(PrimitiveTypeKind.BOOLEAN)

|| !isThenBranchOfSomeIf(node)) {

return null;

}

checkIf(node.ancestors(ASTIfStatement.class).firstOrThrow(), asCtx(data), expr);

return null;

}

// Only explore the then branch. If we explore the else, then we'll report twice.

// In the case if .. else, both branches need to be symmetric anyway.

private boolean isThenBranchOfSomeIf(ASTReturnStatement node) {

if (node.getParent() instanceof ASTIfStatement) {

return node.getIndexInParent() == 1;

}

return node.getParent() instanceof ASTBlock

&& ((ASTBlock) node.getParent()).size() == 1

&& node.getParent().getParent() instanceof ASTIfStatement

&& node.getParent().getIndexInParent() == 1;

}

private void checkIf(ASTIfStatement node, RuleContext data, ASTExpression thenExpr) {

// that's the case: if..then..return; return;

ASTExpression elseExpr = getElseExpr(node);

if (elseExpr == null) {

return;

}

if (isBooleanLiteral(thenExpr) || isBooleanLiteral(elseExpr)) {

String fix = needsToBeReportedWhenOneBranchIsBoolean(node.getCondition(), thenExpr, elseExpr);

if (fix != null) {

data.addViolation(node, fix);

}

} else if (areComplements(thenExpr, elseExpr)) {

// if (foo) return !a;

// else return a;

data.addViolation(node, "return {condition};");

}

}

/**

private String needsToBeReportedWhenOneBranchIsBoolean(ASTExpression condition,

ASTExpression thenExpr,

ASTExpression elseExpr) {

// at least one of these is true

boolean thenFalse = isBooleanLiteral(thenExpr, false);

boolean thenTrue = isBooleanLiteral(thenExpr, true);

boolean elseTrue = isBooleanLiteral(elseExpr, true);

boolean elseFalse = isBooleanLiteral(elseExpr, false);

assert thenFalse || elseFalse || thenTrue || elseTrue

: "expected boolean branch";

if (isBooleanLiteral(thenExpr) && isBooleanLiteral(elseExpr)) {

// both are boolean

if (thenTrue && elseFalse) {

return "return {condition};";

} else if (thenFalse && elseTrue) {

return "return !{condition};";

} else if (thenTrue) { // both are true

return "return true;";

} else { // both are false

return "return false;";

}

}

BinaryOp op = thenFalse || elseFalse ? CONDITIONAL_AND : CONDITIONAL_OR;

// the branch that is not a literal, if both are literals, prefers elseExpr

ASTExpression branch = thenFalse || thenTrue ? elseExpr : thenExpr;

boolean conditionNegated = thenFalse || elseTrue;

// from the above logic it is guaranteed that exactly one of the four booleans is true

String conditionNegation = conditionNegated ? "!" : "";

String operator = thenTrue || elseTrue ? "||" : "&&";

String branchChoice = thenTrue || thenFalse ? "{elseBranch}" : "{thenBranch}";

boolean conditionNeedsParens = (conditionNegated && needsNewParensWhenNegating(condition))

|| needsParensUnderInfix(condition, op);

boolean branchNeedsParens = needsParensUnderInfix(branch, op);

if (conditionNeedsParens || branchNeedsParens) {

return null;

}

return "return " + conditionNegation + "{condition} " + operator + " "

+ branchChoice + ";";

}

private static boolean needsNewParensWhenNegating(ASTExpression e) {

if (e instanceof ASTPrimaryExpression

|| e instanceof ASTCastExpression

// parenthesized expressions are primary

|| e.isParenthesized()

// == -> !=

|| isInfixExprWithOperator(e, NEGATABLE_OPS)

// !! ->

|| JavaAstUtils.isBooleanNegation(e)) {

return false;

} else if (isInfixExprWithOperator(e, CONDITIONAL_OR)

|| isInfixExprWithOperator(e, CONDITIONAL_AND)) {

// negating these ops can be replaced with complement op

// and the negation pushed down branches using De Morgan's laws

ASTInfixExpression infix = (ASTInfixExpression) e;

return needsNewParensWhenNegating(infix.getLeftOperand())

|| needsNewParensWhenNegating(infix.getRightOperand());

}

return true;

}

private static boolean needsParensUnderInfix(ASTExpression e, BinaryOp op) {

// those nodes have greater precedence than infix

return !(e instanceof ASTPrimaryExpression

|| e instanceof ASTCastExpression

|| e instanceof ASTUnaryExpression

|| isInfixExprWithOperator(e, opsWithGreaterPrecedence(op)));

}

private @Nullable ASTExpression getReturnExpr(JavaNode node) {

if (node instanceof ASTReturnStatement) {

return ((ASTReturnStatement) node).getExpr();

} else if (node instanceof ASTBlock && ((ASTBlock) node).size() == 1) {

return getReturnExpr(((ASTBlock) node).get(0));

}

return null;

}

private @Nullable ASTExpression getElseExpr(ASTIfStatement node) {

return node.hasElse() ? getReturnExpr(node.getElseBranch())

: getReturnExpr(node.getNextSibling()); // may be followed immediately by return

}