1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
/**
* @fileoverview Rule to replace assignment expressions with operator assignment
* @author Brandon Mills
* @copyright 2014 Brandon Mills. All rights reserved.
*/
"use strict";
//------------------------------------------------------------------------------
// Helpers
//------------------------------------------------------------------------------
/**
* Checks whether an operator is commutative and has an operator assignment
* shorthand form.
* @param {string} operator Operator to check.
* @returns {boolean} True if the operator is commutative and has a
* shorthand form.
*/
function isCommutativeOperatorWithShorthand(operator) {
return ["*", "&", "^", "|"].indexOf(operator) >= 0;
}
/**
* Checks whether an operator is not commuatative and has an operator assignment
* shorthand form.
* @param {string} operator Operator to check.
* @returns {boolean} True if the operator is not commuatative and has
* a shorthand form.
*/
function isNonCommutativeOperatorWithShorthand(operator) {
return ["+", "-", "/", "%", "<<", ">>", ">>>"].indexOf(operator) >= 0;
}
//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------
/**
* Checks whether two expressions reference the same value. For example:
* a = a
* a.b = a.b
* a[0] = a[0]
* a['b'] = a['b']
* @param {ASTNode} a Left side of the comparison.
* @param {ASTNode} b Right side of the comparison.
* @returns {boolean} True if both sides match and reference the same value.
*/
function same(a, b) {
if (a.type !== b.type) {
return false;
}
switch (a.type) {
case "Identifier":
return a.name === b.name;
case "Literal":
return a.value === b.value;
case "MemberExpression":
// x[0] = x[0]
// x[y] = x[y]
// x.y = x.y
return same(a.object, b.object) && same(a.property, b.property);
default:
return false;
}
}
module.exports = function(context) {
/**
* Ensures that an assignment uses the shorthand form where possible.
* @param {ASTNode} node An AssignmentExpression node.
* @returns {void}
*/
function verify(node) {
var expr, left, operator;
if (node.operator !== "=" || node.right.type !== "BinaryExpression") {
return;
}
left = node.left;
expr = node.right;
operator = expr.operator;
if (isCommutativeOperatorWithShorthand(operator)) {
if (same(left, expr.left) || same(left, expr.right)) {
context.report(node, "Assignment can be replaced with operator assignment.");
}
} else if (isNonCommutativeOperatorWithShorthand(operator)) {
if (same(left, expr.left)) {
context.report(node, "Assignment can be replaced with operator assignment.");
}
}
}
/**
* Warns if an assignment expression uses operator assignment shorthand.
* @param {ASTNode} node An AssignmentExpression node.
* @returns {void}
*/
function prohibit(node) {
if (node.operator !== "=") {
context.report(node, "Unexpected operator assignment shorthand.");
}
}
return {
"AssignmentExpression": context.options[0] !== "never" ? verify : prohibit
};
};
|
