@Override public void visitAssignmentExpression(AssignmentExpressionTree tree) { inferType(tree.variable(), tree.expression()); scan(tree.variable()); }
@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); }
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(); } }
@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) { updatedExpressions.add(tree.variable()); super.visitAssignmentExpression(tree); }
/** * When an assignment is done to a symbol that has not been declared before, * a global variable is created with the left-hand side identifier as name. */ @Override public void visitAssignmentExpression(AssignmentExpressionTree tree) { if (tree.variable() instanceof IdentifierTree) { IdentifierTree identifier = (IdentifierTree) tree.variable(); Usage.Kind usageKind = Usage.Kind.WRITE; if (!tree.operator().text().equals(EcmaScriptPunctuator.EQU.getValue())) { usageKind = Usage.Kind.READ_WRITE; } if (!addUsageFor(identifier, usageKind)) { Symbol symbol = symbolModel.declareSymbol(identifier.name(), Symbol.Kind.VARIABLE, symbolModel.globalScope()); symbol.addUsage( Usage.create(identifier, usageKind) ); } // no need to inferType variable has it has been handle scan(tree.expression()); } else { super.visitAssignmentExpression(tree); } }
@Override public void visitAssignmentExpression(AssignmentExpressionTree tree) { super.visitAssignmentExpression(tree); lookForException(tree.expression()); }
private void addIssue(AssignmentExpressionTree tree) { addIssue(tree.operatorToken(), String.format(MESSAGE, CheckUtils.asString(tree.variable()))); }
@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 visitAssignmentExpression(AssignmentExpressionTree tree) { Tree parent = tree.parent(); if (parent.is(Kind.PARENTHESISED_EXPRESSION) && parent.parent().is(Kind.EXPRESSION_STATEMENT) && !tree.variable().is(Kind.OBJECT_ASSIGNMENT_PATTERN)) { addIssue(tree); } else { Tree parentIgnoreParenthesesAndComma = parentIgnoreParenthesesAndComma(tree); Tree parentIgnoreAssignment = parentIgnoreAssignment(tree); if (!parentIgnoreParenthesesAndComma.is(ALLOWED_PARENT_KINDS) && !parentIgnoreAssignment.is(ALLOWED_PARENT_KINDS_WITH_INITIALIZER)) { addIssue(tree); } } super.visitAssignmentExpression(tree); }
@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())); }
@Override public void visitAssignmentExpression(AssignmentExpressionTree tree) { updatedExpressions.add(tree.variable()); super.visitAssignmentExpression(tree); }
@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())) { reportIssue(tree); } super.visitAssignmentExpression(tree); }
@Override public void visitAssignmentExpression(AssignmentExpressionTree tree) { scan(tree.variable()); scan(tree.expression()); }
@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); }
@Override void raiseIssue(AssignmentExpressionTree tree) { IdentifierTree variable = (IdentifierTree) tree.variable(); addIssue(tree, String.format(MESSAGE, variable.name())); } }
private void checkBinaryOperation(ProgramState currentState, Tree element) { Type rightType = currentState.getConstraint(currentState.peekStack(0)).type(); Type leftType = currentState.getConstraint(currentState.peekStack(1)).type(); ExpressionTree leftOperand; ExpressionTree rightOperand; SyntaxToken operator; 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(); } if (element.is(PLUS_KINDS)) { checkPlus(leftOperand, rightOperand, leftType, rightType, operator); } else if (element.is(COMPARISON_KINDS)) { checkComparison(leftOperand, rightOperand, leftType, rightType, operator); } else if (element.is(ARITHMETIC_KINDS)) { checkArithmetic(leftOperand, rightOperand, leftType, rightType, operator, element.is(MINUS)); } }
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 void visitInitialisationExpression(ExpressionTree left) { if (left instanceof AssignmentExpressionTree) { scan(((AssignmentExpressionTree) left).variable()); visitInitialisationExpression(((AssignmentExpressionTree) left).expression()); } else { scan(left); } }