@Override public void visitMethod(MethodTree tree) { int max; String partialMessage; if (tree.is(Tree.Kind.CONSTRUCTOR)) { max = constructorMax; partialMessage = "Constructor"; } else { max = maximum; partialMessage = "Method"; } int size = tree.parameters().size(); if (size > max) { context.addIssue( tree, this, partialMessage + " has " + size + " parameters, which is greater than " + max + " authorized."); } super.visitMethod(tree); }
@Override public void scanFile(JavaFileScannerContext context) { CompilationUnitTree tree = context.getTree(); if (tree.packageDeclaration() == null && tree.types().isEmpty()) { context.addIssue(context.getTree(), this, "This Java file is empty."); } }
@Override public void visitUnaryExpression(UnaryExpressionTree tree) { super.visitUnaryExpression(tree); if (isIncrementOrDecrement(tree)) { context.addIssue( tree, this, "Extract this increment or decrement operator into a dedicated statement."); } }
private void checkIdentifier(IdentifierTree identifierTree) { if (loopCounters.contains(identifierTree.name())) { context.addIssue( identifierTree, ruleKey, "Refactor the code in order to not assign to this loop counter from within the loop body."); } }
@Override public void visitLiteral(LiteralTree tree) { if (tree.value().length() > 3) { String temp = tree.value().substring(1, tree.value().length() - 1); if (pattern.matcher(temp).matches()) { context.addIssue(tree, this, String.format("Avoid using non-secure urls %s", temp)); } } super.visitLiteral(tree); }
@Override public void visitMethodInvocation(MethodInvocationTree mit) { super.visitMethodInvocation(mit); if (FILE_DELETE.matches(mit)) { checkAndAdvanceState(mit, State.CREATE_TMP_FILE, State.DELETE); } else if (FILE_MKDIR.matches(mit) && State.MKDIR.equals(checkAndAdvanceState(mit, State.DELETE, State.MKDIR))) { context.addIssue( mit, this, "Use \"Files.createTempDirectory\" or a library function to create this directory instead."); } }
@Override public void visitVariable(VariableTree tree) { // System.out.println("HAB: Bool? " + tree.type().symbolType() + // tree.type().symbolType().is("java.lang.Boolean") ); if ((tree.type().symbolType().is("boolean") || tree.type().symbolType().is("java.lang.Boolean")) && !pattern.matcher(tree.simpleName().name()).matches()) { context.addIssue( tree, this, "El nombre de las variables boleana debe iniciar con is seguido de Upper Pascal Case"); } super.visitVariable(tree); }
@Override public void visitMemberSelectExpression(MemberSelectExpressionTree tree) { String reference = ExpressionsHelper.concatenate(tree); if (!isExcluded(reference)) { int line = FirstSyntaxTokenFinder.firstSyntaxToken(tree).line(); if (!reportedLines.contains(line) && isSunClass(reference)) { context.addIssue( line, this, "Replace this usage of Sun classes by ones from the Java API."); reportedLines.add(line); } super.visitMemberSelectExpression(tree); } }
@Override public void visitSwitchStatement(SwitchStatementTree tree) { int count = 0; for (CaseGroupTree caseGroup : tree.cases()) { count += caseGroup.labels().size(); } if (count < 3) { context.addIssue( tree, ruleKey, "Replace this \"switch\" statement by \"if\" statements to increase readability."); } super.visitSwitchStatement(tree); }
@Override public void visitBinaryExpression(BinaryExpressionTree tree) { super.visitBinaryExpression(tree); if (tree.is(Tree.Kind.EQUAL_TO)) { Type leftOperandType = ((JavaTree.AbstractExpressionTree) tree.leftOperand()).getType(); Type rightOperandType = ((JavaTree.AbstractExpressionTree) tree.rightOperand()).getType(); if (leftOperandType == null || rightOperandType == null) { // FIXME null type should not happen. return; } if (!isNullComparison(leftOperandType, rightOperandType) && (isClass(leftOperandType) || isClass(rightOperandType))) { context.addIssue(tree, ruleKey, "Change this comparison to use the equals method."); } } }
@Override public void visitClass(ClassTree tree) { if (tree.is(Tree.Kind.CLASS) || tree.is(Tree.Kind.ENUM)) { for (Tree member : tree.members()) { if (member.is(Tree.Kind.VARIABLE) && isPublicStaticNotFinal((VariableTree) member)) { context.addIssue( member, this, "Make this \"public static " + ((VariableTree) member).simpleName() + "\" field final"); } } } super.visitClass(tree); }
@Override public void visitNewClass(NewClassTree tree) { if (TARGETED_CLASS.contains(getclassName(tree)) && tree.arguments().size() == 1) { ExpressionTree argument = tree.arguments().get(0); if (argument.is(Tree.Kind.CHAR_LITERAL)) { String character = ((LiteralTree) argument).value(); context.addIssue( tree, this, "Replace the constructor character parameter " + character + " with string parameter " + character.replace("'", "\"") + "."); } } }
@Override public void visitClass(ClassTree tree) { Symbol.TypeSymbol symbol = tree.symbol(); if (!tree.is(Tree.Kind.CLASS)) { return; } outerClasses.push(symbol); atLeastOneReference.push(Boolean.FALSE); scan(tree.members()); Boolean oneReference = atLeastOneReference.pop(); outerClasses.pop(); if (!symbol.isStatic() && !oneReference && !outerClasses.isEmpty() && isFirstParentStatic(outerClasses)) { String named = symbol.name().isEmpty() ? "named " : ""; context.addIssue(tree, this, "Make this a " + named + "\"static\" inner class."); } }