private static boolean containsDefaultCase(List<CaseLabelTree> labels) { for (CaseLabelTree caseLabel : labels) { if ("default".equals(caseLabel.caseOrDefaultKeyword().text())) { return true; } } return false; }
private static String getMessage(SyntaxToken expressionFirstToken, AssignmentExpressionTree aeTree) { if (isSingleNegationAssignment(expressionFirstToken, aeTree)) { return "Add a space between \"=\" and \"!\" to avoid confusion."; } return "Was \"" + expressionFirstToken.text() + "=\" meant instead?"; }
protected static boolean hasDefaultClause(SwitchStatementTree switchStatement) { return switchStatement.cases().stream() .flatMap(caseGroupTree -> caseGroupTree.labels().stream()) .anyMatch(caseLabelTree -> caseLabelTree.caseOrDefaultKeyword().text().equals("default")); }
private boolean returnsPrimitive(String primitive) { if (returnType != null) { return returnType.is(Tree.Kind.PRIMITIVE_TYPE) && primitive.equals(((PrimitiveTypeTree) returnType).keyword().text()); } return false; }
@Override public void visitVariable(VariableTree tree) { SyntaxToken endToken = tree.endToken(); if (endToken != null && ";".equals(endToken.text())) { addLine(endToken); } }
@Override public void visitCaseLabel(CaseLabelTree tree) { if (!DEFAULT_KEYWORD.equals(tree.caseOrDefaultKeyword().text())) { // default keyword does not count in complexity blame.add(tree.firstToken()); } super.visitCaseLabel(tree); }
private static boolean isAlignedWith(SyntaxToken operatorToken, Tree other) { SyntaxToken otherOperator = operatorToken(other); return otherOperator.text().equals(operatorToken.text()) && operatorToken.column() == otherOperator.column() // less than 2 lines distance && Math.abs(operatorToken.line() - otherOperator.line()) < 2; }
private static boolean isVoid(MethodTree methodTree) { TypeTree typeTree = methodTree.returnType(); return typeTree.is(Tree.Kind.PRIMITIVE_TYPE) && "void".equals(((PrimitiveTypeTree) typeTree).keyword().text()); } }
private static boolean isFinalizeMethodMember(MethodTree methodTree) { Tree returnType = methodTree.returnType(); boolean returnVoid = returnType != null && returnType.is(Tree.Kind.PRIMITIVE_TYPE) && "void".equals(((PrimitiveTypeTree) returnType).keyword().text()); return returnVoid && "finalize".equals(methodTree.simpleName().name()); }
private static boolean isFinalize(MethodTree methodTree) { if ("finalize".equals(methodTree.simpleName().name())) { Tree returnType = methodTree.returnType(); if (returnType != null && returnType.is(Tree.Kind.PRIMITIVE_TYPE)) { return "void".equals(((PrimitiveTypeTree) returnType).keyword().text()); } } return false; } }
private static boolean isSetter(MethodTree methodTree) { TypeTree returnType = methodTree.returnType(); BlockTree block = methodTree.block(); boolean returnsVoid = returnType.is(Tree.Kind.PRIMITIVE_TYPE) && "void".equals(((PrimitiveTypeTree) returnType).keyword().text()); boolean hasAtLeastOneStatement = block == null || !block.body().isEmpty(); return methodTree.simpleName().name().startsWith("set") && methodTree.parameters().size() == 1 && returnsVoid && hasAtLeastOneStatement; } }
@Override public void visitNode(Tree tree) { ExpressionTree expression = ExpressionUtils.skipParentheses(((UnaryExpressionTree) tree).expression()); if (expression.is( Tree.Kind.EQUAL_TO, Tree.Kind.NOT_EQUAL_TO, Tree.Kind.LESS_THAN, Tree.Kind.GREATER_THAN, Tree.Kind.LESS_THAN_OR_EQUAL_TO, Tree.Kind.GREATER_THAN_OR_EQUAL_TO)) { context.reportIssue(this, tree, "Use the opposite operator (\"" + OPERATORS.get(((BinaryExpressionTree) expression).operatorToken().text()) + "\") instead."); } }
@Override protected void checkTokenPosition(SyntaxToken syntaxToken, BlockTree previousBlock) { if (syntaxToken.line() != previousBlock.closeBraceToken().line()) { reportIssue(syntaxToken, "Move this \"" + syntaxToken.text() + "\" on the same line that the previous closing curly brace."); } } }
private static AnalyzerMessage.TextSpan textSpanBetween(SyntaxToken firstSyntaxToken, SyntaxToken lastSyntaxToken) { AnalyzerMessage.TextSpan location = new AnalyzerMessage.TextSpan( firstSyntaxToken.line(), firstSyntaxToken.column(), lastSyntaxToken.line(), lastSyntaxToken.column() + lastSyntaxToken.text().length() ); Preconditions.checkState(!location.isEmpty(), "Invalid issue location: Text span is empty when trying reporting on (l:%s, c:%s).", firstSyntaxToken.line(), firstSyntaxToken.column()); return location; }
private void checkVariable(VariableTree varTree) { int line = varTree.simpleName().identifierToken().line(); if (varSameDeclaration || lastVarLine == line) { reportIssue(varTree.simpleName(), String.format("Declare \"%s\" on a separate line.", varTree.simpleName().name())); } varSameDeclaration = ",".equals(varTree.endToken().text()); lastVarLine = line; } }
private void highlight(Tree from, Tree to, TypeOfText typeOfText) { SyntaxToken firstToken = from.firstToken(); SyntaxToken lastToken = to.lastToken(); highlighting.highlight(firstToken.line(), firstToken.column(), lastToken.line(), lastToken.column() + lastToken.text().length(), typeOfText); }
@Override public void visitPrimitiveType(PrimitiveTypeTree tree) { Resolve.Env primitiveEnv = env; if (env == null) { primitiveEnv = semanticModel.getEnv(tree); } registerType(tree, resolve.findIdent(primitiveEnv, tree.keyword().text(), JavaSymbol.TYP).type()); }
@Override public void visitWhileStatement(WhileStatementTree tree) { super.visitWhileStatement(tree); checkForReport(tree.statement(), tree.whileKeyword(), tree.closeParenToken(), tree.whileKeyword().text()); }
@Override public void visitForStatement(ForStatementTree tree) { super.visitForStatement(tree); checkForReport(tree.statement(), tree.forKeyword(), tree.closeParenToken(), tree.forKeyword().text()); }
@Override public void visitForEachStatement(ForEachStatement tree) { super.visitForEachStatement(tree); checkForReport(tree.statement(), tree.forKeyword(), tree.closeParenToken(), tree.forKeyword().text()); }