eslint 7.4.0 → 7.8.0

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;
@@ -61,6 +61,10 @@ module.exports = {
                 ignoreArrayIndexes: {
                     type: "boolean",
                     default: false
+                },
+                ignoreDefaultValues: {
+                    type: "boolean",
+                    default: false
                 }
             },
             additionalProperties: false
@@ -77,7 +81,8 @@ module.exports = {
             detectObjects = !!config.detectObjects,
             enforceConst = !!config.enforceConst,
             ignore = (config.ignore || []).map(normalizeIgnoreValue),
-            ignoreArrayIndexes = !!config.ignoreArrayIndexes;
+            ignoreArrayIndexes = !!config.ignoreArrayIndexes,
+            ignoreDefaultValues = !!config.ignoreDefaultValues;
 
         const okTypes = detectObjects ? [] : ["ObjectExpression", "Property", "AssignmentExpression"];
 
@@ -90,6 +95,17 @@ module.exports = {
             return ignore.indexOf(value) !== -1;
         }
 
+        /**
+         * Returns whether the number is a default value assignment.
+         * @param {ASTNode} fullNumberNode `Literal` or `UnaryExpression` full number node
+         * @returns {boolean} true if the number is a default value
+         */
+        function isDefaultValue(fullNumberNode) {
+            const parent = fullNumberNode.parent;
+
+            return parent.type === "AssignmentPattern" && parent.right === fullNumberNode;
+        }
+
         /**
          * Returns whether the given node is used as a radix within parseInt() or Number.parseInt()
          * @param {ASTNode} fullNumberNode `Literal` or `UnaryExpression` full number node
@@ -100,12 +116,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 +169,7 @@ module.exports = {
 
         return {
             Literal(node) {
-                if (!isNumericLiteral(node)) {
+                if (!astUtils.isNumericLiteral(node)) {
                     return;
                 }
 
@@ -176,9 +188,12 @@ module.exports = {
                     raw = node.raw;
                 }
 
+                const parent = fullNumberNode.parent;
+
                 // Always allow radix arguments and JSX props
                 if (
                     isIgnoredValue(value) ||
+                    (ignoreDefaultValues && isDefaultValue(fullNumberNode)) ||
                     isParseIntRadix(fullNumberNode) ||
                     isJSXNumber(fullNumberNode) ||
                     (ignoreArrayIndexes && isArrayIndex(fullNumberNode, value))
@@ -186,8 +201,6 @@ module.exports = {
                     return;
                 }
 
-                const parent = fullNumberNode.parent;
-
                 if (parent.type === "VariableDeclarator") {
                     if (enforceConst && parent.parent.kind !== "const") {
                         context.report({

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

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

package/lib/rules/no-setter-return.js

@@ -39,15 +39,12 @@ function isGlobalReference(node, scope) {
  * @returns {boolean} `true` if the node is argument at the given position.
  */
 function isArgumentOfGlobalMethodCall(node, scope, objectName, methodName, index) {
-    const parent = node.parent;
+    const callNode = node.parent;
 
-    return parent.type === "CallExpression" &&
-        parent.arguments[index] === node &&
-        parent.callee.type === "MemberExpression" &&
-        astUtils.getStaticPropertyName(parent.callee) === methodName &&
-        parent.callee.object.type === "Identifier" &&
-        parent.callee.object.name === objectName &&
-        isGlobalReference(parent.callee.object, scope);
+    return callNode.type === "CallExpression" &&
+        callNode.arguments[index] === node &&
+        astUtils.isSpecificMemberAccess(callNode.callee, objectName, methodName) &&
+        isGlobalReference(astUtils.skipChainExpression(callNode.callee).object, scope);
 }
 
 /**

package/lib/rules/no-underscore-dangle.js

@@ -1,5 +1,5 @@
 /**
- * @fileoverview Rule to flag trailing underscores in variable declarations.
+ * @fileoverview Rule to flag dangling underscores in variable declarations.
  * @author Matt DuVall <http://www.mattduvall.com>
  */
 
@@ -45,6 +45,10 @@ module.exports = {
                     enforceInMethodNames: {
                         type: "boolean",
                         default: false
+                    },
+                    allowFunctionParams: {
+                        type: "boolean",
+                        default: true
                     }
                 },
                 additionalProperties: false
@@ -64,6 +68,7 @@ module.exports = {
         const allowAfterSuper = typeof options.allowAfterSuper !== "undefined" ? options.allowAfterSuper : false;
         const allowAfterThisConstructor = typeof options.allowAfterThisConstructor !== "undefined" ? options.allowAfterThisConstructor : false;
         const enforceInMethodNames = typeof options.enforceInMethodNames !== "undefined" ? options.enforceInMethodNames : false;
+        const allowFunctionParams = typeof options.allowFunctionParams !== "undefined" ? options.allowFunctionParams : true;
 
         //-------------------------------------------------------------------------
         // Helpers
@@ -80,12 +85,12 @@ module.exports = {
         }
 
         /**
-         * Check if identifier has a underscore at the end
+         * Check if identifier has a dangling underscore
          * @param {string} identifier name of the node
          * @returns {boolean} true if its is present
          * @private
          */
-        function hasTrailingUnderscore(identifier) {
+        function hasDanglingUnderscore(identifier) {
             const len = identifier.length;
 
             return identifier !== "_" && (identifier[0] === "_" || identifier[len - 1] === "_");
@@ -126,16 +131,53 @@ module.exports = {
         }
 
         /**
-         * Check if function has a underscore at the end
+         * Check if function parameter has a dangling underscore.
+         * @param {ASTNode} node function node to evaluate
+         * @returns {void}
+         * @private
+         */
+        function checkForDanglingUnderscoreInFunctionParameters(node) {
+            if (!allowFunctionParams) {
+                node.params.forEach(param => {
+                    const { type } = param;
+                    let nodeToCheck;
+
+                    if (type === "RestElement") {
+                        nodeToCheck = param.argument;
+                    } else if (type === "AssignmentPattern") {
+                        nodeToCheck = param.left;
+                    } else {
+                        nodeToCheck = param;
+                    }
+
+                    if (nodeToCheck.type === "Identifier") {
+                        const identifier = nodeToCheck.name;
+
+                        if (hasDanglingUnderscore(identifier) && !isAllowed(identifier)) {
+                            context.report({
+                                node: param,
+                                messageId: "unexpectedUnderscore",
+                                data: {
+                                    identifier
+                                }
+                            });
+                        }
+                    }
+                });
+            }
+        }
+
+        /**
+         * Check if function has a dangling underscore
          * @param {ASTNode} node node to evaluate
          * @returns {void}
          * @private
          */
-        function checkForTrailingUnderscoreInFunctionDeclaration(node) {
-            if (node.id) {
+        function checkForDanglingUnderscoreInFunction(node) {
+            if (node.type === "FunctionDeclaration" && node.id) {
                 const identifier = node.id.name;
 
-                if (typeof identifier !== "undefined" && hasTrailingUnderscore(identifier) && !isAllowed(identifier)) {
+                if (typeof identifier !== "undefined" && hasDanglingUnderscore(identifier) && !isAllowed(identifier)) {
                     context.report({
                         node,
                         messageId: "unexpectedUnderscore",
@@ -145,18 +187,19 @@ module.exports = {
                     });
                 }
             }
+            checkForDanglingUnderscoreInFunctionParameters(node);
         }
 
         /**
-         * Check if variable expression has a underscore at the end
+         * Check if variable expression has a dangling underscore
          * @param {ASTNode} node node to evaluate
          * @returns {void}
          * @private
          */
-        function checkForTrailingUnderscoreInVariableExpression(node) {
+        function checkForDanglingUnderscoreInVariableExpression(node) {
             const identifier = node.id.name;
 
-            if (typeof identifier !== "undefined" && hasTrailingUnderscore(identifier) &&
+            if (typeof identifier !== "undefined" && hasDanglingUnderscore(identifier) &&
                 !isSpecialCaseIdentifierInVariableExpression(identifier) && !isAllowed(identifier)) {
                 context.report({
                     node,
@@ -169,18 +212,18 @@ module.exports = {
         }
 
         /**
-         * Check if member expression has a underscore at the end
+         * Check if member expression has a dangling underscore
          * @param {ASTNode} node node to evaluate
          * @returns {void}
          * @private
          */
-        function checkForTrailingUnderscoreInMemberExpression(node) {
+        function checkForDanglingUnderscoreInMemberExpression(node) {
             const identifier = node.property.name,
                 isMemberOfThis = node.object.type === "ThisExpression",
                 isMemberOfSuper = node.object.type === "Super",
                 isMemberOfThisConstructor = isThisConstructorReference(node);
 
-            if (typeof identifier !== "undefined" && hasTrailingUnderscore(identifier) &&
+            if (typeof identifier !== "undefined" && hasDanglingUnderscore(identifier) &&
                 !(isMemberOfThis && allowAfterThis) &&
                 !(isMemberOfSuper && allowAfterSuper) &&
                 !(isMemberOfThisConstructor && allowAfterThisConstructor) &&
@@ -196,16 +239,16 @@ module.exports = {
         }
 
         /**
-         * Check if method declaration or method property has a underscore at the end
+         * Check if method declaration or method property has a dangling underscore
          * @param {ASTNode} node node to evaluate
          * @returns {void}
          * @private
          */
-        function checkForTrailingUnderscoreInMethod(node) {
+        function checkForDanglingUnderscoreInMethod(node) {
             const identifier = node.key.name;
             const isMethod = node.type === "MethodDefinition" || node.type === "Property" && node.method;
 
-            if (typeof identifier !== "undefined" && enforceInMethodNames && isMethod && hasTrailingUnderscore(identifier) && !isAllowed(identifier)) {
+            if (typeof identifier !== "undefined" && enforceInMethodNames && isMethod && hasDanglingUnderscore(identifier) && !isAllowed(identifier)) {
                 context.report({
                     node,
                     messageId: "unexpectedUnderscore",
@@ -221,11 +264,13 @@ module.exports = {
         //--------------------------------------------------------------------------
 
         return {
-            FunctionDeclaration: checkForTrailingUnderscoreInFunctionDeclaration,
-            VariableDeclarator: checkForTrailingUnderscoreInVariableExpression,
-            MemberExpression: checkForTrailingUnderscoreInMemberExpression,
-            MethodDefinition: checkForTrailingUnderscoreInMethod,
-            Property: checkForTrailingUnderscoreInMethod
+            FunctionDeclaration: checkForDanglingUnderscoreInFunction,
+            VariableDeclarator: checkForDanglingUnderscoreInVariableExpression,
+            MemberExpression: checkForDanglingUnderscoreInMemberExpression,
+            MethodDefinition: checkForDanglingUnderscoreInMethod,
+            Property: checkForDanglingUnderscoreInMethod,
+            FunctionExpression: checkForDanglingUnderscoreInFunction,
+            ArrowFunctionExpression: checkForDanglingUnderscoreInFunction
         };
 
     }

package/lib/rules/no-unexpected-multiline.js

@@ -68,7 +68,7 @@ module.exports = {
         return {
 
             MemberExpression(node) {
-                if (!node.computed) {
+                if (!node.computed || node.optional) {
                     return;
                 }
                 checkForBreakAfter(node.object, "property");
@@ -96,7 +96,7 @@ module.exports = {
             },
 
             CallExpression(node) {
-                if (node.arguments.length === 0) {
+                if (node.arguments.length === 0 || node.optional) {
                     return;
                 }
                 checkForBreakAfter(node.callee, "function");

package/lib/rules/no-unneeded-ternary.js

@@ -122,7 +122,6 @@ module.exports = {
                 if (isBooleanLiteral(node.alternate) && isBooleanLiteral(node.consequent)) {
                     context.report({
                         node,
-                        loc: node.consequent.loc.start,
                         messageId: "unnecessaryConditionalExpression",
                         fix(fixer) {
                             if (node.consequent.value === node.alternate.value) {
@@ -144,7 +143,6 @@ module.exports = {
                 } else if (!defaultAssignment && matchesDefaultAssignment(node)) {
                     context.report({
                         node,
-                        loc: node.consequent.loc.start,
                         messageId: "unnecessaryConditionalAssignment",
                         fix: fixer => {
                             const shouldParenthesizeAlternate =

package/lib/rules/no-unused-expressions.js

@@ -8,6 +8,22 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/**
+ * Returns `true`.
+ * @returns {boolean} `true`.
+ */
+function alwaysTrue() {
+    return true;
+}
+
+/**
+ * Returns `false`.
+ * @returns {boolean} `false`.
+ */
+function alwaysFalse() {
+    return false;
+}
+
 module.exports = {
     meta: {
         type: "suggestion",
@@ -101,40 +117,56 @@ module.exports = {
         }
 
         /**
-         * Determines whether or not a given node is a valid expression. Recurses on short circuit eval and ternary nodes if enabled by flags.
-         * @param {ASTNode} node any node
-         * @returns {boolean} whether the given node is a valid expression
+         * The member functions return `true` if the type has no side-effects.
+         * Unknown nodes are handled as `false`, then this rule ignores those.
          */
-        function isValidExpression(node) {
-            if (allowTernary) {
-
-                // Recursive check for ternary and logical expressions
-                if (node.type === "ConditionalExpression") {
-                    return isValidExpression(node.consequent) && isValidExpression(node.alternate);
+        const Checker = Object.assign(Object.create(null), {
+            isDisallowed(node) {
+                return (Checker[node.type] || alwaysFalse)(node);
+            },
+
+            ArrayExpression: alwaysTrue,
+            ArrowFunctionExpression: alwaysTrue,
+            BinaryExpression: alwaysTrue,
+            ChainExpression(node) {
+                return Checker.isDisallowed(node.expression);
+            },
+            ClassExpression: alwaysTrue,
+            ConditionalExpression(node) {
+                if (allowTernary) {
+                    return Checker.isDisallowed(node.consequent) || Checker.isDisallowed(node.alternate);
                 }
-            }
-
-            if (allowShortCircuit) {
-                if (node.type === "LogicalExpression") {
-                    return isValidExpression(node.right);
+                return true;
+            },
+            FunctionExpression: alwaysTrue,
+            Identifier: alwaysTrue,
+            Literal: alwaysTrue,
+            LogicalExpression(node) {
+                if (allowShortCircuit) {
+                    return Checker.isDisallowed(node.right);
                 }
-            }
-
-            if (allowTaggedTemplates && node.type === "TaggedTemplateExpression") {
                 return true;
+            },
+            MemberExpression: alwaysTrue,
+            MetaProperty: alwaysTrue,
+            ObjectExpression: alwaysTrue,
+            SequenceExpression: alwaysTrue,
+            TaggedTemplateExpression() {
+                return !allowTaggedTemplates;
+            },
+            TemplateLiteral: alwaysTrue,
+            ThisExpression: alwaysTrue,
+            UnaryExpression(node) {
+                return node.operator !== "void" && node.operator !== "delete";
             }
-
-            return /^(?:Assignment|Call|New|Update|Yield|Await|Import)Expression$/u.test(node.type) ||
-                (node.type === "UnaryExpression" && ["delete", "void"].indexOf(node.operator) >= 0);
-        }
+        });
 
         return {
             ExpressionStatement(node) {
-                if (!isValidExpression(node.expression) && !isDirective(node, context.getAncestors())) {
+                if (Checker.isDisallowed(node.expression) && !isDirective(node, context.getAncestors())) {
                     context.report({ node, messageId: "unusedExpression" });
                 }
             }
         };
-
     }
 };

package/lib/rules/no-useless-call.js

@@ -17,13 +17,15 @@ const astUtils = require("./utils/ast-utils");
  * @returns {boolean} Whether or not the node is a `.call()`/`.apply()`.
  */
 function isCallOrNonVariadicApply(node) {
+    const callee = astUtils.skipChainExpression(node.callee);
+
     return (
-        node.callee.type === "MemberExpression" &&
-        node.callee.property.type === "Identifier" &&
-        node.callee.computed === false &&
+        callee.type === "MemberExpression" &&
+        callee.property.type === "Identifier" &&
+        callee.computed === false &&
         (
-            (node.callee.property.name === "call" && node.arguments.length >= 1) ||
-            (node.callee.property.name === "apply" && node.arguments.length === 2 && node.arguments[1].type === "ArrayExpression")
+            (callee.property.name === "call" && node.arguments.length >= 1) ||
+            (callee.property.name === "apply" && node.arguments.length === 2 && node.arguments[1].type === "ArrayExpression")
         )
     );
 }
@@ -74,12 +76,13 @@ module.exports = {
                     return;
                 }
 
-                const applied = node.callee.object;
+                const callee = astUtils.skipChainExpression(node.callee);
+                const applied = astUtils.skipChainExpression(callee.object);
                 const expectedThis = (applied.type === "MemberExpression") ? applied.object : null;
                 const thisArg = node.arguments[0];
 
                 if (isValidThisArg(expectedThis, thisArg, sourceCode)) {
-                    context.report({ node, messageId: "unnecessaryCall", data: { name: node.callee.property.name } });
+                    context.report({ node, messageId: "unnecessaryCall", data: { name: callee.property.name } });
                 }
             }
         };