Update: support logical assignments in core rules (refs #13569)

docs/rules/operator-assignment.md

@@ -23,6 +23,8 @@ JavaScript provides shorthand operators that combine variable assignment and som
 
 This rule requires or disallows assignment operator shorthand where possible.
 
+The rule applies to the operators listed in the above table.
+
 ## Options
 
 This rule has a single string option:

lib/rules/constructor-super.js

@@ -5,6 +5,13 @@
 
 "use strict";
 
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
@@ -60,7 +67,23 @@ function isPossibleConstructor(node) {
             return node.name !== "undefined";
 
         case "AssignmentExpression":
-            return isPossibleConstructor(node.right);
+            if (node.operator === "=") {
+                return isPossibleConstructor(node.right);
+            }
+
+            if (astUtils.isLogicalAssignmentOperator(node.operator)) {
+                return (
+                    isPossibleConstructor(node.left) ||
+                    isPossibleConstructor(node.right)
+                );
+            }
+
+            /**
+             * All other assignment operators are mathematical assignment operators (arithmetic or bitwise).
+             * An assignment expression with a mathematical operator can either evaluate to a primitive value,
+             * or throw, depending on the operands. Thus, it cannot evaluate to a constructor function.
+             */
+            return false;
 
         case "LogicalExpression":
             return (

lib/rules/operator-assignment.js

@@ -151,7 +151,7 @@ module.exports = {
          * @returns {void}
          */
         function prohibit(node) {
-            if (node.operator !== "=") {
+            if (node.operator !== "=" && !astUtils.isLogicalAssignmentOperator(node.operator)) {
                 context.report({
                     node,
                     messageId: "unexpected",

lib/rules/utils/ast-utils.js

@@ -40,6 +40,8 @@ const STATEMENT_LIST_PARENTS = new Set(["Program", "BlockStatement", "SwitchCase
 const DECIMAL_INTEGER_PATTERN = /^(0|[1-9]\d*)$/u;
 const OCTAL_ESCAPE_PATTERN = /^(?:[^\\]|\\[^0-7]|\\0(?![0-9]))*\\(?:[1-7]|0[0-9])/u;
 
+const LOGICAL_ASSIGNMENT_OPERATORS = new Set(["&&=", "||=", "??="]);
+
 /**
  * Checks reference if is non initializer and writable.
  * @param {Reference} reference A reference to check.
@@ -722,6 +724,15 @@ function isMixedLogicalAndCoalesceExpressions(left, right) {
     );
 }
 
+/**
+ * Checks if the given operator is a logical assignment operator.
+ * @param {string} operator The operator to check.
+ * @returns {boolean} `true` if the operator is a logical assignment operator.
+ */
+function isLogicalAssignmentOperator(operator) {
+    return LOGICAL_ASSIGNMENT_OPERATORS.has(operator);
+}
+
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------
@@ -1567,7 +1578,20 @@ module.exports = {
                 return true; // possibly an error object.
 
             case "AssignmentExpression":
-                return module.exports.couldBeError(node.right);
+                if (node.operator === "=") {
+                    return module.exports.couldBeError(node.right);
+                }
+
+                if (isLogicalAssignmentOperator(node.operator)) {
+                    return module.exports.couldBeError(node.left) || module.exports.couldBeError(node.right);
+                }
+
+                /**
+                 * All other assignment operators are mathematical assignment operators (arithmetic or bitwise).
+                 * An assignment expression with a mathematical operator can either evaluate to a primitive value,
+                 * or throw, depending on the operands. Thus, it cannot evaluate to an `Error` object.
+                 */
+                return false;
 
             case "SequenceExpression": {
                 const exprs = node.expressions;
@@ -1754,5 +1778,6 @@ module.exports = {
     isSpecificId,
     isSpecificMemberAccess,
     equalLiteralValue,
-    isSameReference
+    isSameReference,
+    isLogicalAssignmentOperator
 };

tests/lib/rules/constructor-super.js

@@ -16,7 +16,7 @@ const { RuleTester } = require("../../../lib/rule-tester");
 // Tests
 //------------------------------------------------------------------------------
 
-const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 2020 } });
+const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 2021 } });
 
 ruleTester.run("constructor-super", rule, {
     valid: [
@@ -37,7 +37,18 @@ ruleTester.run("constructor-super", rule, {
         "class A extends B { constructor() { if (true) { super(); } else { super(); } } }",
         "class A extends (class B {}) { constructor() { super(); } }",
         "class A extends (B = C) { constructor() { super(); } }",
+        "class A extends (B &&= C) { constructor() { super(); } }",
+        "class A extends (B ||= C) { constructor() { super(); } }",
+        "class A extends (B ??= C) { constructor() { super(); } }",
+        "class A extends (B &&= 5) { constructor() { super(); } }",
+        "class A extends (B ||= 5) { constructor() { super(); } }",
+        "class A extends (B ??= 5) { constructor() { super(); } }",
         "class A extends (B || C) { constructor() { super(); } }",
+        "class A extends (B && 5) { constructor() { super(); } }",
+        "class A extends (5 && B) { constructor() { super(); } }",
+        "class A extends (B || 5) { constructor() { super(); } }",
+        "class A extends (B ?? 5) { constructor() { super(); } }",
+
         "class A extends (a ? B : C) { constructor() { super(); } }",
         "class A extends (B, C) { constructor() { super(); } }",
 
@@ -112,6 +123,30 @@ ruleTester.run("constructor-super", rule, {
             code: "class A extends 'test' { constructor() { super(); } }",
             errors: [{ messageId: "badSuper", type: "CallExpression" }]
         },
+        {
+            code: "class A extends (B = 5) { constructor() { super(); } }",
+            errors: [{ messageId: "badSuper", type: "CallExpression" }]
+        },
+        {
+            code: "class A extends (B += C) { constructor() { super(); } }",
+            errors: [{ messageId: "badSuper", type: "CallExpression" }]
+        },
+        {
+            code: "class A extends (B -= C) { constructor() { super(); } }",
+            errors: [{ messageId: "badSuper", type: "CallExpression" }]
+        },
+        {
+            code: "class A extends (B **= C) { constructor() { super(); } }",
+            errors: [{ messageId: "badSuper", type: "CallExpression" }]
+        },
+        {
+            code: "class A extends (B |= C) { constructor() { super(); } }",
+            errors: [{ messageId: "badSuper", type: "CallExpression" }]
+        },
+        {
+            code: "class A extends (B &= C) { constructor() { super(); } }",
+            errors: [{ messageId: "badSuper", type: "CallExpression" }]
+        },
 
         // derived classes.
         {

tests/lib/rules/func-name-matching.js

@@ -29,6 +29,9 @@ ruleTester.run("func-name-matching", rule, {
         "foo = function foo() {};",
         { code: "foo = function foo() {};", options: ["always"] },
         { code: "foo = function bar() {};", options: ["never"] },
+        { code: "foo &&= function foo() {};", parserOptions: { ecmaVersion: 2021 } },
+        { code: "obj.foo ||= function foo() {};", parserOptions: { ecmaVersion: 2021 } },
+        { code: "obj['foo'] ??= function foo() {};", parserOptions: { ecmaVersion: 2021 } },
         "obj.foo = function foo() {};",
         { code: "obj.foo = function foo() {};", options: ["always"] },
         { code: "obj.foo = function bar() {};", options: ["never"] },
@@ -284,6 +287,27 @@ ruleTester.run("func-name-matching", rule, {
                 { messageId: "matchVariable", data: { funcName: "bar", name: "foo" } }
             ]
         },
+        {
+            code: "foo &&= function bar() {};",
+            parserOptions: { ecmaVersion: 2021 },
+            errors: [
+                { messageId: "matchVariable", data: { funcName: "bar", name: "foo" } }
+            ]
+        },
+        {
+            code: "obj.foo ||= function bar() {};",
+            parserOptions: { ecmaVersion: 2021 },
+            errors: [
+                { messageId: "matchProperty", data: { funcName: "bar", name: "foo" } }
+            ]
+        },
+        {
+            code: "obj['foo'] ??= function bar() {};",
+            parserOptions: { ecmaVersion: 2021 },
+            errors: [
+                { messageId: "matchProperty", data: { funcName: "bar", name: "foo" } }
+            ]
+        },
         {
             code: "obj.foo = function bar() {};",
             parserOptions: { ecmaVersion: 6 },

tests/lib/rules/no-bitwise.js

@@ -22,7 +22,12 @@ ruleTester.run("no-bitwise", rule, {
     valid: [
         "a + b",
         "!a",
+        "a && b",
+        "a || b",
         "a += b",
+        { code: "a &&= b", parserOptions: { ecmaVersion: 2021 } },
+        { code: "a ||= b", parserOptions: { ecmaVersion: 2021 } },
+        { code: "a ??= b", parserOptions: { ecmaVersion: 2021 } },
         { code: "~[1, 2, 3].indexOf(1)", options: [{ allow: ["~"] }] },
         { code: "~1<<2 === -8", options: [{ allow: ["~", "<<"] }] },
         { code: "a|0", options: [{ int32Hint: true }] },

tests/lib/rules/no-extend-native.js

@@ -160,6 +160,23 @@ ruleTester.run("no-extend-native", rule, {
         code: "(Object?.defineProperty)(Object.prototype, 'p', { value: 0 })",
         parserOptions: { ecmaVersion: 2020 },
         errors: [{ messageId: "unexpected", data: { builtin: "Object" } }]
+    },
+
+    // Logical assignments
+    {
+        code: "Array.prototype.p &&= 0",
+        parserOptions: { ecmaVersion: 2021 },
+        errors: [{ messageId: "unexpected", data: { builtin: "Array" } }]
+    },
+    {
+        code: "Array.prototype.p ||= 0",
+        parserOptions: { ecmaVersion: 2021 },
+        errors: [{ messageId: "unexpected", data: { builtin: "Array" } }]
+    },
+    {
+        code: "Array.prototype.p ??= 0",
+        parserOptions: { ecmaVersion: 2021 },
+        errors: [{ messageId: "unexpected", data: { builtin: "Array" } }]
     }
 
     ]

tests/lib/rules/no-invalid-this.js

@@ -719,6 +719,24 @@ const patterns = [
         errors,
         valid: [NORMAL],
         invalid: [USE_STRICT, IMPLIED_STRICT, MODULES]
+    },
+    {
+        code: "obj.method &&= function () { console.log(this); z(x => console.log(x, this)); }",
+        parserOptions: { ecmaVersion: 2021 },
+        valid: [NORMAL, USE_STRICT, IMPLIED_STRICT, MODULES],
+        invalid: []
+    },
+    {
+        code: "obj.method ||= function () { console.log(this); z(x => console.log(x, this)); }",
+        parserOptions: { ecmaVersion: 2021 },
+        valid: [NORMAL, USE_STRICT, IMPLIED_STRICT, MODULES],
+        invalid: []
+    },
+    {
+        code: "obj.method ??= function () { console.log(this); z(x => console.log(x, this)); }",
+        parserOptions: { ecmaVersion: 2021 },
+        valid: [NORMAL, USE_STRICT, IMPLIED_STRICT, MODULES],
+        invalid: []
     }
 ];
 

tests/lib/rules/no-param-reassign.js

@@ -368,6 +368,57 @@ ruleTester.run("no-param-reassign", rule, {
                 messageId: "assignmentToFunctionParamProp",
                 data: { name: "a" }
             }]
+        },
+        {
+            code: "function foo(a) { a &&= b; }",
+            parserOptions: { ecmaVersion: 2021 },
+            errors: [{
+                messageId: "assignmentToFunctionParam",
+                data: { name: "a" }
+            }]
+        },
+        {
+            code: "function foo(a) { a ||= b; }",
+            parserOptions: { ecmaVersion: 2021 },
+            errors: [{
+                messageId: "assignmentToFunctionParam",
+                data: { name: "a" }
+            }]
+        },
+        {
+            code: "function foo(a) { a ??= b; }",
+            parserOptions: { ecmaVersion: 2021 },
+            errors: [{
+                messageId: "assignmentToFunctionParam",
+                data: { name: "a" }
+            }]
+        },
+        {
+            code: "function foo(a) { a.b &&= c; }",
+            options: [{ props: true }],
+            parserOptions: { ecmaVersion: 2021 },
+            errors: [{
+                messageId: "assignmentToFunctionParamProp",
+                data: { name: "a" }
+            }]
+        },
+        {
+            code: "function foo(a) { a.b.c ||= d; }",
+            options: [{ props: true }],
+            parserOptions: { ecmaVersion: 2021 },
+            errors: [{
+                messageId: "assignmentToFunctionParamProp",
+                data: { name: "a" }
+            }]
+        },
+        {
+            code: "function foo(a) { a[b] ??= c; }",
+            options: [{ props: true }],
+            parserOptions: { ecmaVersion: 2021 },
+            errors: [{
+                messageId: "assignmentToFunctionParamProp",
+                data: { name: "a" }
+            }]
         }
     ]
 });

tests/lib/rules/no-throw-literal.js

@@ -30,7 +30,10 @@ ruleTester.run("no-throw-literal", rule, {
         "throw new foo();", // NewExpression
         "throw foo.bar;", // MemberExpression
         "throw foo[bar];", // MemberExpression
-        "throw foo = new Error();", // AssignmentExpression
+        "throw foo = new Error();", // AssignmentExpression with the `=` operator
+        { code: "throw foo &&= 'literal'", parserOptions: { ecmaVersion: 2021 } }, // AssignmentExpression with a logical operator
+        { code: "throw foo.bar ||= 'literal'", parserOptions: { ecmaVersion: 2021 } }, // AssignmentExpression with a logical operator
+        { code: "throw foo[bar] ??= 'literal'", parserOptions: { ecmaVersion: 2021 } }, // AssignmentExpression with a logical operator
         "throw 1, 2, new Error();", // SequenceExpression
         "throw 'literal' && new Error();", // LogicalExpression (right)
         "throw new Error() || 'literal';", // LogicalExpression (left)
@@ -104,7 +107,21 @@ ruleTester.run("no-throw-literal", rule, {
 
         // AssignmentExpression
         {
-            code: "throw foo = 'error';",
+            code: "throw foo = 'error';", // RHS is a literal
+            errors: [{
+                messageId: "object",
+                type: "ThrowStatement"
+            }]
+        },
+        {
+            code: "throw foo += new Error();", // evaluates to a primitive value, or throws while evaluating
+            errors: [{
+                messageId: "object",
+                type: "ThrowStatement"
+            }]
+        },
+        {
+            code: "throw foo &= new Error();", // evaluates to a primitive value, or throws while evaluating
             errors: [{
                 messageId: "object",
                 type: "ThrowStatement"