/** * Same contract as method {@link #addIssue(Tree, String)}. */ public Optional<PreciseIssue> addUniqueIssue(Tree tree, String message, Tree... secondaryLocations) { Optional<PreciseIssue> issue = addUniqueIssue(tree, message); if (issue.isPresent()) { for (Tree location : secondaryLocations) { issue.get().secondary(location); } } return issue; }
@Override protected void conditionWithDeadCode(Tree condition, boolean isTruthy, Set<Tree> deadCode) { String result = isTruthy ? "true" : "false"; PreciseIssue preciseIssue = addIssue(condition, String.format(MESSAGE, result)); deadCode.forEach(deadCodeTree -> preciseIssue.secondary(deadCodeTree, "Never reached")); }
/** * Same contract as method {@link #addIssue(Tree, String)}. */ public Optional<PreciseIssue> addUniqueIssue(Tree tree, String message, IssueLocation... secondaryLocations) { Optional<PreciseIssue> issue = addUniqueIssue(tree, message); if (issue.isPresent()) { for (IssueLocation location : secondaryLocations) { issue.get().secondary(location); } } return issue; }
private void addIssue(List<StatementTree> statementsAtLine) { PreciseIssue issue = addIssue(statementsAtLine.get(1), MESSAGE); for (int i = 2; i < statementsAtLine.size(); i++) { issue.secondary(new IssueLocation(statementsAtLine.get(i))); } } }
private void addIssue(Tree expression, List<SyntaxToken> complexityOperators) { int complexity = complexityOperators.size(); String message = String.format(MESSAGE, complexity, max); PreciseIssue issue = addIssue(expression, message); for (SyntaxToken complexityOperator : complexityOperators) { issue.secondary(complexityOperator, "+1"); } issue.cost ((double) complexity - max); }
private void checkSuperInvokedOnlyOnce(MethodDeclarationTree tree, List<SuperTree> superTrees) { if (isConstructor(tree) && superTrees.size() > 1) { SuperTree firstSuper = superTrees.get(0); superTrees.stream() .skip(1) .forEach(s -> addIssue(s, MESSAGE_SUPER_INVOKED_ONCE).secondary(new IssueLocation(firstSuper))); } }
private void raiseIssue(IdentifierTree writeUsage, IdentifierTree identifierUsedInUpdateClause) { String message = String.format(MESSAGE, writeUsage.name()); addIssue(writeUsage, message) .secondary(identifierUsedInUpdateClause, SECONDARY_MESSAGE); } }
private void addIssue(Tree condition, ForLoopIncrement loopIncrement, String adjective) { String message = String.format(MESSAGE, loopIncrement.identifier.name(), adjective); addIssue(loopIncrement.incrementTree, message) .secondary(condition); }
private void leaveScopeAndCheckNumberOfJump(SyntaxToken loopKeyword) { List<Tree> jumps = jumpTargets.pop().jumps; int jumpStatementNumber = jumps.size(); if (jumpStatementNumber > 1) { PreciseIssue issue = addIssue(loopKeyword, MESSAGE).cost((double) jumpStatementNumber - 1); for (Tree jump : jumps) { issue.secondary(new IssueLocation(jump)); } } }
private void increaseAndCheckNestedLevel(SyntaxToken token) { if (stack.size() == getMaximumNestingLevel()) { PreciseIssue issue = addIssue(token, String.format(MESSAGE, getMaximumNestingLevel())); stack.forEach(t -> issue.secondary(t, "Nesting +1")); } stack.push(token); }
@Override public void endOfFile(ScriptTree scriptTree) { EqualityVisitor equalityVisitor = new EqualityVisitor(); equalityVisitor.scanTree(scriptTree); equalityVisitor.equalityExpressions .stream() .filter(equalityExpression -> !ignoredList.contains(equalityExpression)) .forEach(equalityExpression -> addIssue(equalityExpression.operatorToken(), equalityExpression.is(Kind.EQUAL_TO) ? "Replace \"==\" with \"===\"." : "Replace \"!=\" with \"!==\".") .secondary(equalityExpression.leftOperand()) .secondary(equalityExpression.rightOperand())); }
@Override public void visitScript(ScriptTree tree) { for (Symbol argumentsSymbol : getContext().getSymbolModel().getSymbols("arguments")) { if (argumentsSymbol.external() && !argumentsSymbol.usages().isEmpty()) { Iterator<Usage> usageIterator = argumentsSymbol.usages().iterator(); PreciseIssue preciseIssue = addIssue(usageIterator.next().identifierTree(), MESSAGE); while (usageIterator.hasNext()) { preciseIssue.secondary(usageIterator.next().identifierTree()); } } } } }
private void raiseIssue(FunctionTree tree, List<Tree> complexityTrees) { int complexity = complexityTrees.size(); String message = String.format(MESSAGE, complexity, maximumFunctionComplexityThreshold); IssueLocation primaryIssueLocation = new IssueLocation(tree.firstToken(), tree.parameterClause(), message); PreciseIssue issue = addIssue(new PreciseIssue(this, primaryIssueLocation)); for (Tree complexityTree : complexityTrees) { issue.secondary(complexityTree, "+1"); } issue.cost((double) complexity - maximumFunctionComplexityThreshold); }
@Override public void visitNode(Tree tree) { BinaryExpressionTree expression = (BinaryExpressionTree) tree; ExpressionTree nan = getNaN(expression); if (nan != null) { addIssue(nan, String.format(MESSAGE, expression.operatorToken().text())) .secondary(expression.operatorToken()); } }
private void checkIndentation(SyntaxToken conditionalFirstToken, StatementTree statement) { if (statement.is(Tree.Kind.BLOCK)) { return; } SyntaxToken firstStatementToken = statement.firstToken(); if (conditionalFirstToken.column() >= firstStatementToken.column()) { String message = String.format(MESSAGE, conditionalFirstToken.text()); addIssue(conditionalFirstToken, message) .secondary(firstStatementToken); } }
private void raiseIssuesOnDeclarations(Symbol symbol, String message, IdentifierTree shadowedDeclaration) { for (Usage usage : symbol.usages()) { if (usage.isDeclaration()) { addIssue(usage.identifierTree(), message).secondary(shadowedDeclaration); } } }
private void raiseIssue(ObjectLiteralTree tree, int begin, int end, String primaryMessage, String secondaryMessage) { PreciseIssue preciseIssue = addIssue(tree.openCurlyBraceToken(), primaryMessage); for (int i = begin; i < end; i++) { if (isShorthand(tree.properties().get(i))) { preciseIssue.secondary(tree.properties().get(i), secondaryMessage); } } }
@Override public void visitIfStatement(IfStatementTree tree) { if (tree.elseClause() == null) { IfStatementTree innerIfStatement = getCollapsibleIfStatement(tree.statement()); if (innerIfStatement != null) { IssueLocation primaryLocation = issueLocation(tree, MESSAGE); IssueLocation secondaryLocation = issueLocation(innerIfStatement, SECONDARY_MESSAGE); addIssue(new PreciseIssue(this, primaryLocation).secondary(secondaryLocation)); } } super.visitIfStatement(tree); }