private static boolean hasLiteralInitializer(@Nullable ExpressionTree initializer) { return initializer != null && ExpressionUtils.skipParentheses(initializer).is( Tree.Kind.BOOLEAN_LITERAL, Tree.Kind.CHAR_LITERAL, Tree.Kind.DOUBLE_LITERAL, Tree.Kind.FLOAT_LITERAL, Tree.Kind.INT_LITERAL, Tree.Kind.LONG_LITERAL, Tree.Kind.NULL_LITERAL, Tree.Kind.STRING_LITERAL); } }
private static IdentifierTree getIdentifier(ExpressionTree tree) { ExpressionTree nonNullOperand = ExpressionUtils.skipParentheses(tree); if (nonNullOperand.is(Tree.Kind.IDENTIFIER)) { return (IdentifierTree) nonNullOperand; } return null; }
private ExpressionTree skipChainedAssignments(ExpressionTree expressionTree) { ExpressionTree tree = ExpressionUtils.skipParentheses(expressionTree); while (tree instanceof AssignmentExpressionTree) { AssignmentExpressionTree assignmentExpressionTree = (AssignmentExpressionTree) tree; scan(assignmentExpressionTree.variable()); tree = ExpressionUtils.skipParentheses(assignmentExpressionTree.expression()); } return tree; }
public IdentifierTree argumentToIdentifier(ExpressionTree expr) { if (expr.is(Tree.Kind.IDENTIFIER)) { return (IdentifierTree) ExpressionUtils.skipParentheses(expr); } else if (expr.is(Tree.Kind.MEMBER_SELECT)) { return (IdentifierTree) ExpressionUtils.skipParentheses(((MemberSelectExpressionTree) expr).identifier()); } else { return null; } }
private Stream<BinaryExpressionTree> flattenLogicalExpression(ExpressionTree expression) { if (expression.is(CONDITIONAL_AND, CONDITIONAL_OR)) { ignored.add(expression); BinaryExpressionTree binaryExpr = (BinaryExpressionTree) expression; ExpressionTree left = ExpressionUtils.skipParentheses(binaryExpr.leftOperand()); ExpressionTree right = ExpressionUtils.skipParentheses(binaryExpr.rightOperand()); return Stream.concat(Stream.concat(flattenLogicalExpression(left), Stream.of(binaryExpr)), flattenLogicalExpression(right)); } return Stream.empty(); }
private static boolean isHardcodedURI(ExpressionTree expr) { ExpressionTree newExpr = ExpressionUtils.skipParentheses(expr); if (!newExpr.is(Tree.Kind.STRING_LITERAL)) { return false; } String stringLiteral = LiteralUtils.trimQuotes(((LiteralTree) newExpr).value()); return URI_PATTERN.matcher(stringLiteral).find(); }
/** * Required for accurate reporting. * If condition is && or || expression, then return its right operand. */ private static ExpressionTree cleanupCondition(ExpressionTree condition) { ExpressionTree cleanedUpCondition = ExpressionUtils.skipParentheses(condition); if (cleanedUpCondition.is(Tree.Kind.CONDITIONAL_AND, Tree.Kind.CONDITIONAL_OR)) { cleanedUpCondition = cleanupCondition(((BinaryExpressionTree) cleanedUpCondition).rightOperand()); } return cleanedUpCondition; }
@CheckForNull private static IdentifierTree getVariableIdentifier(AssignmentExpressionTree tree) { ExpressionTree variable = ExpressionUtils.skipParentheses(tree.variable()); if (variable.is(Tree.Kind.IDENTIFIER)) { return (IdentifierTree) variable; } else if (variable.is(Tree.Kind.MEMBER_SELECT)) { return ((MemberSelectExpressionTree) variable).identifier(); } // ignore assignments in arrays return null; }
@Override public void visitAssignmentExpression(AssignmentExpressionTree tree) { ExpressionTree lhs = ExpressionUtils.skipParentheses(tree.variable()); if (lhs.is(Tree.Kind.IDENTIFIER)) { Symbol symbol = ((IdentifierTree) lhs).symbol(); if (isLocalVariable(symbol)) { assignedLocalVars.add(symbol); } super.visitAssignmentExpression(tree); } } }
@Override public void visitExpressionStatement(ExpressionStatementTree tree) { ExpressionTree expressionTree = ExpressionUtils.skipParentheses(tree.expression()); expressionTree = skipChainedAssignments(expressionTree); scan(expressionTree); }
/** * Checks of is the given tree is a {@link MemberSelectExpressionTree} which is selecting with <code>this</code> or <code>super</code> * @param tree The tree to check. * @return true when the tree is a select on <code>this</code> or <code>super</code> * @see #isSelectOnThisOrSuper(MemberSelectExpressionTree) */ public static boolean isSelectOnThisOrSuper(AssignmentExpressionTree tree) { ExpressionTree variable = ExpressionUtils.skipParentheses(tree.variable()); return variable.is(Tree.Kind.MEMBER_SELECT) && isSelectOnThisOrSuper((MemberSelectExpressionTree) variable); }
private void checkForEach(Map<Symbol, Integer> forEachSymbols, @Nullable Tree previousIterable, ForEachStatement item) { ExpressionTree expressionTree = ExpressionUtils.skipParentheses(item.expression()); if (expressionTree.is(Tree.Kind.IDENTIFIER)) { checkForEachIdentifier(forEachSymbols, (IdentifierTree) expressionTree); } else if (previousIterable != null) { checkForEachExpression(previousIterable, expressionTree); } }
private boolean isGetClassOnArgument(ExpressionTree tree) { ExpressionTree expressionTree = ExpressionUtils.skipParentheses(tree); return expressionTree.is(Tree.Kind.METHOD_INVOCATION) && GETCLASS_MATCHER.matches((MethodInvocationTree) expressionTree) && isInvocationOnArgument((MethodInvocationTree) expressionTree); }
private static boolean isTrueLiteral(Tree tree) { if (tree.is(Tree.Kind.PARENTHESIZED_EXPRESSION) || tree.is(Tree.Kind.BOOLEAN_LITERAL)) { ExpressionTree expression = ExpressionUtils.skipParentheses((ExpressionTree) tree); return LiteralUtils.isTrue(expression); } return false; } }
private void checkConditionalExpression(ConditionalExpressionTree node) { if (SyntacticEquivalence.areEquivalent(ExpressionUtils.skipParentheses(node.trueExpression()), ExpressionUtils.skipParentheses(node.falseExpression()))) { reportIssue(node.condition(), node.questionToken(), "This conditional operation returns the same value whether the condition is \"true\" or \"false\"."); } } }
private void handlePostfixExpression(Set<Symbol> out, UnaryExpressionTree element) { ExpressionTree expression = ExpressionUtils.skipParentheses(element.expression()); if (expression.is(Tree.Kind.IDENTIFIER)) { Symbol symbol = ((IdentifierTree) expression).symbol(); if (isLocalVariable(symbol) && !out.contains(symbol)) { createIssue(element, symbol); } } }
private static boolean isNullLiteral(ExpressionTree lastArgument) { ExpressionTree arg = ExpressionUtils.skipParentheses(lastArgument); return arg.is(Tree.Kind.NULL_LITERAL) || (arg.is(Tree.Kind.TYPE_CAST) && isNullLiteral(((TypeCastTree) arg).expression())); }
private void checkIdentifier(ExpressionTree expression) { ExpressionTree expr = ExpressionUtils.skipParentheses(expression); if (expr.is(Tree.Kind.IDENTIFIER)) { addSymbol((IdentifierTree) expr); } else if (expr.is(Tree.Kind.MEMBER_SELECT)) { addSymbol(((MemberSelectExpressionTree) expr).identifier()); } }
private static boolean isConcatenation(AssignmentExpressionTree tree) { if (tree.is(Tree.Kind.ASSIGNMENT)) { ExpressionTree expressionTree = ExpressionUtils.skipParentheses(tree.expression()); return expressionTree.is(Tree.Kind.PLUS) && concatenateVariable(tree.variable(), (BinaryExpressionTree) expressionTree); } return tree.is(Tree.Kind.PLUS_ASSIGNMENT); }
private void checkNewMap(ExpressionTree given, boolean useEnumKey) { ExpressionTree expression = ExpressionUtils.skipParentheses(given); if (expression.is(Tree.Kind.NEW_CLASS)) { NewClassTree newClassTree = (NewClassTree) expression; if (isUnorderedMap(newClassTree.symbolType()) && (useEnumKey || hasEnumKey(newClassTree.identifier().symbolType()))) { addIssue(newClassTree); } } }