@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.");
}
}
