private static boolean isDuplicate(ListTree<TypeTree> superInterfaces, TypeTree currentInterfaceTree) { for (TypeTree superInterfaceTree : superInterfaces) { if (!currentInterfaceTree.equals(superInterfaceTree) && SyntacticEquivalence.areEquivalent(currentInterfaceTree, superInterfaceTree)) { return true; } } return false; }
/** * @return true, if nodes are syntactically equivalent */ public static boolean areEquivalent(@Nullable Tree leftNode, @Nullable Tree rightNode) { return areEquivalent((JavaTree) leftNode, (JavaTree) rightNode); }
/** * @return true, if nodes are syntactically equivalent */ public static boolean areEquivalent(@Nullable Tree leftNode, @Nullable Tree rightNode) { return areEquivalent((JavaTree) leftNode, (JavaTree) rightNode); }
/** * @return true, if nodes are syntactically equivalent */ public static boolean areEquivalent(@Nullable Tree leftNode, @Nullable Tree rightNode) { return areEquivalent((JavaTree) leftNode, (JavaTree) rightNode); }
/** * @return true, if nodes are syntactically equivalent */ public static boolean areEquivalent(@Nullable Tree leftNode, @Nullable Tree rightNode) { return areEquivalent((JavaTree) leftNode, (JavaTree) rightNode); }
private static boolean concatenateVariable(ExpressionTree variable, ExpressionTree operand) { if (operand.is(Tree.Kind.PLUS)) { return concatenateVariable(variable, (BinaryExpressionTree) operand); } return SyntacticEquivalence.areEquivalent(variable, operand); }
private static boolean nullCheckWithInstanceOf(ExpressionTree leftOp, ExpressionTree rightOp, Tree.Kind binaryExpressionKind, Tree.Kind expectedKind) { ExpressionTree binaryVariable = Optional.ofNullable(binaryExpressionVariable(leftOp)) .orElse(binaryExpressionVariable(rightOp)); if (binaryVariable == null || binaryExpressionKind != expectedKind) { return false; } ExpressionTree instanceofVariable = Optional.ofNullable(instanceofFound(rightOp, binaryExpressionKind)) .orElse(instanceofFound(leftOp, binaryExpressionKind)); return instanceofVariable != null && SyntacticEquivalence.areEquivalent(binaryVariable, instanceofVariable); }
private static boolean nullCheckWithInstanceOf(ExpressionTree leftOp, ExpressionTree rightOp, Tree.Kind binaryExpressionKind, Tree.Kind expectedKind) { ExpressionTree binaryVariable = Optional.ofNullable(binaryExpressionVariable(leftOp)) .orElse(binaryExpressionVariable(rightOp)); if (binaryVariable == null || binaryExpressionKind != expectedKind) { return false; } ExpressionTree instanceofVariable = Optional.ofNullable(instanceofFound(rightOp, binaryExpressionKind)) .orElse(instanceofFound(leftOp, binaryExpressionKind)); return instanceofVariable != null && SyntacticEquivalence.areEquivalent(binaryVariable, instanceofVariable); }
private boolean concatenateVariable(ExpressionTree variable, ExpressionTree operand) { if(operand.is(Tree.Kind.PLUS)) { return concatenateVariable(variable, (BinaryExpressionTree) operand); } return SyntacticEquivalence.areEquivalent(variable, operand); }
private void checkExtending(ClassTree classTree, TypeTree currentInterfaceTree) { for (TypeTree superInterfaceTree : classTree.superInterfaces()) { if (!currentInterfaceTree.equals(superInterfaceTree) && SyntacticEquivalence.areEquivalent(currentInterfaceTree, superInterfaceTree)) { addIssue(superInterfaceTree, String.format(ERROR_MESSAGE, extractInterfaceName(currentInterfaceTree))); } } }
private static boolean concatenateVariable(ExpressionTree variable, ExpressionTree operand) { if (operand.is(Tree.Kind.PLUS)) { return concatenateVariable(variable, (BinaryExpressionTree) operand); } return SyntacticEquivalence.areEquivalent(variable, operand); }
@Override public void visitNode(Tree tree) { List<CatchTree> catches = new ArrayList<>(); for (CatchTree catchTree : ((TryStatementTree) tree).catches()) { for (CatchTree catchTreeToBeCompared : catches) { if (SyntacticEquivalence.areEquivalent(catchTree.block(), catchTreeToBeCompared.block())) { reportIssue(catchTree, catchTreeToBeCompared); break; } } catches.add(catchTree); } }
private void checkForEachExpression(Tree forEachIterable, ExpressionTree expressionTree) { if (SyntacticEquivalence.areEquivalent(expressionTree, forEachIterable)) { addIssue(expressionTree, forEachIterable.firstToken().line()); } }
private void checkForEachExpression(Tree forEachIterable, ExpressionTree expressionTree) { if (SyntacticEquivalence.areEquivalent(expressionTree, forEachIterable)) { addIssue(expressionTree, forEachIterable.firstToken().line()); } }
public boolean areOperandEquivalent(ExpressionTree left, ExpressionTree right, Tree.Kind binaryKind) { if (SyntacticEquivalence.areEquivalent(left, right)) { return true; } // Check other operands if operator is symetric. if (SYMETRIC_OPERATORS.contains(binaryKind) && left.is(binaryKind)) { return areOperandEquivalent(((BinaryExpressionTree) left).leftOperand(), right, binaryKind) || areOperandEquivalent(((BinaryExpressionTree) left).rightOperand(), right, binaryKind); } return false; }
@Override public void visitNode(Tree tree) { AssignmentExpressionTree node = (AssignmentExpressionTree) tree; if (SyntacticEquivalence.areEquivalent(node.expression(), node.variable())) { reportIssue(node.operatorToken(), "Remove or correct this useless self-assignment."); } }
@Override public void visitNode(Tree tree) { AssignmentExpressionTree node = (AssignmentExpressionTree) tree; if (SyntacticEquivalence.areEquivalent(node.expression(), node.variable())) { reportIssue(node.operatorToken(), "Remove or correct this useless self-assignment."); } }
@Override public void visitAssignmentExpression(AssignmentExpressionTree tree) { //Check only = kind of assignements (not +=, *=, etc.) if (tree.is(Tree.Kind.ASSIGNMENT) && SyntacticEquivalence.areEquivalent(tree.expression(), tree.variable())) { context.addIssue(tree, this, "Remove or correct this useless self-assignment"); } super.visitAssignmentExpression(tree); } }
private void checkConditionalExpression(ConditionalExpressionTree node) { if (SyntacticEquivalence.areEquivalent(ExpressionUtils.skipParentheses(node.trueExpression()), ExpressionUtils.skipParentheses(node.falseExpression()))) { reportIssue(node.condition(), node.questionToken(), "This conditional operation returns the same value whether the condition is \"true\" or \"false\"."); } } }
private void checkConditionalExpression(ConditionalExpressionTree node) { if (SyntacticEquivalence.areEquivalent(ExpressionUtils.skipParentheses(node.trueExpression()), ExpressionUtils.skipParentheses(node.falseExpression()))) { reportIssue(node.condition(), node.questionToken(), "This conditional operation returns the same value whether the condition is \"true\" or \"false\"."); } } }