eslint 7.2.0 → 7.5.0

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);
                 }
@@ -710,6 +723,20 @@ module.exports = {
             reportsBuffer.reports = reportsBuffer.reports.filter(r => r.node !== node);
         }
 
+        /**
+         * Checks whether a node is a MemberExpression at NewExpression's callee.
+         * @param {ASTNode} node node to check.
+         * @returns {boolean} True if the node is a MemberExpression at NewExpression's callee. false otherwise.
+         */
+        function isMemberExpInNewCallee(node) {
+            if (node.type === "MemberExpression") {
+                return node.parent.type === "NewExpression" && node.parent.callee === node
+                    ? true
+                    : node.parent.object === node && isMemberExpInNewCallee(node.parent);
+            }
+            return false;
+        }
+
         return {
             ArrayExpression(node) {
                 node.elements
@@ -950,7 +977,11 @@ module.exports = {
             LogicalExpression: checkBinaryLogical,
 
             MemberExpression(node) {
-                const nodeObjHasExcessParens = hasExcessParens(node.object) &&
+                const shouldAllowWrapOnce = isMemberExpInNewCallee(node) &&
+                  doesMemberExpressionContainCallExpression(node);
+                const nodeObjHasExcessParens = shouldAllowWrapOnce
+                    ? hasDoubleExcessParens(node.object)
+                    : hasExcessParens(node.object) &&
                     !(
                         isImmediateFunctionPrototypeMethodCall(node.parent) &&
                         node.parent.callee === node &&
@@ -974,8 +1005,8 @@ module.exports = {
                 }
 
                 if (nodeObjHasExcessParens &&
-                  node.object.type === "CallExpression" &&
-                  node.parent.type !== "NewExpression") {
+                  node.object.type === "CallExpression"
+                ) {
                     report(node.object);
                 }
 
@@ -986,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-promise-executor-return.js

@@ -0,0 +1,121 @@
+/**
+ * @fileoverview Rule to disallow returning values from Promise executor functions
+ * @author Milos Djermanovic
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const { findVariable } = require("eslint-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const functionTypesToCheck = new Set(["ArrowFunctionExpression", "FunctionExpression"]);
+
+/**
+ * Determines whether the given identifier node is a reference to a global variable.
+ * @param {ASTNode} node `Identifier` node to check.
+ * @param {Scope} scope Scope to which the node belongs.
+ * @returns {boolean} True if the identifier is a reference to a global variable.
+ */
+function isGlobalReference(node, scope) {
+    const variable = findVariable(scope, node);
+
+    return variable !== null && variable.scope.type === "global" && variable.defs.length === 0;
+}
+
+/**
+ * Finds function's outer scope.
+ * @param {Scope} scope Function's own scope.
+ * @returns {Scope} Function's outer scope.
+ */
+function getOuterScope(scope) {
+    const upper = scope.upper;
+
+    if (upper.type === "function-expression-name") {
+        return upper.upper;
+    }
+    return upper;
+}
+
+/**
+ * Determines whether the given function node is used as a Promise executor.
+ * @param {ASTNode} node The node to check.
+ * @param {Scope} scope Function's own scope.
+ * @returns {boolean} `true` if the node is a Promise executor.
+ */
+function isPromiseExecutor(node, scope) {
+    const parent = node.parent;
+
+    return parent.type === "NewExpression" &&
+        parent.arguments[0] === node &&
+        parent.callee.type === "Identifier" &&
+        parent.callee.name === "Promise" &&
+        isGlobalReference(parent.callee, getOuterScope(scope));
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "problem",
+
+        docs: {
+            description: "disallow returning values from Promise executor functions",
+            category: "Possible Errors",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/no-promise-executor-return"
+        },
+
+        schema: [],
+
+        messages: {
+            returnsValue: "Return values from promise executor functions cannot be read."
+        }
+    },
+
+    create(context) {
+
+        let funcInfo = null;
+
+        /**
+         * Reports the given node.
+         * @param {ASTNode} node Node to report.
+         * @returns {void}
+         */
+        function report(node) {
+            context.report({ node, messageId: "returnsValue" });
+        }
+
+        return {
+
+            onCodePathStart(_, node) {
+                funcInfo = {
+                    upper: funcInfo,
+                    shouldCheck: functionTypesToCheck.has(node.type) && isPromiseExecutor(node, context.getScope())
+                };
+
+                if (funcInfo.shouldCheck && node.type === "ArrowFunctionExpression" && node.expression) {
+                    report(node.body);
+                }
+            },
+
+            onCodePathEnd() {
+                funcInfo = funcInfo.upper;
+            },
+
+            ReturnStatement(node) {
+                if (funcInfo.shouldCheck && node.argument) {
+                    report(node);
+                }
+            }
+        };
+    }
+};

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
                 });

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

@@ -17,56 +17,6 @@ const astUtils = require("./utils/ast-utils");
 
 const SPACES = /\s+/gu;
 
-/**
- * Checks whether the property of 2 given member expression nodes are the same
- * property or not.
- * @param {ASTNode} left A member expression node to check.
- * @param {ASTNode} right Another member expression node to check.
- * @returns {boolean} `true` if the member expressions have the same property.
- */
-function isSameProperty(left, right) {
-    if (left.property.type === "Identifier" &&
-        left.property.type === right.property.type &&
-        left.property.name === right.property.name &&
-        left.computed === right.computed
-    ) {
-        return true;
-    }
-
-    const lname = astUtils.getStaticPropertyName(left);
-    const rname = astUtils.getStaticPropertyName(right);
-
-    return lname !== null && lname === rname;
-}
-
-/**
- * Checks whether 2 given member expression nodes are the reference to the same
- * property or not.
- * @param {ASTNode} left A member expression node to check.
- * @param {ASTNode} right Another member expression node to check.
- * @returns {boolean} `true` if the member expressions are the reference to the
- *  same property or not.
- */
-function isSameMember(left, right) {
-    if (!isSameProperty(left, right)) {
-        return false;
-    }
-
-    const lobj = left.object;
-    const robj = right.object;
-
-    if (lobj.type !== robj.type) {
-        return false;
-    }
-    if (lobj.type === "MemberExpression") {
-        return isSameMember(lobj, robj);
-    }
-    if (lobj.type === "ThisExpression") {
-        return true;
-    }
-    return lobj.type === "Identifier" && lobj.name === robj.name;
-}
-
 /**
  * Traverses 2 Pattern nodes in parallel, then reports self-assignments.
  * @param {ASTNode|null} left A left node to traverse. This is a Pattern or
@@ -162,9 +112,9 @@ function eachSelfAssignment(left, right, props, report) {
         }
     } else if (
         props &&
-        left.type === "MemberExpression" &&
-        right.type === "MemberExpression" &&
-        isSameMember(left, right)
+        astUtils.skipChainExpression(left).type === "MemberExpression" &&
+        astUtils.skipChainExpression(right).type === "MemberExpression" &&
+        astUtils.isSameReference(left, right)
     ) {
         report(right);
     }