private static Optional<MethodInvocationTree> previousMITInChain(MethodInvocationTree mit) { ExpressionTree methodSelect = mit.methodSelect(); if (methodSelect.is(Tree.Kind.MEMBER_SELECT)) { ExpressionTree expression = ((MemberSelectExpressionTree) methodSelect).expression(); if (expression.is(Tree.Kind.METHOD_INVOCATION)) { MethodInvocationTree previousInvocation = (MethodInvocationTree) expression; return Optional.of(previousInvocation); } } return Optional.empty(); }
@Nullable private static AssignmentExpressionTree getInnerAssignmentExpression(ExpressionTree tree) { ExpressionTree expressionTree = ExpressionUtils.skipParentheses(tree); if (expressionTree.is(Kind.ASSIGNMENT)) { return (AssignmentExpressionTree) expressionTree; } return null; }
@CheckForNull private static MemberSelectExpressionTree getMemberSelect(MethodInvocationTree mit) { ExpressionTree methodSelect = mit.methodSelect(); if (!methodSelect.is(Tree.Kind.MEMBER_SELECT)) { return null; } return (MemberSelectExpressionTree) methodSelect; }
@CheckForNull private static Symbol invocationTarget(MethodInvocationTree mit) { ExpressionTree methodSelect = mit.methodSelect(); if (methodSelect.is(Tree.Kind.MEMBER_SELECT)) { ExpressionTree methodSelectExpression = ((MemberSelectExpressionTree) methodSelect).expression(); if (methodSelectExpression.is(Tree.Kind.IDENTIFIER)) { return ((IdentifierTree) methodSelectExpression).symbol(); } } return null; }
private void checkStore(ExpressionTree expression) { if (expression.is(Tree.Kind.IDENTIFIER)) { IdentifierTree identifierTree = (IdentifierTree) expression; if (!parametersStack.isEmpty() && parametersStack.peek().contains(identifierTree.symbol())) { context.reportIssue(this, identifierTree, "Store a copy of \"" + identifierTree.name() + "\"."); } } }
@CheckForNull private static ExpressionTree getPreparedStatementReference(MethodInvocationTree mit) { ExpressionTree methodSelect = mit.methodSelect(); if (methodSelect.is(Tree.Kind.MEMBER_SELECT)) { ExpressionTree expression = ((MemberSelectExpressionTree) methodSelect).expression(); if (expression.is(Tree.Kind.IDENTIFIER)) { Symbol referenceSymbol = ((IdentifierTree) expression).symbol(); return ReassignmentFinder.getClosestReassignmentOrDeclarationExpression(mit, referenceSymbol); } } return null; }
@Override public void visitMemberSelectExpression(MemberSelectExpressionTree tree) { if (tree.expression().is(Tree.Kind.IDENTIFIER) || tree.expression().is(Tree.Kind.MEMBER_SELECT)) { //Check only first identifier of a member select expression : in a.b.c we are only interested in a. scan(tree.expression()); } }
private static boolean isAlwaysFalseCondition(ExpressionTree expression) { if (expression.is(Tree.Kind.BOOLEAN_LITERAL)) { return BooleanUtils.isFalse(booleanLiteralValue(expression)); } if (expression.is(Tree.Kind.LOGICAL_COMPLEMENT)) { ExpressionTree subExpression = ((UnaryExpressionTree) expression).expression(); return BooleanUtils.isTrue(booleanLiteralValue(subExpression)); } return false; }
private static boolean isJsonTypeIdEnumValue(ExpressionTree tree, Set<String> values) { if (!isJsonTypeId(tree)) { return false; } String valueName; if (tree.is(Tree.Kind.MEMBER_SELECT)) { valueName = ((MemberSelectExpressionTree) tree).identifier().name(); } else { valueName = ((IdentifierTree) tree).name(); } return values.contains(valueName); }
private static boolean isSuperClone(MemberSelectExpressionTree tree) { return "clone".equals(tree.identifier().name()) && tree.expression().is(Kind.IDENTIFIER) && "super".equals(((IdentifierTree) tree.expression()).name()); }
@Override public void visitNode(Tree tree) { ExpressionTree expression = ExpressionUtils.skipParentheses(((UnaryExpressionTree) tree).expression()); if (expression.is( Tree.Kind.EQUAL_TO, Tree.Kind.NOT_EQUAL_TO, Tree.Kind.LESS_THAN, Tree.Kind.GREATER_THAN, Tree.Kind.LESS_THAN_OR_EQUAL_TO, Tree.Kind.GREATER_THAN_OR_EQUAL_TO)) { context.reportIssue(this, tree, "Use the opposite operator (\"" + OPERATORS.get(((BinaryExpressionTree) expression).operatorToken().text()) + "\") instead."); } }
@Override public void visitAssignmentExpression(AssignmentExpressionTree tree) { ExpressionTree variable = tree.variable(); if (variable.is(Tree.Kind.IDENTIFIER)) { IdentifierTree identifier = (IdentifierTree) variable; Symbol reference = identifier.symbol(); if (reference.isVariableSymbol() && variables.contains(reference)) { context.reportIssue(this, identifier, "Introduce a new variable instead of reusing the parameter \"" + identifier.name() + "\"."); } } }
private static boolean callSuperMethodWithSameName(MemberSelectExpressionTree mset, MethodTree methodTree) { return mset.expression().is(Tree.Kind.IDENTIFIER) && "super".equals(((IdentifierTree) mset.expression()).name()) && mset.identifier().name().equals(methodTree.simpleName().name()); }
@Override public void visitAssignmentExpression(AssignmentExpressionTree tree) { if (tree.variable().is(Tree.Kind.IDENTIFIER)) { checkIdentifier((IdentifierTree) tree.variable()); } super.visitAssignmentExpression(tree); }
@Override public void visitNode(Tree tree) { ParenthesizedTree parenthesizedTree = (ParenthesizedTree) tree; if (parenthesizedTree.expression().is(Kind.PARENTHESIZED_EXPRESSION)) { reportIssue(((ParenthesizedTree) parenthesizedTree.expression()).openParenToken(), "Remove these useless parentheses.", Collections.singletonList(new JavaFileScannerContext.Location("", parenthesizedTree.closeParenToken())), null); } }
@Override public void visitIfStatement(IfStatementTree tree) { super.visitIfStatement(tree); ExpressionTree condition = tree.condition(); if (condition.is(Tree.Kind.ASSIGNMENT) && EQUALITY_RELATIONAL_OPERATORS.contains(((AssignmentExpressionTree) condition).expression().kind())) { raiseIssue(((AssignmentExpressionTree) condition).operatorToken().line(), tree); } }
@Override public void visitVariable(VariableTree tree) { ExpressionTree initializer = tree.initializer(); if (initializer != null && initializer.is(Tree.Kind.STRING_LITERAL) && ModifiersUtils.hasModifier(tree.modifiers(), Modifier.STATIC) && ModifiersUtils.hasModifier(tree.modifiers(), Modifier.FINAL)) { constants.putIfAbsent(((LiteralTree) initializer).value(), tree); return; } super.visitVariable(tree); }
private static Type getMethodOwnerType(MethodInvocationTree methodSelectTree) { if (methodSelectTree.methodSelect().is(Tree.Kind.MEMBER_SELECT)) { return ((MemberSelectExpressionTree) methodSelectTree.methodSelect()).expression().symbolType(); } else { return methodSelectTree.symbol().owner().type(); } }
@Override protected void onMethodInvocationFound(MethodInvocationTree mit) { ExpressionTree expressionTree = mit.arguments().get(0); // For now ignore everything that is not a .class expression if (expressionTree.is(Tree.Kind.MEMBER_SELECT)) { Type symbolType = ((MemberSelectExpressionTree) expressionTree).expression().symbolType(); if (!symbolType.isUnknown() && isNotRuntimeAnnotation(symbolType)) { reportIssue(expressionTree, "\"@" + symbolType.name() + "\" is not available at runtime and cannot be seen with reflection."); } } }
private static String getNewlyCreatedClassName(MethodInvocationTree mit) { MemberSelectExpressionTree mset = (MemberSelectExpressionTree) mit.methodSelect(); if (mset.expression().is(Tree.Kind.NEW_CLASS)) { Tree classId = ((NewClassTree) mset.expression()).identifier(); if (classId.is(Tree.Kind.IDENTIFIER)) { return ((IdentifierTree) classId).name(); } else if (classId.is(Tree.Kind.MEMBER_SELECT)) { return ((MemberSelectExpressionTree) classId).identifier().name(); } } return ""; }