--- /dev/null
+/**
+ * @fileoverview Rule to replace assignment expressions with operator assignment
+ * @author Brandon Mills
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// 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);
+
+ case "ThisExpression":
+ return true;
+
+ default:
+ return false;
+ }
+}
+
+/**
+ * Determines if the left side of a node can be safely fixed (i.e. if it activates the same getters/setters and)
+ * toString calls regardless of whether assignment shorthand is used)
+ * @param {ASTNode} node The node on the left side of the expression
+ * @returns {boolean} `true` if the node can be fixed
+ */
+function canBeFixed(node) {
+ return (
+ node.type === "Identifier" ||
+ (
+ node.type === "MemberExpression" &&
+ (node.object.type === "Identifier" || node.object.type === "ThisExpression") &&
+ (!node.computed || node.property.type === "Literal")
+ )
+ );
+}
+
+module.exports = {
+ meta: {
+ type: "suggestion",
+
+ docs: {
+ description: "require or disallow assignment operator shorthand where possible",
+ category: "Stylistic Issues",
+ recommended: false,
+ url: "https://eslint.org/docs/rules/operator-assignment"
+ },
+
+ schema: [
+ {
+ enum: ["always", "never"]
+ }
+ ],
+
+ fixable: "code",
+ messages: {
+ replaced: "Assignment can be replaced with operator assignment.",
+ unexpected: "Unexpected operator assignment shorthand."
+ }
+ },
+
+ create(context) {
+
+ const sourceCode = context.getSourceCode();
+
+ /**
+ * Returns the operator token of an AssignmentExpression or BinaryExpression
+ * @param {ASTNode} node An AssignmentExpression or BinaryExpression node
+ * @returns {Token} The operator token in the node
+ */
+ function getOperatorToken(node) {
+ return sourceCode.getFirstTokenBetween(node.left, node.right, token => token.value === node.operator);
+ }
+
+ /**
+ * Ensures that an assignment uses the shorthand form where possible.
+ * @param {ASTNode} node An AssignmentExpression node.
+ * @returns {void}
+ */
+ function verify(node) {
+ if (node.operator !== "=" || node.right.type !== "BinaryExpression") {
+ return;
+ }
+
+ const left = node.left;
+ const expr = node.right;
+ const operator = expr.operator;
+
+ if (isCommutativeOperatorWithShorthand(operator) || isNonCommutativeOperatorWithShorthand(operator)) {
+ if (same(left, expr.left)) {
+ context.report({
+ node,
+ messageId: "replaced",
+ fix(fixer) {
+ if (canBeFixed(left)) {
+ const equalsToken = getOperatorToken(node);
+ const operatorToken = getOperatorToken(expr);
+ const leftText = sourceCode.getText().slice(node.range[0], equalsToken.range[0]);
+ const rightText = sourceCode.getText().slice(operatorToken.range[1], node.right.range[1]);
+
+ // Check for comments that would be removed.
+ if (sourceCode.commentsExistBetween(equalsToken, operatorToken)) {
+ return null;
+ }
+
+ return fixer.replaceText(node, `${leftText}${expr.operator}=${rightText}`);
+ }
+ return null;
+ }
+ });
+ } else if (same(left, expr.right) && isCommutativeOperatorWithShorthand(operator)) {
+
+ /*
+ * This case can't be fixed safely.
+ * If `a` and `b` both have custom valueOf() behavior, then fixing `a = b * a` to `a *= b` would
+ * change the execution order of the valueOf() functions.
+ */
+ context.report({
+ node,
+ messageId: "replaced"
+ });
+ }
+ }
+ }
+
+ /**
+ * 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,
+ messageId: "unexpected",
+ fix(fixer) {
+ if (canBeFixed(node.left)) {
+ const firstToken = sourceCode.getFirstToken(node);
+ const operatorToken = getOperatorToken(node);
+ const leftText = sourceCode.getText().slice(node.range[0], operatorToken.range[0]);
+ const newOperator = node.operator.slice(0, -1);
+ let rightText;
+
+ // Check for comments that would be duplicated.
+ if (sourceCode.commentsExistBetween(firstToken, operatorToken)) {
+ return null;
+ }
+
+ // If this change would modify precedence (e.g. `foo *= bar + 1` => `foo = foo * (bar + 1)`), parenthesize the right side.
+ if (
+ astUtils.getPrecedence(node.right) <= astUtils.getPrecedence({ type: "BinaryExpression", operator: newOperator }) &&
+ !astUtils.isParenthesised(sourceCode, node.right)
+ ) {
+ rightText = `${sourceCode.text.slice(operatorToken.range[1], node.right.range[0])}(${sourceCode.getText(node.right)})`;
+ } else {
+ const firstRightToken = sourceCode.getFirstToken(node.right);
+ let rightTextPrefix = "";
+
+ if (
+ operatorToken.range[1] === firstRightToken.range[0] &&
+ !astUtils.canTokensBeAdjacent(newOperator, firstRightToken)
+ ) {
+ rightTextPrefix = " "; // foo+=+bar -> foo= foo+ +bar
+ }
+
+ rightText = `${rightTextPrefix}${sourceCode.text.slice(operatorToken.range[1], node.range[1])}`;
+ }
+
+ return fixer.replaceText(node, `${leftText}= ${leftText}${newOperator}${rightText}`);
+ }
+ return null;
+ }
+ });
+ }
+ }
+
+ return {
+ AssignmentExpression: context.options[0] !== "never" ? verify : prohibit
+ };
+
+ }
+};
projects / dotfiles / .git / blobdiff