private static int stringLiteralsNumber(List<ExpressionTree> operandList) { int literalsNum = 0; for (ExpressionTree operand : operandList) { if (operand.is(Kind.TEMPLATE_LITERAL, Kind.STRING_LITERAL)) { literalsNum++; } } return literalsNum; }
@CheckForNull private static ForLoopIncrement increment(ExpressionTree incrementTree, ExpressionTree expression, Double value) { if (expression.is(Tree.Kind.IDENTIFIER_REFERENCE)) { return new ForLoopIncrement(incrementTree, (IdentifierTree) expression, value); } return null; }
private static boolean propertyIsDeprecated(ExpressionTree property, List<String> deprecated) { if (property.is(Tree.Kind.PROPERTY_IDENTIFIER)) { IdentifierTree identifier = (IdentifierTree) property; return deprecated.contains(identifier.name()); } return false; } }
@Override public void visitNode(Tree tree) { ExpressionTree condition = ((ConditionalTree) tree).condition(); if (condition != null && condition.is(Kind.BOOLEAN_LITERAL, Kind.NUMERIC_LITERAL)) { ignoredLoopConditions.add((LiteralTree) condition); } } }
private static boolean atLeastOneArgumentNotLiteral(ArgumentListTree arguments) { for (ExpressionTree expressionTree : arguments.arguments()) { if (!expressionTree.is(Kind.STRING_LITERAL)) { return true; } } return false; }
private boolean isCallbackException() { for (ReturnStatementTree returnStatementTree : valuesPerReturn.keySet()) { ExpressionTree expression = returnStatementTree.expression(); if (expression != null && !expression.is(Kind.BOOLEAN_LITERAL)) { return false; } } return true; }
private static IdentifierTree callee(CallExpressionTree tree) { ExpressionTree callee = tree.callee(); while (callee.is(Tree.Kind.DOT_MEMBER_EXPRESSION)) { callee = ((MemberExpressionTree) callee).object(); } if (callee.is(Tree.Kind.IDENTIFIER_REFERENCE) && !callee.equals(tree.callee())) { return (IdentifierTree) callee; } return null; }
private static boolean isFunctionConstructorWithPossibleInjection(ExpressionTree tree, @Nullable ArgumentListTree arguments) { boolean result = false; if (tree.is(Tree.Kind.IDENTIFIER_REFERENCE)) { String name = ((IdentifierTree)tree).name(); result = "Function".equals(name) && arguments != null && atLeastOneArgumentNotLiteral(arguments); } return result; }
private static boolean isNontrivialConditionException(ForStatementTree forStatement) { ExpressionTree condition = forStatement.condition(); ExpressionTree update = forStatement.update(); if (update != null && condition != null && condition.is(KindSet.EQUALITY_KINDS)) { Set<String> counters = new HashSet<>(); counters(update, counters); ExpressionTree leftOperand = ((BinaryExpressionTree) condition).leftOperand(); return !leftOperand.is(IDENTIFIER_REFERENCE) || !counters.contains(((IdentifierTree) leftOperand).name()); } return false; }
private static boolean isExpressionExclusion(Tree item) { if (item.is(Kind.EXPRESSION_STATEMENT)) { ExpressionStatementTree expressionStatement = (ExpressionStatementTree) item; if (expressionStatement.expression().is(Kind.IDENTIFIER_REFERENCE, Kind.UNARY_PLUS, Kind.UNARY_MINUS, Kind.STRING_LITERAL) || expressionStatement.semicolonToken() == null || expressionStatement.expression().is(Kind.COMMA_OPERATOR)) { return true; } } return false; }
private static List<ExpressionTree> getAllSubExpressions(BinaryExpressionTree tree) { List<ExpressionTree> result = new LinkedList<>(); result.add(tree.rightOperand()); ExpressionTree currentExpression = tree.leftOperand(); while (currentExpression.is(Kind.COMMA_OPERATOR)) { result.add(((BinaryExpressionTree) currentExpression).rightOperand()); currentExpression = ((BinaryExpressionTree) currentExpression).leftOperand(); } result.add(currentExpression); return result; }
private static List<SyntaxToken> getCommas(BinaryExpressionTree tree) { List<SyntaxToken> commas = new ArrayList<>(); commas.add(tree.operatorToken()); ExpressionTree currentExpression = tree.leftOperand(); while (currentExpression.is(Kind.COMMA_OPERATOR)) { commas.add(((BinaryExpressionTree) currentExpression).operatorToken()); currentExpression = ((BinaryExpressionTree) currentExpression).leftOperand(); } return Lists.reverse(commas); }
@Override public void visitUnaryExpression(UnaryExpressionTree unaryExpression) { if (unaryExpression.is(Kind.TYPEOF)) { ExpressionTree expression = unaryExpression.expression(); if (expression.is(Kind.IDENTIFIER_REFERENCE)) { excludedNames.add(((IdentifierTree) expression).name()); } } super.visitUnaryExpression(unaryExpression); }
@Override public void visitNode(Tree tree) { BinaryExpressionTree expression = (BinaryExpressionTree) tree; if (expression.leftOperand().is(LOGICAL_COMPLEMENT)) { addIssue(tree, String.format(MESSAGE, expression.operatorToken().text())); } } }
@Override public void visitExpressionStatement(ExpressionStatementTree tree) { if (tree.expression().is(Kind.STRING_LITERAL)) { String value = ((LiteralTree) tree.expression()).value(); if ("\"use strict\"".equals(value) || "'use strict'".equals(value)) { addIssue(tree, MESSAGE); } } super.visitExpressionStatement(tree); }
@Override public void visitExpressionStatement(ExpressionStatementTree tree) { ExpressionTree expression = CheckUtils.removeParenthesis(tree.expression()); if (expression.is(Kind.STRING_LITERAL)) { if (!isDirective((LiteralTree) expression)) { addIssue(tree, MESSAGE); } } else if (!expression.is(KINDS_WITH_SIDE_EFFECTS) && !isIIFE(expression) && !insideTry(tree)) { addIssue(tree, MESSAGE); } super.visitExpressionStatement(tree); }
private static boolean isVariableWrite(ExpressionStatementTree statement, Usage usage) { if (statement.expression().is(Kind.ASSIGNMENT)) { AssignmentExpressionTree assignment = (AssignmentExpressionTree) statement.expression(); return assignment.variable() == usage.identifierTree() && isNewCollectionCreation(assignment.expression()); } return false; }
@Override public void visitAssignmentExpression(AssignmentExpressionTree tree) { ExpressionTree variable = tree.variable(); if (tree.is(Tree.Kind.ASSIGNMENT) && variable.is(Kind.IDENTIFIER_REFERENCE) && sameValue((IdentifierTree) variable, tree.expression())) { addIssue(tree, MESSAGE); } super.visitAssignmentExpression(tree); }
private static boolean isBeingPassedElsewhere(Symbol objectSymbol, Tree element) { if (element.parent().is(Tree.Kind.ASSIGNMENT)) { AssignmentExpressionTree assignment = (AssignmentExpressionTree) element.parent(); if (assignment.variable().is(Tree.Kind.IDENTIFIER_REFERENCE)) { IdentifierTree identifier = (IdentifierTree) assignment.variable(); return !sameSymbol(objectSymbol, identifier); } } return element.parent().is(Tree.Kind.ARGUMENT_LIST, Tree.Kind.INITIALIZED_BINDING_ELEMENT); }
@Override public void visitCallExpression(CallExpressionTree tree) { if (tree.types().contains(Type.Kind.BACKBONE_MODEL) && !tree.argumentClause().arguments().isEmpty()) { visitDefaults(tree); } if (tree.callee().is(Kind.DOT_MEMBER_EXPRESSION) && isBackboneSetMethod((DotMemberExpressionTree) tree.callee())) { visitSetMethodCall(tree); } super.visitCallExpression(tree); }