org.sonar.plugins.java.api.tree.Tree Java Examples

@Override
public void visitMethodInvocation(MethodInvocationTree tree) {
    JavaFileScannerContext context = getContext();

    if (!tree.methodSelect().is(Tree.Kind.IDENTIFIER)) {
        MemberSelectExpressionTree memberSelectExpressionTree = ((MemberSelectExpressionTree) tree.methodSelect());

        String methodName = memberSelectExpressionTree.identifier().name();
        String fullyQualifiedNameOfExpression = memberSelectExpressionTree.expression().symbolType()
            .fullyQualifiedName();

        if (IMPLICITLY_WAIT_METHOD_NAME.equals(methodName) &&
            isPartOfWebDriverPackage(fullyQualifiedNameOfExpression)) {
            context.reportIssue(this, tree, "Avoid using implicit wait, use explicit wait instead");
        }
    }
}
 

@Override
public void visitNode(Tree tree) {
	if (!hasSemantic()) {
		return;
	}
	switch (tree.kind()) {
	case METHOD:
		checkIfNativeMethod((MethodTree) tree);
		break;
	case CLASS:
		classes.add((ClassTree) tree);
		break;
	case IMPORT:// VJ
		checkIfLombokClass((ImportTree) tree);
		break;
	case EXPRESSION_STATEMENT:
		collectAssignment(((ExpressionStatementTree) tree).expression());
		break;
	case IDENTIFIER:
		collectUnknownIdentifier((IdentifierTree) tree);
		break;
	default:
		throw new IllegalStateException("Unexpected subscribed tree.");
	}
}
 

@Override
public void visitLiteral(LiteralTree tree) {
	if (tree.is(Tree.Kind.STRING_LITERAL)) {
		String value = LiteralUtils.trimQuotes(tree.value());
		IP.reset(value);
		if (IP.matches()) {
			String ip = IP.group("ip");

			// VJ:ADD 忽略127.0.0.1
			if ("127.0.0.1".equals(ip)) {
				return;
			}
			// VJ:END
			if (areAllBelow256(Splitter.on('.').split(ip))) {
				context.reportIssue(this, tree, "Make this IP \"" + ip + "\" address configurable.");
			}
		}
	}
}
 

@Override
public void visitNode(Tree tree) {
	ClassTree classTree = (ClassTree) tree;
	for (Tree member : classTree.members()) {
		if (member.is(Tree.Kind.VARIABLE) && hasSemantic()) {
			VariableTree variableTree = (VariableTree) member;
			Type symbolType = variableTree.type().symbolType();
			 if (isConstantType(symbolType) && (classTree.is(Tree.Kind.INTERFACE, Tree.Kind.ANNOTATION_TYPE) || isStaticFinal(variableTree))) {
		          checkName(variableTree);
		     }
		}
		// VJ Remove //
		// else if (member.is(Tree.Kind.ENUM_CONSTANT)) {
		// checkName((VariableTree) member);
		// }
	}
}
 

@Override
public void visitNode(Tree tree) {
	if (!hasSemantic()) {
		return;
	}
	MethodTree methodTree = (MethodTree) tree;
	if (methodTree.block() == null || !isIncluded(methodTree)) {
		return;
	}
	List<IdentifierTree> unused = Lists.newArrayList();
	for (VariableTree var : methodTree.parameters()) {
		Symbol symbol = var.symbol();
		if (symbol.usages().isEmpty() && !symbol.metadata().isAnnotatedWith(AUTHORIZED_ANNOTATION)
				&& !isStrutsActionParameter(var)) {
			unused.add(var.simpleName());
		}
	}
	Set<String> unresolvedIdentifierNames = unresolvedIdentifierNames(methodTree.block());
	// kill the noise regarding unresolved identifiers, and remove the one with matching names from the list of
	// unused
	unused = unused.stream().filter(id -> !unresolvedIdentifierNames.contains(id.name()))
			.collect(Collectors.toList());
	if (!unused.isEmpty()) {
		reportUnusedParameters(unused);
	}
}
 

@Override
public void visitNode(Tree tree) {
	if (!hasSemantic()) {
		return;
	}
	switch (tree.kind()) {
	case METHOD:
		checkIfNativeMethod((MethodTree) tree);
		break;
	case CLASS:
		classes.add((ClassTree) tree);
		break;
	case IMPORT:// VJ
		checkIfLombokClass((ImportTree) tree);
		break;
	case EXPRESSION_STATEMENT:
		collectAssignment(((ExpressionStatementTree) tree).expression());
		break;
	case IDENTIFIER:
		collectUnknownIdentifier((IdentifierTree) tree);
		break;
	default:
		throw new IllegalStateException("Unexpected subscribed tree.");
	}
}
 

protected boolean checkIfLongSession(MethodTree method) {
    List<AnnotationTree> annotations = method.modifiers().annotations();
    for (AnnotationTree annotationTree : annotations) {
        if (annotationTree.annotationType().is(Tree.Kind.IDENTIFIER)) {
            IdentifierTree idf = (IdentifierTree) annotationTree.annotationType();
            if (idf.name().equals(ACTIVATE)) {
                collectLongSessionOpened(method);
                return true;
            } else if (idf.name().equals(DEACTIVATE)) {
                collectLongSessionClosed(method);
                return true;
            }
        }
    }
    return false;
}
 

@Override
public void visitLiteral(LiteralTree tree) {
	if (tree.is(Tree.Kind.STRING_LITERAL)) {
		String value = LiteralUtils.trimQuotes(tree.value());
		IP.reset(value);
		if (IP.matches()) {
			String ip = IP.group("ip");

			// VJ:ADD 忽略127.0.0.1
			if ("127.0.0.1".equals(ip)) {
				return;
			}
			// VJ:END
			if (areAllBelow256(Splitter.on('.').split(ip))) {
				context.reportIssue(this, tree, "Make this IP \"" + ip + "\" address configurable.");
			}
		}
	}
}
 

protected boolean checkIfLongResourceResolver(MethodTree method) {
    List<AnnotationTree> annotations = method.modifiers().annotations();
    for (AnnotationTree annotationTree : annotations) {
        if (annotationTree.annotationType().is(Tree.Kind.IDENTIFIER)) {
            IdentifierTree idf = (IdentifierTree) annotationTree.annotationType();
            if (idf.name().equals(ACTIVATE)) {
                collectLongResourceResolverOpened(method);
                return true;
            } else if (idf.name().equals(DEACTIVATE)) {
                collectLongResourceResolverClosed(method);
                return true;
            }
        }
    }
    return false;
}
 

@Override
public void visitMethodInvocation(MethodInvocationTree tree) {
    JavaFileScannerContext context = getContext();

    if (!tree.methodSelect().is(Tree.Kind.IDENTIFIER)) {
        MemberSelectExpressionTree memberSelectExpressionTree = ((MemberSelectExpressionTree) tree.methodSelect());

        String methodName = memberSelectExpressionTree.identifier().name();
        String fullyQualifiedNameOfExpression = memberSelectExpressionTree.expression().symbolType()
            .fullyQualifiedName();

        if (SLEEP_METHOD_NAME.equals(methodName) &&
            fullyQualifiedNameOfExpression.equals(THREAD)) {
            context.reportIssue(this, tree, "Avoid using hard coded sleeps, use explicit wait instead");
        }
    }
}
 

@Override
public void visitNode(Tree tree) {
	if (!hasSemantic()) {
		return;
	}
	MethodTree methodTree = (MethodTree) tree;
	if (methodTree.block() == null || !isIncluded(methodTree)) {
		return;
	}
	List<IdentifierTree> unused = Lists.newArrayList();
	for (VariableTree var : methodTree.parameters()) {
		Symbol symbol = var.symbol();
		if (symbol.usages().isEmpty() && !symbol.metadata().isAnnotatedWith(AUTHORIZED_ANNOTATION)
				&& !isStrutsActionParameter(var)) {
			unused.add(var.simpleName());
		}
	}
	Set<String> unresolvedIdentifierNames = unresolvedIdentifierNames(methodTree.block());
	// kill the noise regarding unresolved identifiers, and remove the one with matching names from the list of
	// unused
	unused = unused.stream().filter(id -> !unresolvedIdentifierNames.contains(id.name()))
			.collect(Collectors.toList());
	if (!unused.isEmpty()) {
		reportUnusedParameters(unused);
	}
}
 

@Override
public void visitNode(Tree tree) {
	ClassTree classTree = (ClassTree) tree;
	for (Tree member : classTree.members()) {
		if (member.is(Tree.Kind.VARIABLE) && hasSemantic()) {
			VariableTree variableTree = (VariableTree) member;
			Type symbolType = variableTree.type().symbolType();
			 if (isConstantType(symbolType) && (classTree.is(Tree.Kind.INTERFACE, Tree.Kind.ANNOTATION_TYPE) || isStaticFinal(variableTree))) {
		          checkName(variableTree);
		     }
		}
		// VJ Remove //
		// else if (member.is(Tree.Kind.ENUM_CONSTANT)) {
		// checkName((VariableTree) member);
		// }
	}
}
 

private void checkInvocation(Tree tree, MethodMatcher invocationMatcher) {
    if (tree.is(Kind.METHOD_INVOCATION)) {
        MethodInvocationTree methodInvocationTree = (MethodInvocationTree) tree;
        if (invocationMatcher.matches(methodInvocationTree)) {
            this.onMethodInvocationFound(methodInvocationTree);
        }
    }
}
 

private void handleSmellAnnotation(final AnnotationTree annotationTree) {
    String message = "";
    Integer minutes = 0;
    SmellType type = null;
    final Arguments arguments = annotationTree.arguments();
    for (final ExpressionTree expressionTree : arguments) {
        if (expressionTree.is(Tree.Kind.ASSIGNMENT)) {
            final AssignmentExpressionTree aet = (AssignmentExpressionTree) expressionTree;
            final String variable = ((IdentifierTree) aet.variable()).name();
            switch (variable) {
                case "minutes":
                    minutes += Integer.valueOf(((LiteralTree) aet.expression()).value());
                    LOGGER.debug("{} = {}", variable, minutes);
                    break;
                case "reason":
                    message = extractMessage(aet.expression());
                    LOGGER.debug("{} = {}", variable, message);
                    break;
                case "type":
                    type = SmellType.valueOf(((MemberSelectExpressionTree) aet.expression()).identifier()
                        .name());
                    break;
                default:
                    break;
            }
        }
    }
    if (smellType().equals(type)) {
        final Matcher matcher = PATTERN.matcher(message);
        if (matcher.matches()) {
            message = matcher.group(1);
        }
        reportIssue(annotationTree, message, new ArrayList<JavaFileScannerContext.Location>(), minutes);
    }
}
 

private static boolean isMethodIdentifier(IdentifierTree identifier) {
	Tree parent = identifier.parent();
	while (parent != null && !parent.is(Tree.Kind.METHOD_INVOCATION, Tree.Kind.METHOD_REFERENCE)) {
		parent = parent.parent();
	}
	if (parent == null) {
		return false;
	}
	if (parent.is(Tree.Kind.METHOD_INVOCATION)) {
		return identifier.equals(methodName((MethodInvocationTree) parent));
	} else {
		return identifier.equals(((MethodReferenceTree) parent).method());
	}
}
 

private void addAssignment(ExpressionTree tree) {
	ExpressionTree variable = ExpressionUtils.skipParentheses(tree);
	if (variable.is(Tree.Kind.IDENTIFIER)) {
		addAssignment((IdentifierTree) variable);
	} else if (variable.is(Tree.Kind.MEMBER_SELECT)) {
		addAssignment(((MemberSelectExpressionTree) variable).identifier());
	}
}
 

@Override
public void visitNode(final Tree tree) {
    final AnnotationTree annotationTree = (AnnotationTree) tree;
    final Type symbolType = annotationTree.annotationType()
        .symbolType();
    if (symbolType.is("com.qualinsight.plugins.sonarqube.smell.api.annotation.Smell")) {
        handleSmellAnnotation(annotationTree);
    }
}
 

@Override
public void visitNode(Tree tree) {
    Kind i = tree.kind();
    if (i == Kind.METHOD) {
        SynchronizedMethodVisitor visitor = new SynchronizedMethodVisitor(this);
        tree.accept(visitor);
    } else if (i == Kind.SYNCHRONIZED_STATEMENT) {
        reportIssue(tree, MESSAGE);
    }
    super.visitNode(tree);
}
 

private void reportIssueIfStrategyNotUsed(Tree tree, String variableName) {
    if (findWithoutStrategyWasUsedOnSlingQuery()) {
        context.reportIssue(this, tree, RULE_MESSAGE);
        slingQueries.put(variableName, SlingQueryStates.ISSUE_RETURNED);
        ignoreIssues = true;
    }
}
 

@Override
public void visitReturnStatement(ReturnStatementTree tree) {
    if (tree.expression() != null && tree.expression().is(Kind.IDENTIFIER)) {
        IdentifierTree identifier = (IdentifierTree) tree.expression();
        Tree declaration = getDeclaration(identifier);
        if (sessions.contains(declaration)) {
            sessions.remove(declaration);
        }
    }
    super.visitReturnStatement(tree);
}
 

private static IdentifierTree getIdentifier(MethodInvocationTree methodInvocationTree) {
    // methodSelect can only be the Tree.Kind.IDENTIFIER or the Tree.Kind.MEMBER_SELECT
    if (methodInvocationTree.methodSelect().is(Tree.Kind.IDENTIFIER)) {
        return (IdentifierTree) methodInvocationTree.methodSelect();
    }
    return ((MemberSelectExpressionTree) methodInvocationTree.methodSelect()).identifier();
}
 

private void checkMember(Tree member) {
    boolean isVariableField = member.is(Kind.VARIABLE);
    if (isVariableField) {
        VariableTree variableField = (VariableTree) member;
        String name = variableField.type().symbolType().fullyQualifiedName();
        if (NON_THREAD_SAFE_TYPES.contains(name)) {
            context.reportIssue(this, member, String.format(RULE_MESSAGE, name));
        }
    }
}
 

private void checkIfMapVariableIsModified(List<IdentifierTree> usagesOfMVM) {
    for (IdentifierTree modifiableValueMapUsageIdentifier : usagesOfMVM) {
        Tree usageOfMVM = modifiableValueMapUsageIdentifier.parent();
        if (usageOfMVM != null) {
            if (usageOfMVM.is(Tree.Kind.ARGUMENTS)) {
                visitMethodWithMVM(modifiableValueMapUsageIdentifier, usageOfMVM);
            } else if (usageOfMVM.is(Tree.Kind.MEMBER_SELECT) && isSomeoneCallingMutableMethodsOnMap((MemberSelectExpressionTree) usageOfMVM)) {
                isModified = true;
                break;
            }
        }
    }
}
 

private void visitMethodWithMVM(IdentifierTree modifiableValueMapUsageIdentifier, Tree usageOfMVM) {
    int argumentNumber = ((Arguments) usageOfMVM).indexOf(modifiableValueMapUsageIdentifier);
    MethodInvocationTree methodInvocationWithMVM = (MethodInvocationTree) usageOfMVM.parent();
    if (methodInvocationWithMVM != null) {
        MethodTree methodWithMVM = (MethodTree) methodInvocationWithMVM.symbol().declaration();
        if (methodWithMVM != null && methodWithMVM.is(Tree.Kind.METHOD)) {
            MethodWithMVMVisitor methodWithMVMVisitor = new MethodWithMVMVisitor(this, argumentNumber);
            methodWithMVM.accept(methodWithMVMVisitor);
        }
    }
}
 

private boolean isOptionalDefaultValue(Arguments arguments) {
    boolean optionalIsDefaultValue = false;
    for (ExpressionTree argument : arguments) {
        if (argument.is(Tree.Kind.ASSIGNMENT)) {
            AssignmentExpressionTree assignment = (AssignmentExpressionTree) argument;
            if (isDefaultInjectionStrategyAssignment(assignment)) {
                optionalIsDefaultValue = isOptionalStrategyValue(assignment);
            }
        }
    }
    return optionalIsDefaultValue;
}
 

private boolean isAssignmentToName(ExpressionTree expression) {
    boolean result = false;
    if (expression.is(Tree.Kind.ASSIGNMENT)) {
        AssignmentExpressionTree assignment = (AssignmentExpressionTree) expression;
        result = NAME.equals(((IdentifierTree) assignment.variable()).name());
    }
    return result;
}
 

@Override
public void visitNode(Tree stringLiteral) {
    String literalValue = removeQuotes(((LiteralTree) stringLiteral).value());
    if (ConstantsChecker.isConstant(literalValue)) {
        String message = ConstantsChecker.getMessageForConstant(literalValue);
        reportIssue(stringLiteral, String.format("Use constant %s instead of hardcoded value.", message));
    }
    super.visitNode(stringLiteral);
}
 

@Override
public void visitReturnStatement(ReturnStatementTree tree) {
    if (tree.expression() != null && tree.expression().is(Kind.IDENTIFIER)) {
        IdentifierTree identifier = (IdentifierTree) tree.expression();
        Tree declaration = identifier.symbol().declaration();
        if (resourceResolvers.contains(declaration)) {
            resourceResolvers.remove(declaration);
        }
    }
    super.visitReturnStatement(tree);
}
 

public static List<AnnotationTree> getAnnotationTrees(ClassTree tree) {
    List<AnnotationTree> annotationTrees = new ArrayList<>();
    List<Tree> members = tree.members();

    for (Tree member : members) {
        if (METHOD_KIND.equals(member.kind().toString())) {
            annotationTrees.addAll(((MethodTree) member).modifiers().annotations());
        }
    }

    return annotationTrees;
}
 

private static String fullQualifiedName(Tree tree) {
	if (tree.is(Tree.Kind.IDENTIFIER)) {
		return ((IdentifierTree) tree).name();
	} else if (tree.is(Tree.Kind.MEMBER_SELECT)) {
		MemberSelectExpressionTree m = (MemberSelectExpressionTree) tree;
		return fullQualifiedName(m.expression()) + "." + m.identifier().name();
	}
	throw new UnsupportedOperationException(String.format("Kind/Class '%s' not supported", tree.getClass()));
}