eslint 7.4.0 → 7.5.0

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

@@ -12,12 +12,6 @@
 const astUtils = require("./utils/ast-utils");
 const globals = require("globals");
 
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const propertyDefinitionMethods = new Set(["defineProperty", "defineProperties"]);
-
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -100,40 +94,30 @@ module.exports = {
         }
 
         /**
-         * Checks that an identifier is an object of a prototype whose member
-         * is being assigned in an AssignmentExpression.
-         * Example: Object.prototype.foo = "bar"
-         * @param {ASTNode} identifierNode The identifier to check.
-         * @returns {boolean} True if the identifier's prototype is modified.
+         * Check if it's an assignment to the property of the given node.
+         * Example: `*.prop = 0` // the `*` is the given node.
+         * @param {ASTNode} node The node to check.
+         * @returns {boolean} True if an assignment to the property of the node.
          */
-        function isInPrototypePropertyAssignment(identifierNode) {
-            return Boolean(
-                isPrototypePropertyAccessed(identifierNode) &&
-                identifierNode.parent.parent.type === "MemberExpression" &&
-                identifierNode.parent.parent.parent.type === "AssignmentExpression" &&
-                identifierNode.parent.parent.parent.left === identifierNode.parent.parent
+        function isAssigningToPropertyOf(node) {
+            return (
+                node.parent.type === "MemberExpression" &&
+                node.parent.object === node &&
+                node.parent.parent.type === "AssignmentExpression" &&
+                node.parent.parent.left === node.parent
             );
         }
 
         /**
-         * Checks that an identifier is an object of a prototype whose member
-         * is being extended via the Object.defineProperty() or
-         * Object.defineProperties() methods.
-         * Example: Object.defineProperty(Array.prototype, "foo", ...)
-         * Example: Object.defineProperties(Array.prototype, ...)
-         * @param {ASTNode} identifierNode The identifier to check.
-         * @returns {boolean} True if the identifier's prototype is modified.
+         * Checks if the given node is at the first argument of the method call of `Object.defineProperty()` or `Object.defineProperties()`.
+         * @param {ASTNode} node The node to check.
+         * @returns {boolean} True if the node is at the first argument of the method call of `Object.defineProperty()` or `Object.defineProperties()`.
          */
-        function isInDefinePropertyCall(identifierNode) {
-            return Boolean(
-                isPrototypePropertyAccessed(identifierNode) &&
-                identifierNode.parent.parent.type === "CallExpression" &&
-                identifierNode.parent.parent.arguments[0] === identifierNode.parent &&
-                identifierNode.parent.parent.callee.type === "MemberExpression" &&
-                identifierNode.parent.parent.callee.object.type === "Identifier" &&
-                identifierNode.parent.parent.callee.object.name === "Object" &&
-                identifierNode.parent.parent.callee.property.type === "Identifier" &&
-                propertyDefinitionMethods.has(identifierNode.parent.parent.callee.property.name)
+        function isInDefinePropertyCall(node) {
+            return (
+                node.parent.type === "CallExpression" &&
+                node.parent.arguments[0] === node &&
+                astUtils.isSpecificMemberAccess(node.parent.callee, "Object", /^definePropert(?:y|ies)$/u)
             );
         }
 
@@ -149,14 +133,27 @@ module.exports = {
          * @returns {void}
          */
         function checkAndReportPrototypeExtension(identifierNode) {
-            if (isInPrototypePropertyAssignment(identifierNode)) {
+            if (!isPrototypePropertyAccessed(identifierNode)) {
+                return; // This is not `*.prototype` access.
+            }
+
+            /*
+             * `identifierNode.parent` is a MamberExpression `*.prototype`.
+             * If it's an optional member access, it may be wrapped by a `ChainExpression` node.
+             */
+            const prototypeNode =
+                identifierNode.parent.parent.type === "ChainExpression"
+                    ? identifierNode.parent.parent
+                    : identifierNode.parent;
+
+            if (isAssigningToPropertyOf(prototypeNode)) {
 
-                // Identifier --> MemberExpression --> MemberExpression --> AssignmentExpression
-                reportNode(identifierNode.parent.parent.parent, identifierNode.name);
-            } else if (isInDefinePropertyCall(identifierNode)) {
+                // `*.prototype` -> MemberExpression -> AssignmentExpression
+                reportNode(prototypeNode.parent.parent, identifierNode.name);
+            } else if (isInDefinePropertyCall(prototypeNode)) {
 
-                // Identifier --> MemberExpression --> CallExpression
-                reportNode(identifierNode.parent.parent, identifierNode.name);
+                // `*.prototype` -> CallExpression
+                reportNode(prototypeNode.parent, identifierNode.name);
             }
         }
 

package/lib/rules/no-extra-bind.js

@@ -61,24 +61,62 @@ module.exports = {
          * @returns {void}
          */
         function report(node) {
+            const memberNode = node.parent;
+            const callNode = memberNode.parent.type === "ChainExpression"
+                ? memberNode.parent.parent
+                : memberNode.parent;
+
             context.report({
-                node: node.parent.parent,
+                node: callNode,
                 messageId: "unexpected",
-                loc: node.parent.property.loc,
+                loc: memberNode.property.loc,
+
                 fix(fixer) {
-                    if (node.parent.parent.arguments.length && !isSideEffectFree(node.parent.parent.arguments[0])) {
+                    if (!isSideEffectFree(callNode.arguments[0])) {
                         return null;
                     }
 
-                    const firstTokenToRemove = sourceCode
-                        .getFirstTokenBetween(node.parent.object, node.parent.property, astUtils.isNotClosingParenToken);
-                    const lastTokenToRemove = sourceCode.getLastToken(node.parent.parent);
+                    /*
+                     * The list of the first/last token pair of a removal range.
+                     * This is two parts because closing parentheses may exist between the method name and arguments.
+                     * E.g. `(function(){}.bind ) (obj)`
+                     *                    ^^^^^   ^^^^^ < removal ranges
+                     * E.g. `(function(){}?.['bind'] ) ?.(obj)`
+                     *                    ^^^^^^^^^^   ^^^^^^^ < removal ranges
+                     */
+                    const tokenPairs = [
+                        [
+
+                            // `.`, `?.`, or `[` token.
+                            sourceCode.getTokenAfter(
+                                memberNode.object,
+                                astUtils.isNotClosingParenToken
+                            ),
+
+                            // property name or `]` token.
+                            sourceCode.getLastToken(memberNode)
+                        ],
+                        [
+
+                            // `?.` or `(` token of arguments.
+                            sourceCode.getTokenAfter(
+                                memberNode,
+                                astUtils.isNotClosingParenToken
+                            ),
+
+                            // `)` token of arguments.
+                            sourceCode.getLastToken(callNode)
+                        ]
+                    ];
+                    const firstTokenToRemove = tokenPairs[0][0];
+                    const lastTokenToRemove = tokenPairs[1][1];
 
                     if (sourceCode.commentsExistBetween(firstTokenToRemove, lastTokenToRemove)) {
                         return null;
                     }
 
-                    return fixer.removeRange([firstTokenToRemove.range[0], node.parent.parent.range[1]]);
+                    return tokenPairs.map(([start, end]) =>
+                        fixer.removeRange([start.range[0], end.range[1]]));
                 }
             });
         }
@@ -93,18 +131,20 @@ module.exports = {
          * @returns {boolean} `true` if the node is the callee of `.bind()` method.
          */
         function isCalleeOfBindMethod(node) {
-            const parent = node.parent;
-            const grandparent = parent.parent;
+            if (!astUtils.isSpecificMemberAccess(node.parent, null, "bind")) {
+                return false;
+            }
+
+            // The node of `*.bind` member access.
+            const bindNode = node.parent.parent.type === "ChainExpression"
+                ? node.parent.parent
+                : node.parent;
 
             return (
-                grandparent &&
-                grandparent.type === "CallExpression" &&
-                grandparent.callee === parent &&
-                grandparent.arguments.length === 1 &&
-                grandparent.arguments[0].type !== "SpreadElement" &&
-                parent.type === "MemberExpression" &&
-                parent.object === node &&
-                astUtils.getStaticPropertyName(parent) === "bind"
+                bindNode.parent.type === "CallExpression" &&
+                bindNode.parent.callee === bindNode &&
+                bindNode.parent.arguments.length === 1 &&
+                bindNode.parent.arguments[0].type !== "SpreadElement"
             );
         }
 

package/lib/rules/no-extra-boolean-cast.js

@@ -111,6 +111,10 @@ module.exports = {
          * @returns {boolean} If the node is in one of the flagged contexts
          */
         function isInFlaggedContext(node) {
+            if (node.parent.type === "ChainExpression") {
+                return isInFlaggedContext(node.parent);
+            }
+
             return isInBooleanContext(node) ||
             (isLogicalContext(node.parent) &&
 
@@ -149,6 +153,9 @@ module.exports = {
          * @returns {boolean} `true` if the node needs to be parenthesized.
          */
         function needsParens(previousNode, node) {
+            if (previousNode.parent.type === "ChainExpression") {
+                return needsParens(previousNode.parent, node);
+            }
             if (isParenthesized(previousNode)) {
 
                 // parentheses around the previous node will stay, so there is no need for an additional pair

package/lib/rules/no-extra-parens.js

@@ -100,10 +100,18 @@ module.exports = {
          * @private
          */
         function isImmediateFunctionPrototypeMethodCall(node) {
-            return node.type === "CallExpression" &&
-                node.callee.type === "MemberExpression" &&
-                node.callee.object.type === "FunctionExpression" &&
-                ["call", "apply"].includes(astUtils.getStaticPropertyName(node.callee));
+            const callNode = astUtils.skipChainExpression(node);
+
+            if (callNode.type !== "CallExpression") {
+                return false;
+            }
+            const callee = astUtils.skipChainExpression(callNode.callee);
+
+            return (
+                callee.type === "MemberExpression" &&
+                callee.object.type === "FunctionExpression" &&
+                ["call", "apply"].includes(astUtils.getStaticPropertyName(callee))
+            );
         }
 
         /**
@@ -360,7 +368,9 @@ module.exports = {
          * @returns {boolean} `true` if the given node is an IIFE
          */
         function isIIFE(node) {
-            return node.type === "CallExpression" && node.callee.type === "FunctionExpression";
+            const maybeCallNode = astUtils.skipChainExpression(node);
+
+            return maybeCallNode.type === "CallExpression" && maybeCallNode.callee.type === "FunctionExpression";
         }
 
         /**
@@ -466,13 +476,16 @@ module.exports = {
 
                 if (
                     hasDoubleExcessParens(callee) ||
-                    !isIIFE(node) && !hasNewParensException && !(
+                    !isIIFE(node) &&
+                    !hasNewParensException &&
+                    !(
 
                         // Allow extra parens around a new expression if they are intervening parentheses.
                         node.type === "NewExpression" &&
                         callee.type === "MemberExpression" &&
                         doesMemberExpressionContainCallExpression(callee)
-                    )
+                    ) &&
+                    !(!node.optional && callee.type === "ChainExpression")
                 ) {
                     report(node.callee);
                 }
@@ -1004,6 +1017,13 @@ module.exports = {
                     report(node.object);
                 }
 
+                if (nodeObjHasExcessParens &&
+                    node.optional &&
+                    node.object.type === "ChainExpression"
+                ) {
+                    report(node.object);
+                }
+
                 if (node.computed && hasExcessParens(node.property)) {
                     report(node.property);
                 }

package/lib/rules/no-implicit-coercion.js

@@ -47,12 +47,14 @@ function isDoubleLogicalNegating(node) {
  * @returns {boolean} Whether or not the node is a binary negating of `.indexOf()` method calling.
  */
 function isBinaryNegatingOfIndexOf(node) {
+    if (node.operator !== "~") {
+        return false;
+    }
+    const callNode = astUtils.skipChainExpression(node.argument);
+
     return (
-        node.operator === "~" &&
-        node.argument.type === "CallExpression" &&
-        node.argument.callee.type === "MemberExpression" &&
-        node.argument.callee.property.type === "Identifier" &&
-        INDEX_OF_PATTERN.test(node.argument.callee.property.name)
+        callNode.type === "CallExpression" &&
+        astUtils.isSpecificMemberAccess(callNode.callee, null, INDEX_OF_PATTERN)
     );
 }
 
@@ -246,7 +248,10 @@ module.exports = {
                 // ~foo.indexOf(bar)
                 operatorAllowed = options.allow.indexOf("~") >= 0;
                 if (!operatorAllowed && options.boolean && isBinaryNegatingOfIndexOf(node)) {
-                    const recommendation = `${sourceCode.getText(node.argument)} !== -1`;
+
+                    // `foo?.indexOf(bar) !== -1` will be true (== found) if the `foo` is nullish. So use `>= 0` in that case.
+                    const comparison = node.argument.type === "ChainExpression" ? ">= 0" : "!== -1";
+                    const recommendation = `${sourceCode.getText(node.argument)} ${comparison}`;
 
                     report(node, recommendation, false);
                 }

package/lib/rules/no-implied-eval.js

@@ -35,8 +35,8 @@ module.exports = {
     },
 
     create(context) {
-        const EVAL_LIKE_FUNCS = Object.freeze(["setTimeout", "execScript", "setInterval"]);
         const GLOBAL_CANDIDATES = Object.freeze(["global", "window", "globalThis"]);
+        const EVAL_LIKE_FUNC_PATTERN = /^(?:set(?:Interval|Timeout)|execScript)$/u;
 
         /**
          * Checks whether a node is evaluated as a string or not.
@@ -56,28 +56,6 @@ module.exports = {
             return false;
         }
 
-        /**
-         * Checks whether a node is an Identifier node named one of the specified names.
-         * @param {ASTNode} node A node to check.
-         * @param {string[]} specifiers Array of specified name.
-         * @returns {boolean} True if the node is a Identifier node which has specified name.
-         */
-        function isSpecifiedIdentifier(node, specifiers) {
-            return node.type === "Identifier" && specifiers.includes(node.name);
-        }
-
-        /**
-         * Checks a given node is a MemberExpression node which has the specified name's
-         * property.
-         * @param {ASTNode} node A node to check.
-         * @param {string[]} specifiers Array of specified name.
-         * @returns {boolean} `true` if the node is a MemberExpression node which has
-         *      the specified name's property
-         */
-        function isSpecifiedMember(node, specifiers) {
-            return node.type === "MemberExpression" && specifiers.includes(astUtils.getStaticPropertyName(node));
-        }
-
         /**
          * Reports if the `CallExpression` node has evaluated argument.
          * @param {ASTNode} node A CallExpression to check.
@@ -114,14 +92,15 @@ module.exports = {
                 const identifier = ref.identifier;
                 let node = identifier.parent;
 
-                while (isSpecifiedMember(node, [name])) {
+                while (astUtils.isSpecificMemberAccess(node, null, name)) {
                     node = node.parent;
                 }
 
-                if (isSpecifiedMember(node, EVAL_LIKE_FUNCS)) {
-                    const parent = node.parent;
+                if (astUtils.isSpecificMemberAccess(node, null, EVAL_LIKE_FUNC_PATTERN)) {
+                    const calleeNode = node.parent.type === "ChainExpression" ? node.parent : node;
+                    const parent = calleeNode.parent;
 
-                    if (parent.type === "CallExpression" && parent.callee === node) {
+                    if (parent.type === "CallExpression" && parent.callee === calleeNode) {
                         reportImpliedEvalCallExpression(parent);
                     }
                 }
@@ -134,7 +113,7 @@ module.exports = {
 
         return {
             CallExpression(node) {
-                if (isSpecifiedIdentifier(node.callee, EVAL_LIKE_FUNCS)) {
+                if (astUtils.isSpecificId(node.callee, EVAL_LIKE_FUNC_PATTERN)) {
                     reportImpliedEvalCallExpression(node);
                 }
             },

package/lib/rules/no-import-assign.js

@@ -9,16 +9,12 @@
 // Helpers
 //------------------------------------------------------------------------------
 
-const { findVariable, getPropertyName } = require("eslint-utils");
-
-const MutationMethods = {
-    Object: new Set([
-        "assign", "defineProperties", "defineProperty", "freeze",
-        "setPrototypeOf"
-    ]),
-    Reflect: new Set([
-        "defineProperty", "deleteProperty", "set", "setPrototypeOf"
-    ])
+const { findVariable } = require("eslint-utils");
+const astUtils = require("./utils/ast-utils");
+
+const WellKnownMutationFunctions = {
+    Object: /^(?:assign|definePropert(?:y|ies)|freeze|setPrototypeOf)$/u,
+    Reflect: /^(?:(?:define|delete)Property|set(?:PrototypeOf)?)$/u
 };
 
 /**
@@ -56,17 +52,20 @@ function isAssignmentLeft(node) {
  * @returns {boolean} `true` if the node is the operand of mutation unary operator.
  */
 function isOperandOfMutationUnaryOperator(node) {
-    const { parent } = node;
+    const argumentNode = node.parent.type === "ChainExpression"
+        ? node.parent
+        : node;
+    const { parent } = argumentNode;
 
     return (
         (
             parent.type === "UpdateExpression" &&
-            parent.argument === node
+            parent.argument === argumentNode
         ) ||
         (
             parent.type === "UnaryExpression" &&
             parent.operator === "delete" &&
-            parent.argument === node
+            parent.argument === argumentNode
         )
     );
 }
@@ -92,35 +91,37 @@ function isIterationVariable(node) {
 }
 
 /**
- * Check if a given node is the iteration variable of `for-in`/`for-of` syntax.
+ * Check if a given node is at the first argument of a well-known mutation function.
+ * - `Object.assign`
+ * - `Object.defineProperty`
+ * - `Object.defineProperties`
+ * - `Object.freeze`
+ * - `Object.setPrototypeOf`
+ * - `Refrect.defineProperty`
+ * - `Refrect.deleteProperty`
+ * - `Refrect.set`
+ * - `Refrect.setPrototypeOf`
  * @param {ASTNode} node The node to check.
  * @param {Scope} scope A `escope.Scope` object to find variable (whichever).
- * @returns {boolean} `true` if the node is the iteration variable.
+ * @returns {boolean} `true` if the node is at the first argument of a well-known mutation function.
  */
 function isArgumentOfWellKnownMutationFunction(node, scope) {
     const { parent } = node;
 
+    if (parent.type !== "CallExpression" || parent.arguments[0] !== node) {
+        return false;
+    }
+    const callee = astUtils.skipChainExpression(parent.callee);
+
     if (
-        parent.type === "CallExpression" &&
-        parent.arguments[0] === node &&
-        parent.callee.type === "MemberExpression" &&
-        parent.callee.object.type === "Identifier"
+        !astUtils.isSpecificMemberAccess(callee, "Object", WellKnownMutationFunctions.Object) &&
+        !astUtils.isSpecificMemberAccess(callee, "Reflect", WellKnownMutationFunctions.Reflect)
     ) {
-        const { callee } = parent;
-        const { object } = callee;
-
-        if (Object.keys(MutationMethods).includes(object.name)) {
-            const variable = findVariable(scope, object);
-
-            return (
-                variable !== null &&
-                variable.scope.type === "global" &&
-                MutationMethods[object.name].has(getPropertyName(callee, scope))
-            );
-        }
+        return false;
     }
+    const variable = findVariable(scope, callee.object);
 
-    return false;
+    return variable !== null && variable.scope.type === "global";
 }
 
 /**

package/lib/rules/no-irregular-whitespace.js

@@ -91,7 +91,7 @@ module.exports = {
             const locStart = node.loc.start;
             const locEnd = node.loc.end;
 
-            errors = errors.filter(({ loc: errorLoc }) => {
+            errors = errors.filter(({ loc: { start: errorLoc } }) => {
                 if (errorLoc.line >= locStart.line && errorLoc.line <= locEnd.line) {
                     if (errorLoc.column >= locStart.column && (errorLoc.column <= locEnd.column || errorLoc.line < locEnd.line)) {
                         return false;
@@ -160,15 +160,19 @@ module.exports = {
                 let match;
 
                 while ((match = IRREGULAR_WHITESPACE.exec(sourceLine)) !== null) {
-                    const location = {
-                        line: lineNumber,
-                        column: match.index
-                    };
-
                     errors.push({
                         node,
                         messageId: "noIrregularWhitespace",
-                        loc: location
+                        loc: {
+                            start: {
+                                line: lineNumber,
+                                column: match.index
+                            },
+                            end: {
+                                line: lineNumber,
+                                column: match.index + match[0].length
+                            }
+                        }
                     });
                 }
             });
@@ -189,16 +193,22 @@ module.exports = {
 
             while ((match = IRREGULAR_LINE_TERMINATORS.exec(source)) !== null) {
                 const lineIndex = linebreaks.indexOf(match[0], lastLineIndex + 1) || 0;
-                const location = {
-                    line: lineIndex + 1,
-                    column: sourceLines[lineIndex].length
-                };
 
                 errors.push({
                     node,
                     messageId: "noIrregularWhitespace",
-                    loc: location
+                    loc: {
+                        start: {
+                            line: lineIndex + 1,
+                            column: sourceLines[lineIndex].length
+                        },
+                        end: {
+                            line: lineIndex + 2,
+                            column: 0
+                        }
+                    }
                 });
+
                 lastLineIndex = lineIndex;
             }
         }

package/lib/rules/no-magic-numbers.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const { isNumericLiteral } = require("./utils/ast-utils");
+const astUtils = require("./utils/ast-utils");
 
 // Maximum array length by the ECMAScript Specification.
 const MAX_ARRAY_LENGTH = 2 ** 32 - 1;
@@ -100,12 +100,8 @@ module.exports = {
 
             return parent.type === "CallExpression" && fullNumberNode === parent.arguments[1] &&
                 (
-                    parent.callee.name === "parseInt" ||
-                    (
-                        parent.callee.type === "MemberExpression" &&
-                        parent.callee.object.name === "Number" &&
-                        parent.callee.property.name === "parseInt"
-                    )
+                    astUtils.isSpecificId(parent.callee, "parseInt") ||
+                    astUtils.isSpecificMemberAccess(parent.callee, "Number", "parseInt")
                 );
         }
 
@@ -157,7 +153,7 @@ module.exports = {
 
         return {
             Literal(node) {
-                if (!isNumericLiteral(node)) {
+                if (!astUtils.isNumericLiteral(node)) {
                     return;
                 }
 

package/lib/rules/no-obj-calls.js

@@ -24,10 +24,13 @@ const nonCallableGlobals = ["Atomics", "JSON", "Math", "Reflect"];
  * @returns {string} name to report
  */
 function getReportNodeName(node) {
-    if (node.callee.type === "MemberExpression") {
-        return getPropertyName(node.callee);
+    if (node.type === "ChainExpression") {
+        return getReportNodeName(node.expression);
     }
-    return node.callee.name;
+    if (node.type === "MemberExpression") {
+        return getPropertyName(node);
+    }
+    return node.name;
 }
 
 //------------------------------------------------------------------------------
@@ -69,7 +72,7 @@ module.exports = {
                 }
 
                 for (const { node, path } of tracker.iterateGlobalReferences(traceMap)) {
-                    const name = getReportNodeName(node);
+                    const name = getReportNodeName(node.callee);
                     const ref = path[0];
                     const messageId = name === ref ? "unexpectedCall" : "unexpectedRefCall";
 

package/lib/rules/no-prototype-builtins.js

@@ -4,6 +4,12 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -39,15 +45,19 @@ module.exports = {
          * @returns {void}
          */
         function disallowBuiltIns(node) {
-            if (node.callee.type !== "MemberExpression" || node.callee.computed) {
+
+            // TODO: just use `astUtils.getStaticPropertyName(node.callee)`
+            const callee = astUtils.skipChainExpression(node.callee);
+
+            if (callee.type !== "MemberExpression" || callee.computed) {
                 return;
             }
-            const propName = node.callee.property.name;
+            const propName = callee.property.name;
 
             if (DISALLOWED_PROPS.indexOf(propName) > -1) {
                 context.report({
                     messageId: "prototypeBuildIn",
-                    loc: node.callee.property.loc,
+                    loc: callee.property.loc,
                     data: { prop: propName },
                     node
                 });