@Override public void visitUnaryExpression(UnaryExpressionTree tree) { if (tree.is(KindSet.INC_DEC_KINDS)) { updatedExpressions.add(tree.expression()); } super.visitUnaryExpression(tree); }
@Override public void visitUnaryExpression(UnaryExpressionTree tree) { if (tree.is(Tree.Kind.DELETE) && isArrayElement(tree.expression())) { addIssue(tree.operatorToken(), MESSAGE); } super.visitUnaryExpression(tree); }
@Override public void visitNode(Tree tree) { UnaryExpressionTree voidExpression = (UnaryExpressionTree) tree; ExpressionTree operand = CheckUtils.removeParenthesis(voidExpression.expression()); if (!isZero(operand)) { addIssue(voidExpression.operatorToken(), MESSAGE); } }
@Override public void visitUnaryExpression(UnaryExpressionTree tree) { scan(tree.expression()); }
private boolean isIncDec(UnaryExpressionTree tree) { return tree.is( Tree.Kind.PREFIX_INCREMENT, Tree.Kind.PREFIX_DECREMENT, Tree.Kind.POSTFIX_INCREMENT, Tree.Kind.POSTFIX_DECREMENT ); }
private void raiseIssue(UnaryExpressionTree tree) { String message = String.format(MESSAGE, "++".equals(tree.operatorToken().text()) ? "increment" : "decrement"); addIssue(tree.operatorToken(), message); } }
@Override public void visitNode(Tree tree) { SyntaxToken operator; if (tree.is(Tree.Kind.BITWISE_COMPLEMENT)){ operator = ((UnaryExpressionTree) tree).operator(); } else if (tree instanceof BinaryExpressionTree) { operator = ((BinaryExpressionTree) tree).operator(); } else { operator = ((AssignmentExpressionTree) tree).operator(); } getContext().addIssue(this, operator, String.format("Remove the use of \"%s\" operator.", operator.text())); }
private static boolean isDateException(Tree tree) { if (tree.is(Kind.UNARY_PLUS)) { String exprString = CheckUtils.asString(((UnaryExpressionTree) tree).expression()); return exprString.contains("Date") || exprString.contains("date"); } return false; }
@Override public void visitNode(Tree tree) { AssignmentExpressionTree assignment = (AssignmentExpressionTree) tree; ExpressionTree expression = assignment.expression(); if (expression.is(Kind.UNARY_PLUS, Kind.UNARY_MINUS, Kind.LOGICAL_COMPLEMENT)) { UnaryExpressionTree unaryExpression = (UnaryExpressionTree) expression; SyntaxToken assignmentOperator = assignment.operatorToken(); SyntaxToken expressionOperator = unaryExpression.operatorToken(); if (areAdjacent(assignmentOperator, expressionOperator) && !areAdjacent(expressionOperator, unaryExpression.expression())) { String message = String.format(MESSAGE, unaryExpression.operatorToken()); addIssue(new PreciseIssue(this, new IssueLocation(assignmentOperator, expressionOperator, message))); } } super.visitNode(tree); }
@Override public void visitUnaryExpression(UnaryExpressionTree tree) { if (tree.is(KindSet.INC_DEC_KINDS)) { raiseIssue(tree); } super.visitUnaryExpression(tree); }
@Override void raiseIssue(UnaryExpressionTree tree) { if (!isDateException(tree)) { SyntaxToken operator = tree.operatorToken(); addIssue(operator, String.format(MESSAGE, operator.text())); } }
@Override public void visitUnaryExpression(UnaryExpressionTree tree) { if (tree.is(Tree.Kind.POSTFIX_INCREMENT, Tree.Kind.POSTFIX_DECREMENT, Tree.Kind.PREFIX_INCREMENT, Tree.Kind.PREFIX_DECREMENT)) { updatedExpressions.add(tree.expression()); } super.visitUnaryExpression(tree); }
@Override public void visitUnaryExpression(UnaryExpressionTree tree) { if (isIncDec(tree) && tree.expression().is(Tree.Kind.IDENTIFIER_REFERENCE)) { addUsageFor((IdentifierTree) tree.expression(), Usage.Kind.READ_WRITE); } else { super.visitUnaryExpression(tree); } }
@Override public void visitAssignmentExpression(AssignmentExpressionTree assignment) { if (assignment.expression().is(Tree.Kind.POSTFIX_INCREMENT, Tree.Kind.POSTFIX_DECREMENT)) { UnaryExpressionTree postfix = (UnaryExpressionTree) assignment.expression(); if (SyntacticEquivalence.areEquivalent(assignment.variable(), postfix.expression())) { String type = postfix.is(Tree.Kind.POSTFIX_INCREMENT) ? "increment" : "decrement"; String message = String.format(MESSAGE, type); addIssue(postfix.operatorToken(), message); } } super.visitAssignmentExpression(assignment); }
@Override public void beforeBlockElement(ProgramState currentState, Tree element, ProgramPoint programPoint) { if (element.is(PLUS_KINDS) || element.is(COMPARISON_KINDS) || element.is(ARITHMETIC_KINDS)) { checkBinaryOperation(currentState, element); } if (element.is(UNARY_KINDS)) { Type operandType = currentState.getConstraint(currentState.peekStack()).type(); ExpressionTree operand = ((UnaryExpressionTree) element).expression(); if (BOOLEAN_STRING_DATE.contains(operandType)) { raiseIssue(operand, ((UnaryExpressionTree) element).operatorToken()); } } }
@Override boolean isProblem(UnaryExpressionTree tree, ProgramState currentState) { Constraint constraint = currentState.getConstraint(currentState.peekStack()); Type type = constraint.type(); boolean isDateCasting = type == Type.DATE && tree.is(Kind.UNARY_PLUS); return !isDateCasting && type != null && NOT_ALLOWED_TYPES.contains(type); }
@Override public void visitUnaryExpression(UnaryExpressionTree tree) { if (inUpdate && tree.is(KindSet.INC_DEC_KINDS)) { addCurrentLoopCounter(tree.expression()); } super.visitUnaryExpression(tree); }
@CheckForNull public static Double numericValue(ExpressionTree expression) { if (expression.is(Tree.Kind.NUMERIC_LITERAL)) { return Double.valueOf(((LiteralTree) expression).value()); } if (expression.is(Tree.Kind.UNARY_MINUS, Tree.Kind.UNARY_PLUS)) { UnaryExpressionTree unaryExp = (UnaryExpressionTree) expression; Double subExpressionIntValue = numericValue(unaryExp.expression()); return expression.is(Tree.Kind.UNARY_MINUS) ? minus(subExpressionIntValue) : subExpressionIntValue; } return null; }
@Override public void beforeBlockElement(ProgramState currentState, Tree element, ProgramPoint programPoint) { if (programPoint instanceof BinaryProgramPoint) { final BinaryProgramPoint binaryPoint = (BinaryProgramPoint) programPoint; final Constraint resultConstraint = binaryPoint.resultingConstraint(currentState); if (resultConstraint.isStricterOrEqualTo(Constraint.NAN)) { final ExpressionComponents components = new ExpressionComponents(element); if (binaryPoint.firstOperandConstraint().isStricterOrEqualTo(UNDEFINED_OR_NON_NUMBER_OBJECT)) { raiseIssue(components.leftOperand, components.operator, components.rightOperand); } else { raiseIssue(components.rightOperand, components.operator, components.leftOperand); } } } else if (element.is( Kind.UNARY_PLUS, Kind.UNARY_MINUS, Kind.POSTFIX_INCREMENT, Kind.POSTFIX_DECREMENT, Kind.PREFIX_INCREMENT, Kind.PREFIX_DECREMENT)) { Constraint constraint = currentState.getConstraint(currentState.peekStack(0)); if (constraint.isStricterOrEqualTo(UNDEFINED_OR_NON_NUMBER_OBJECT)) { UnaryExpressionTree unaryExpression = (UnaryExpressionTree) element; raiseIssue(unaryExpression.expression(), unaryExpression.operatorToken()); } } }
@Override public void visitUnaryExpression(UnaryExpressionTree tree) { if (tree.is(KindSet.INC_DEC_KINDS) && currentParameterWithDefault != null) { addIssue(currentParameterWithDefault, String.format(MESSAGE, CheckUtils.asString(currentParameterWithDefault.left()))); currentParameterWithDefault = null; } super.visitUnaryExpression(tree); } }