@Override public void visitAssignmentExpression(AssignmentExpressionTree tree) { super.visitAssignmentExpression(tree); lookForException(tree.expression()); }
@Override public void visitAssignmentExpression(AssignmentExpressionTree tree) { if (tree.is(Kind.ASSIGNMENT) && isUndefined(tree.expression())) { addIssue(tree.expression(), MESSAGE); } super.visitAssignmentExpression(tree); }
@Override public void visitAssignmentExpression(AssignmentExpressionTree tree) { super.visitAssignmentExpression(tree); lookForException(tree.expression()); }
private static boolean isUpdateOnOneWithAssign(ExpressionTree update) { if (update.is(PLUS_ASSIGNMENT, MINUS_ASSIGNMENT)) { ExpressionTree rightExpression = ((AssignmentExpressionTree) update).expression(); return rightExpression.is(NUMERIC_LITERAL) && "1".equals(((LiteralTree) rightExpression).value()); } return false; } }
private static boolean isUpdateOnOneWithAssign(ExpressionTree update) { if (update.is(Tree.Kind.PLUS_ASSIGNMENT, Tree.Kind.MINUS_ASSIGNMENT)) { ExpressionTree rightExpression = ((AssignmentExpressionTree) update).expression(); return rightExpression.is(Tree.Kind.NUMERIC_LITERAL) && "1".equals(((LiteralTree) rightExpression).value()); } return false; } }
@Override public void visitAssignmentExpression(AssignmentExpressionTree tree) { scan(tree.variable()); scan(tree.expression()); }
@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 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("Remove this %s or correct the code not to waste it.", type); getContext().addIssue(this, postfix, message); } } super.visitAssignmentExpression(assignment); }
@Override public void visitAssignmentExpression(AssignmentExpressionTree tree) { if (tree.is(Kind.ASSIGNMENT) && isUndefined(tree.expression())) { reportIssue(tree); } super.visitAssignmentExpression(tree); }
private void visitInitialisationExpression(ExpressionTree left) { if (left instanceof AssignmentExpressionTree) { scan(((AssignmentExpressionTree) left).variable()); visitInitialisationExpression(((AssignmentExpressionTree) left).expression()); } else { scan(left); } }
@Override public void visitAssignmentExpression(AssignmentExpressionTree tree) { inferType(tree.variable(), tree.expression()); scan(tree.variable()); }
public ExpressionComponents(Tree element) { if (element instanceof AssignmentExpressionTree) { AssignmentExpressionTree assignment = (AssignmentExpressionTree) element; leftOperand = assignment.variable(); rightOperand = assignment.expression(); operator = assignment.operatorToken(); } else { BinaryExpressionTree binaryExpression = (BinaryExpressionTree) element; leftOperand = binaryExpression.leftOperand(); rightOperand = binaryExpression.rightOperand(); operator = binaryExpression.operatorToken(); } }
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); }
@Override public void visitAssignmentExpression(AssignmentExpressionTree tree) { ExpressionTree variable = tree.variable(); if (tree.is(Tree.Kind.ASSIGNMENT) && SyntacticEquivalence.areEquivalent(variable, tree.expression())) { getContext().addIssue(this, tree, "Remove or correct this useless self-assignment."); } super.visitAssignmentExpression(tree); }
@Nullable private static Integer getValue(Tree tree) { Integer result = null; if (tree.is(NOT_EQUAL_TO)) { result = getInteger(((BinaryExpressionTree) tree).rightOperand()); } else if (isOneVarDeclaration(tree)) { BindingElementTree variable = ((VariableDeclarationTree) tree).variables().get(0); if (variable.is(INITIALIZED_BINDING_ELEMENT)) { result = getInteger(((InitializedBindingElementTree) variable).right()); } } else if (tree.is(ASSIGNMENT)) { result = getInteger(((AssignmentExpressionTree) tree).expression()); } return result; }
@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 visitExpressionStatement(ExpressionStatementTree tree) { Tree expressionTree = tree.expression(); if (expressionTree.is(Kind.COMMA_OPERATOR)) { visitCommaOperatorExpression(((BinaryExpressionTree) expressionTree).leftOperand()); visitCommaOperatorExpression(((BinaryExpressionTree) expressionTree).rightOperand()); } else { while (expressionTree instanceof AssignmentExpressionTree) { AssignmentExpressionTree assignmentExpressionTree = (AssignmentExpressionTree) expressionTree; scan(assignmentExpressionTree.variable()); expressionTree = assignmentExpressionTree.expression(); } scan(expressionTree); } }
private Integer getValue(Tree tree) { Integer result = null; if (tree.is(Tree.Kind.NOT_EQUAL_TO)) { result = getInteger(((BinaryExpressionTree) tree).rightOperand()); } else if (isOneVarDeclaration(tree)) { BindingElementTree variable = ((VariableDeclarationTree) tree).variables().get(0); if (variable.is(Tree.Kind.INITIALIZED_BINDING_ELEMENT)) { result = getInteger(((InitializedBindingElementTree) variable).right()); } } else if (tree.is(Tree.Kind.ASSIGNMENT)) { result = getInteger(((AssignmentExpressionTree) tree).expression()); } return result; }
@Override public void visitAssignmentExpression(AssignmentExpressionTree tree) { if (tree.variable().is(Kind.DOT_MEMBER_EXPRESSION) && tree.expression().types().containsOnlyAndUnique(Type.Kind.FUNCTION)) { DotMemberExpressionTree lhs = (DotMemberExpressionTree) tree.variable(); if (lhs.object().is(Kind.DOT_MEMBER_EXPRESSION)) { DotMemberExpressionTree prototype = (DotMemberExpressionTree) lhs.object(); if ("prototype".equals(prototype.property().name()) && prototype.object().is(Kind.IDENTIFIER_REFERENCE) && prototype.object().types().contains(Type.Kind.FUNCTION)) { addIssue(lhs, String.format(MESSAGE, ((IdentifierTree) prototype.object()).name(), lhs.property().name())); } } } super.visitAssignmentExpression(tree); } }