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

@Override
public void visitAssignmentExpression(AssignmentExpressionTree tree) {
    if (isExpressionAMethodInvocation(tree) && isVariableAnIdentifier(tree)) {
        final MethodInvocationTree methodInvocation = (MethodInvocationTree) tree.expression();
        final IdentifierTree identifier = (IdentifierTree) tree.variable();
        if (isManuallyCreatedResourceResolver(methodInvocation)) {
            resourceResolvers.add((VariableTree) identifier.symbol().declaration());
        } else if (isResourceResolver(methodInvocation) && methodInvocation.methodSelect().is(Kind.IDENTIFIER)) {
            MethodTree methodDeclaration = getMethodTree(methodInvocation);
            // variable 'methodDeclaration' can be null in case when method declaration isn't within the same file.
            if (methodDeclaration != null && isManuallyCreatedResourceResolver(methodDeclaration)) {
                resourceResolvers.add((VariableTree) getDeclaration(identifier));
            }
        }
    }
    super.visitAssignmentExpression(tree);
}
 

@Override
public void visitMethodInvocation(MethodInvocationTree tree) {
    // Method invocation from right to left
    if (isFindMethod(tree) && (slingQueryWasNotUsed() || isThisANewSlingQuery())) {
        slingQueries.replace(currentSlingQueryVariableName, SlingQueryStates.FIND_USED_WITHOUT_STRATEGY);
    } else if (isSearchStrategyMethod(tree)) {
        slingQueries.replace(currentSlingQueryVariableName, SlingQueryStates.STRATEGY_USED);
        ignoreIssues = true;
    }
    if (DOLLAR_SIGN.equals(tree.methodSelect().firstToken().text()) && isDollarCase()) {
        context.reportIssue(this, tree, RULE_MESSAGE);
    } else if (isFindMethod(tree)) {
        findMethodUsed = true;
    } else if (isSearchStrategyMethod(tree)) {
        searchStrategyMethodUsed = true;
    }
    super.visitMethodInvocation(tree);
}
 

@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 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 visitMethodInvocation(MethodInvocationTree tree) {
	ExpressionTree methodSelect = tree.methodSelect();
	if (!methodSelect.is(Tree.Kind.IDENTIFIER)) {
		// not interested in simple method invocations, we are targeting usage of method parameters
		scan(methodSelect);
	}
	scan(tree.typeArguments());
	scan(tree.arguments());
}
 

void checkMethodInvocationLocators(MethodInvocationTree tree, LocatorStrategyCheckType locatorStrategyCheckType) {
    Map<String, String> locatorsInMethodInvocationTree = getLocatorValueMapInMethodInvocationTree(tree);

    for (Map.Entry<String, String> locator : locatorsInMethodInvocationTree.entrySet()) {
        checkLocator(tree, locator.getKey(), locator.getValue(), locatorStrategyCheckType);
    }
}
 

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 boolean isGetContentResourceUsedOnPage(VariableTree tree) {
    return tree.initializer() instanceof MethodInvocationTree &&
        !((MethodInvocationTree) tree.initializer()).symbol().isUnknown() &&
        isPage(((MethodInvocationTree) tree.initializer()).symbol().owner().type()
            .fullyQualifiedName()) &&
        GET_CONTENT_RESOURCE_METHOD.equals(((MethodInvocationTree) tree.initializer()).symbol().name());
}
 

@Override
public void visitAssignmentExpression(AssignmentExpressionTree tree) {
    if (isMethodInvocation(tree)) {
        MethodInvocationTree methodInvocation = (MethodInvocationTree) tree.expression();
        if (isManuallyCreatedSession(methodInvocation)) {
            IdentifierTree variable = (IdentifierTree) tree.variable();
            sessions.add((VariableTree) getDeclaration(variable));
        } else if (isSession(methodInvocation) && methodInvocation.methodSelect().is(Kind.IDENTIFIER)) {
            findSessionsCreatedInMethods(tree, methodInvocation);
        }
    }
    super.visitAssignmentExpression(tree);
}
 

private void chainedMethodsNullCheck(MethodInvocationTree tree) {
    if (tree.methodSelect() instanceof MemberSelectExpressionTree) {
        MemberSelectExpressionTree method = (MemberSelectExpressionTree) tree.methodSelect();
        if (method.expression() instanceof MethodInvocationTree) {
            MethodInvocationTree invocation = (MethodInvocationTree) method.expression();
            if (!invocation.symbol().isUnknown() &&
                isPage(invocation.symbol().owner().type().fullyQualifiedName()) &&
                isGetContentResourceUsedOnPage(invocation) &&
                !returnOccurredInsideEqualNullCheck) {
                context.reportIssue(this, tree, RULE_MESSAGE);
            }
        }
    }
}
 

private void externalLibraryNullChecks(MethodInvocationTree tree) {
    if (isNonNullUsed(tree)) {
        contentResources.replace(tree.arguments().get(METHOD_FIRST_ARGUMENT).toString(), true);
    } else if (isAllNonNullUsed(tree)) {
        tree.arguments().forEach(contentResource -> contentResources.replace(contentResource.toString(), true));
    } else if (insideIfStatement && isThisIsNullMethod(tree)) {
        insideEqualNullCheck = true;
    }
}
 

private void equalsNullCheck(MethodInvocationTree tree) {
    Boolean firstTokenText = contentResources.getOrDefault(tree.firstToken().text(), true);
    if (Boolean.FALSE.equals(firstTokenText) &&
        !returnOccurredInsideEqualNullCheck) {
        context.reportIssue(this, tree, RULE_MESSAGE);
    }
}
 

@Override
public void visitAssignmentExpression(AssignmentExpressionTree tree) {
    if (isMethodInvocation(tree) && getDeclaration((IdentifierTree) tree.variable()).equals(declarationOfReturnedVariable)) {
        MethodInvocationTree methodInvocation = (MethodInvocationTree) tree.expression();
        if (isManuallyCreatedSession(methodInvocation)) {
            this.createdManually = true;
        } else {
            CheckIfSessionCreatedManually sessionCreatedManually = new CheckIfSessionCreatedManually();
            getMethodTree(methodInvocation).accept(sessionCreatedManually);
            this.createdManually = sessionCreatedManually.isCreatedManually();
        }
    }
    super.visitAssignmentExpression(tree);
}
 

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

@Override
public void visitMethodInvocation(MethodInvocationTree tree) {
    externalLibraryNullChecks(tree);
    equalsNullCheck(tree);
    chainedMethodsNullCheck(tree);
    super.visitMethodInvocation(tree);
}
 

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);
        }
    }
}
 

@Override
public void visitAssignmentExpression(AssignmentExpressionTree tree) {
    if (isExpressionAMethodInvocation(tree) && variableIsEqualToReturnedVariableIn(tree)) {
        MethodInvocationTree methodInvocation = (MethodInvocationTree) tree.expression();
        if (isManuallyCreatedResourceResolver(methodInvocation)) {
            this.createdManually = true;
        } else {
            CheckIfRRCreatedManually rrCreatedManually = new CheckIfRRCreatedManually();
            getMethodTree(methodInvocation).accept(rrCreatedManually);
            this.createdManually = rrCreatedManually.isCreatedManually();
        }
    }
    super.visitAssignmentExpression(tree);
}
 

@Override
public void visitVariable(VariableTree tree) {
    if (isAMethodInvocation(tree) && variableIsEqualToReturnedVariableIn(tree)) {
        MethodInvocationTree methodInvocation = (MethodInvocationTree) tree.initializer();
        if (isManuallyCreatedResourceResolver(methodInvocation)) {
            this.createdManually = true;
        } else {
            CheckIfRRCreatedManually rrCreatedManually = new CheckIfRRCreatedManually();
            getMethodTree(methodInvocation).accept(rrCreatedManually);
            this.createdManually = rrCreatedManually.isCreatedManually();
        }
    }
    super.visitVariable(tree);
}
 

@Override
public void visitMethodInvocation(MethodInvocationTree tree) {
	ExpressionTree methodSelect = tree.methodSelect();
	if (!methodSelect.is(Tree.Kind.IDENTIFIER)) {
		// not interested in simple method invocations, we are targeting usage of method parameters
		scan(methodSelect);
	}
	scan(tree.typeArguments());
	scan(tree.arguments());
}
 

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

    if (methodInvocationIsAssertion(tree)) {
        context.reportIssue(this, tree, "Should not use assertions in non-test classes.");
    }
}
 

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();
}
 

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

    if (methodInvocationIsPartOfWebDriverPackage(tree)) {
        context.reportIssue(this, tree, "Should not use WebDriver commands in Test classes.");
    }
}
 

public static Map<String, String> getLocatorValueMapInMethodInvocationTree(MethodInvocationTree tree) {
    Map<String, String> methodInvocationLocatorValueMap = new HashMap<>();

    if (methodInvocationIsElementFinder(tree) && !tree.arguments().isEmpty()) {
        String locatorStrategy = getIdentifier(tree).name();
        String locatorValue = ((LiteralTree) tree.arguments().get(0)).value().replace("\"", "");

        methodInvocationLocatorValueMap.put(locatorStrategy, locatorValue);
    }

    return methodInvocationLocatorValueMap;
}
 

public static boolean methodInvocationIsPartOfWebDriverPackage(MethodInvocationTree methodInvocationTree) {
    if (getIdentifier(methodInvocationTree).symbol().isUnknown()) {
        return false;
    }

    String fullyQualifiedName = methodInvocationTree.symbol().owner().type().fullyQualifiedName();

    return isPartOfWebDriverPackage(fullyQualifiedName);
}
 

private static boolean methodInvocationIsElementFinder(MethodInvocationTree methodInvocationTree) {
    if (getIdentifier(methodInvocationTree).symbol().isUnknown()) {
        return false;
    }

    String methodName = getIdentifier(methodInvocationTree).name();
    String ownerName = getIdentifier(methodInvocationTree).symbol().owner().name();

    return (methodName.matches(FIND_ELEMENT_METHOD_REGEX) || ownerName.equals(BY_OBJECT_NAME)) &&
        methodInvocationIsPartOfWebDriverPackage(methodInvocationTree);
}
 

public static boolean methodInvocationIsAssertion(MethodInvocationTree methodInvocationTree) {
    if (getIdentifier(methodInvocationTree).symbol().isUnknown()) {
        return false;
    }
    String methodName = getIdentifier(methodInvocationTree).name();

    String fullyQualifiedName = methodInvocationTree.symbol().owner().type().fullyQualifiedName();

    return methodIsAssertion(methodName) && isPartOfAssertionPackage(fullyQualifiedName);
}
 

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

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 boolean isGetContentResourceUsedOnPage(MethodInvocationTree tree) {
    return GET_CONTENT_RESOURCE_METHOD.equals(tree.methodSelect().lastToken().text());
}
 

private boolean isGetContentResourceUsedOnResource(AssignmentExpressionTree tree) {
    return isResource(tree) &&
        tree.expression() instanceof MethodInvocationTree &&
        GET_CONTENT_RESOURCE_METHOD.equals(((MethodInvocationTree) tree.expression()).symbol().name());
}