private Issue.Message[] secondaryMessages(List<UastNode> nodes) { return nodes.stream().skip(1).map(node -> new Issue.Message(node, "Duplication")).toArray(Issue.Message[]::new); } }
@Override public void visitNode(UastNode node) { Optional.of(node) .map(ParenthesizedLike::from) .map(ParenthesizedLike::expression) .map(ParenthesizedLike::from) .ifPresent(parentheses -> reportIssue( parentheses.leftParenthesis(), "Remove these useless parentheses.", new Issue.Message(parentheses.rightParenthesis()))); }
private void addSecondaryLocation(UastNode node, int increase) { if (secondaryLocations != null) { String message; if (increase == 1) { message = "+1"; } else { message = "+" + increase + " (incl " + (increase - 1) + " for nesting)"; } secondaryLocations.add(new Issue.Message(node, message)); } }
@Override public void visitNode(UastNode node) { if (node.is(UastNode.Kind.CLASS)) { functions.clear(); } if (node.is(FunctionLike.KIND)) { FunctionLike thisFunction = FunctionLike.from(node); if (thisFunction == null) { return; } if (thisFunction.body().getChildren(UastNode.Kind.STATEMENT).size() < 2) { return; } for (FunctionLike function : functions) { if (areEquivalent(thisFunction.body(), function.body()) && areEquivalent(thisFunction.parameters(), function.parameters()) && areEquivalent(thisFunction.resultList(), function.resultList())) { reportIssue(thisFunction.name(), "Function is identical with function on line " + function.node().firstToken().line + ".", new Issue.Message(function.name(), "Original implementation")); break; } } functions.add(thisFunction); } } }
@Override public void visitNode(UastNode node) { if (!hasElse(node)) { List<UastNode> bodyStatementChildren = node.getChildren(Kind.STATEMENT, Kind.BLOCK); if (bodyStatementChildren.size() == 1) { UastNode statementNode = bodyStatementChildren.get(0); if (statementNode.is(Kind.BLOCK)) { List<UastNode> nestedInBlockOptionalStatement = statementNode.getChildren(Kind.STATEMENT); if (nestedInBlockOptionalStatement.size() == 1) { statementNode = nestedInBlockOptionalStatement.get(0); } } if (statementNode.is(Kind.IF) && !hasElse(statementNode) && hasSimpleCondition(statementNode)) { reportIssue( getReportingLocationForIf(node), MESSAGE, new Issue.Message(getReportingLocationForIf(statementNode), "Nested \"if\" statement")); } } } }
protected final void reportIssue(UastNode node, String message) { context.reportIssue(new Issue(this, new Issue.Message(node, message), null)); }
public static Issue issueOnFile(Check check, String message) { return new Issue(check, new Message(null, message), null); }
public static Issue issueOnLine(Check check, int line, String message) { return new Issue(check, new Message(line, message), null); }
protected final void reportIssue(UastNode node, String message, Issue.Message... secondaryMessages) { context.reportIssue(new Issue(this, new Issue.Message(node, message), null, secondaryMessages)); }
protected final void reportIssue(UastNode from, UastNode to, String message, double effortToFix, Issue.Message... secondaryMessages) { context.reportIssue(new Issue(this, new Issue.Message(from, to, message), effortToFix, secondaryMessages)); }
protected final void reportIssue(UastNode from, UastNode to, String message, Issue.Message... secondaryMessages) { context.reportIssue(new Issue(this, new Issue.Message(from, to, message), null, secondaryMessages)); }
@Override public void visitNode(UastNode node) { SwitchLike switchLike = SwitchLike.from(node); int casesNb = switchLike.caseNodes().size(); if(casesNb > maximumCases) { Issue.Message[] secondaries = switchLike.caseNodes().stream().map(cn -> new Issue.Message(cn.getChild(UastNode.Kind.KEYWORD).orElse(cn), "+1")).toArray(Issue.Message[]::new); reportIssue(switchLike.switchKeyword(), String.format("Reduce the number of switch cases from %d to at most %d.", casesNb, maximumCases), secondaries); } }
private void reportIssue(UastNode duplicating, UastNode duplicated, String caseOrBranch) { Token firstToken = duplicated.firstToken(); if (firstToken != null) { int duplicatedBranchFirstLine = firstToken.line; reportIssue( duplicating, String.format(MESSAGE, caseOrBranch, caseOrBranch, duplicatedBranchFirstLine), new Issue.Message(duplicated, "Original")); } }
private void checkNesting(UastNode node) { if (nesting.size() == max) { Issue.Message[] secondary = nesting.stream() .map(n -> new Issue.Message(n.getChild(UastNode.Kind.KEYWORD).orElse(node), "Nesting +1")) .toArray(Issue.Message[]::new); reportIssue(node.getChild(UastNode.Kind.KEYWORD).orElse(node), "Refactor this code to not nest more than " + max + " control flow statements.", secondary); } } }
@Override public void visitNode(UastNode node) { BinaryExpressionLike binaryExpression = BinaryExpressionLike.from(node); if (binaryExpression != null && !isExcluded(binaryExpression) && SyntacticEquivalence.areEquivalent(binaryExpression.leftOperand(), binaryExpression.rightOperand())) { String operator = binaryExpression.operator().joinTokens(); reportIssue(binaryExpression.rightOperand(), "Correct one of the identical sub-expressions on both sides of operator \"" + operator + "\".", new Issue.Message(binaryExpression.leftOperand())); } }
private void checkConditions(UastNode condition, UastNode prevCondition) { UastNode.Token prevConditionToken = prevCondition.firstToken(); if (prevConditionToken != null && SyntacticEquivalence.areEquivalent(condition, prevCondition)) { int prevConditionLine = prevConditionToken.line; reportIssue(condition, "This condition is same as one already tested on line " + prevConditionLine + ".", new Issue.Message(prevCondition, "Original")); } } }
@Test void message_to_string() { Set<UastNode.Kind> noKind = Collections.emptySet(); List<UastNode> noChild = Collections.emptyList(); UastNode node1 = new UastNode(noKind, "", new UastNode.Token(42, 7, "{"), noChild); UastNode node2 = new UastNode(noKind, "", new UastNode.Token(54, 3, "}"), noChild); Issue.Message message1 = new Issue.Message(node1, node2, "a message"); assertThat(message1.toString()).isEqualTo("([42:7 {], [54:3 }]) a message"); Issue.Message message2 = new Issue.Message(node1, node2, null); assertThat(message2.toString()).isEqualTo("([42:7 {], [54:3 }])"); } }