@Override protected void onMethodInvocationFound(MethodInvocationTree mit) { Type symbolType = mit.arguments().get(0).symbolType(); if (!(symbolType.is("long") || symbolType.is("java.lang.Long"))) { reportIssue(MethodsHelper.methodName(mit), "Remove this \"Double.longBitsToDouble\" call."); } }
@Override public void visitMethodInvocation(MethodInvocationTree syntaxNode) { final ExpressionTree methodSelect = syntaxNode.methodSelect(); if (isClosingResource(syntaxNode.symbol())) { if (methodSelect.is(Tree.Kind.MEMBER_SELECT)) { final ExpressionTree targetExpression = ((MemberSelectExpressionTree) methodSelect).expression(); if (targetExpression.is(Tree.Kind.IDENTIFIER)) { final IdentifierTree identifier = (IdentifierTree) targetExpression; programState = closeResource(programState, programState.getValue(identifier.symbol())); } else { programState = closeResource(programState, programState.peekValue()); } } } else if (syntaxNode.methodSelect().is(Tree.Kind.MEMBER_SELECT) && isOpeningResultSet(syntaxNode.symbol())) { final SymbolicValue value = getTargetValue(syntaxNode); constraintManager.setValueFactory(new WrappedValueFactory(value)); } else if (isClosingResultSets(syntaxNode.symbol())) { if (methodSelect.is(Tree.Kind.MEMBER_SELECT)) { final SymbolicValue value = getTargetValue(syntaxNode); closeResultSetsRelatedTo(value); } } else { closeArguments(syntaxNode.arguments(), 1); } }
private void buildMethodInvocation(MethodInvocationTree tree) { MethodInvocationTree mit = tree; currentBlock.elements.add(mit); build(mit.methodSelect()); for (ExpressionTree arg : Lists.reverse(mit.arguments())) { build(arg); } }
private void checkMethodInvocationArguments( MethodInvocationTree methodInvocationTree, List<Type> parametersTypes) { List<ExpressionTree> arguments = methodInvocationTree.arguments(); int position = 0; for (Type paramType : parametersTypes) { if (arguments.size() > position) { checkExpression(arguments.get(position), paramType); } position++; } }
@Test public void ignore_assignation_after_starting_point_same_line() throws Exception { String code = newCode("int foo() {", " int b = 0;", " doSomething(b); b = 1;", "}"); List<StatementTree> statements = methodBody(code); Tree expectedVariableDeclaration = initializerFromVariableDeclarationStatement(statements.get(0)); MethodInvocationTree startingPoint = (MethodInvocationTree) ((ExpressionStatementTree) statements.get(1)).expression(); Symbol searchedVariable = ((IdentifierTree) startingPoint.arguments().get(0)).symbol(); assertThatLastReassignmentsOfVariableIsEqualTo( searchedVariable, startingPoint, expectedVariableDeclaration); }
private static boolean isEqualsMethod(MethodInvocationTree syntaxNode) { if (syntaxNode.arguments().size() == 1) { ExpressionTree methodSelect = syntaxNode.methodSelect(); if (methodSelect.is(Tree.Kind.MEMBER_SELECT)) { MemberSelectExpressionTree expression = (MemberSelectExpressionTree) methodSelect; if ("equals".equals(expression.identifier().name()) && syntaxNode.symbol().isMethodSymbol()) { Symbol.MethodSymbol symbol = (Symbol.MethodSymbol) syntaxNode.symbol(); return symbol.parameterTypes().get(0).is("java.lang.Object"); } } } return false; }
@Override protected void onMethodInvocationFound(MethodInvocationTree tree) { Type argumentType = tree.arguments().get(0).symbolType(); Type collectionType = getMethodOwner(tree); // can be null when using raw types Type collectionParameterType = getTypeParameter(collectionType); if (collectionParameterType != null && !collectionParameterType.isUnknown() && !isArgumentCompatible(argumentType, collectionParameterType)) { addIssue( tree, MessageFormat.format( "A \"{0}<{1}>\" cannot contain a \"{2}\"", collectionType, collectionParameterType, argumentType)); } }
private void checkForBoxing(ExpressionTree expression) { if (expression.is(Tree.Kind.NEW_CLASS)) { NewClassTree newClassTree = (NewClassTree) expression; Symbol.TypeSymbol classSymbol = wrapperClassSymbol(newClassTree); if (classSymbol != null) { ExpressionTree boxingArg = newClassTree.arguments().get(0); if (boxingArg.symbolType().isPrimitive()) { addBoxingIssue(newClassTree, classSymbol, boxingArg); } } } else if (expression.is(Tree.Kind.METHOD_INVOCATION)) { MethodInvocationTree methodInvocationTree = (MethodInvocationTree) expression; if (isValueOfInvocation(methodInvocationTree)) { ExpressionTree boxingArg = methodInvocationTree.arguments().get(0); addBoxingIssue(expression, methodInvocationTree.symbol().owner(), boxingArg); } } }
private void visitMethodInvocationTree(MethodInvocationTree methodInvocationTree) { if (isValueOfInvocation(methodInvocationTree)) { checkForUnboxing(methodInvocationTree.arguments().get(0)); } else if (isUnboxingMethodInvocation(methodInvocationTree)) { ExpressionTree methodSelect = methodInvocationTree.methodSelect(); if (methodSelect.is(Tree.Kind.MEMBER_SELECT)) { MemberSelectExpressionTree memberSelectExpressionTree = (MemberSelectExpressionTree) methodSelect; checkForBoxing(memberSelectExpressionTree.expression()); } } else { Symbol symbol = methodInvocationTree.symbol(); if (symbol.isMethodSymbol()) { List<Type> parametersTypes = ((Symbol.MethodSymbol) symbol).parameterTypes(); checkMethodInvocationArguments(methodInvocationTree, parametersTypes); } } }
@Override public void visitNode(Tree tree) { MethodInvocationTree methodTree = (MethodInvocationTree) tree; boolean isHibernateCall = isHibernateCall(methodTree); if (isHibernateCall || isExecuteQueryOrPrepareStatement(methodTree) || isEntityManagerCreateNativeQuery(methodTree)) { // We want to check the argument for the three methods. ExpressionTree arg = methodTree.arguments().get(0); parameterName = ""; if (isDynamicString(methodTree, arg, null, true)) { String message = "\"" + parameterName + "\" is provided externally to the method and not sanitized before use."; if (isHibernateCall) { message = "Use Hibernate's parameter binding instead of concatenation."; } reportIssue(MethodsHelper.methodName(methodTree), message); } } }
private static boolean isExecuteQueryOrPrepareStatement(MethodInvocationTree methodTree) { return !methodTree.arguments().isEmpty() && (STATEMENT_EXECUTE_QUERY_MATCHER.matches(methodTree) || CONNECTION_MATCHERS.anyMatch(methodTree)); }