eslint 8.37.0 → 8.38.0

package/README.md

@@ -244,11 +244,6 @@ The people who review and fix bugs and help triage issues.
 Bryan Mishkin
 </a>
 </td><td align="center" valign="top" width="11%">
-<a href="https://github.com/btmills">
-<img src="https://github.com/btmills.png?s=75" width="75" height="75"><br />
-Brandon Mills
-</a>
-</td><td align="center" valign="top" width="11%">
 <a href="https://github.com/fasttime">
 <img src="https://github.com/fasttime.png?s=75" width="75" height="75"><br />
 Francesco Trotta

package/lib/linter/linter.js

@@ -905,22 +905,6 @@ function createRuleListeners(rule, ruleContext) {
     }
 }
 
-/**
- * Gets all the ancestors of a given node
- * @param {ASTNode} node The node
- * @returns {ASTNode[]} All the ancestor nodes in the AST, not including the provided node, starting
- * from the root node and going inwards to the parent node.
- */
-function getAncestors(node) {
-    const ancestorsStartingAtParent = [];
-
-    for (let ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
-        ancestorsStartingAtParent.push(ancestor);
-    }
-
-    return ancestorsStartingAtParent.reverse();
-}
-
 // methods that exist on SourceCode object
 const DEPRECATED_SOURCECODE_PASSTHROUGHS = {
     getSource: "getText",
@@ -996,8 +980,8 @@ function runRules(sourceCode, configuredRules, ruleMapper, parserName, languageO
         Object.assign(
             Object.create(BASE_TRAVERSAL_CONTEXT),
             {
-                getAncestors: () => getAncestors(currentNode),
-                getDeclaredVariables: sourceCode.scopeManager.getDeclaredVariables.bind(sourceCode.scopeManager),
+                getAncestors: () => sourceCode.getAncestors(currentNode),
+                getDeclaredVariables: node => sourceCode.getDeclaredVariables(node),
                 getCwd: () => cwd,
                 getFilename: () => filename,
                 getPhysicalFilename: () => physicalFilename || filename,

package/lib/rules/block-scoped-var.js

@@ -28,6 +28,7 @@ module.exports = {
 
     create(context) {
         let stack = [];
+        const sourceCode = context.getSourceCode();
 
         /**
          * Makes a block scope.
@@ -83,7 +84,7 @@ module.exports = {
             }
 
             // Gets declared variables, and checks its references.
-            const variables = context.getDeclaredVariables(node);
+            const variables = sourceCode.getDeclaredVariables(node);
 
             for (let i = 0; i < variables.length; ++i) {
 

package/lib/rules/camelcase.js

@@ -296,7 +296,7 @@ module.exports = {
                 "ClassExpression",
                 "CatchClause"
             ]](node) {
-                for (const variable of context.getDeclaredVariables(node)) {
+                for (const variable of sourceCode.getDeclaredVariables(node)) {
                     if (isGoodName(variable.name)) {
                         continue;
                     }
@@ -346,7 +346,7 @@ module.exports = {
 
             // Report camelcase in import --------------------------------------
             ImportDeclaration(node) {
-                for (const variable of context.getDeclaredVariables(node)) {
+                for (const variable of sourceCode.getDeclaredVariables(node)) {
                     if (isGoodName(variable.name)) {
                         continue;
                     }

package/lib/rules/func-names.js

@@ -159,7 +159,7 @@ module.exports = {
         function handleFunction(node) {
 
             // Skip recursive functions.
-            const nameVar = context.getDeclaredVariables(node)[0];
+            const nameVar = sourceCode.getDeclaredVariables(node)[0];
 
             if (isFunctionName(nameVar) && nameVar.references.length > 0) {
                 return;

package/lib/rules/global-require.js

@@ -78,7 +78,7 @@ module.exports = {
                 const currentScope = sourceCode.getScope(node);
 
                 if (node.callee.name === "require" && !isShadowed(currentScope, node.callee)) {
-                    const isGoodRequire = context.getAncestors().every(parent => ACCEPTABLE_PARENTS.has(parent.type));
+                    const isGoodRequire = sourceCode.getAncestors(node).every(parent => ACCEPTABLE_PARENTS.has(parent.type));
 
                     if (!isGoodRequire) {
                         context.report({ node, messageId: "unexpected" });

package/lib/rules/new-parens.js

@@ -31,20 +31,11 @@ module.exports = {
         },
 
         fixable: "code",
-        schema: {
-            anyOf: [
-                {
-                    type: "array",
-                    items: [
-                        {
-                            enum: ["always", "never"]
-                        }
-                    ],
-                    minItems: 0,
-                    maxItems: 1
-                }
-            ]
-        },
+        schema: [
+            {
+                enum: ["always", "never"]
+            }
+        ],
         messages: {
             missing: "Missing '()' invoking a constructor.",
             unnecessary: "Unnecessary '()' invoking a constructor with no arguments."

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

@@ -31,6 +31,8 @@ module.exports = {
 
     create(context) {
 
+        const sourceCode = context.getSourceCode();
+
         /**
          * Finds and reports references that are non initializer and writable.
          * @param {Variable} variable A variable to check.
@@ -49,7 +51,7 @@ module.exports = {
          * @returns {void}
          */
         function checkForClass(node) {
-            context.getDeclaredVariables(node).forEach(checkVariable);
+            sourceCode.getDeclaredVariables(node).forEach(checkVariable);
         }
 
         return {

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

@@ -31,6 +31,8 @@ module.exports = {
 
     create(context) {
 
+        const sourceCode = context.getSourceCode();
+
         /**
          * Finds and reports references that are non initializer and writable.
          * @param {Variable} variable A variable to check.
@@ -45,7 +47,7 @@ module.exports = {
         return {
             VariableDeclaration(node) {
                 if (node.kind === "const") {
-                    context.getDeclaredVariables(node).forEach(checkVariable);
+                    sourceCode.getDeclaredVariables(node).forEach(checkVariable);
                 }
             }
         };

package/lib/rules/no-div-regex.js

@@ -15,7 +15,7 @@ module.exports = {
         type: "suggestion",
 
         docs: {
-            description: "Disallow division operators explicitly at the beginning of regular expressions",
+            description: "Disallow equal signs explicitly at the beginning of regular expressions",
             recommended: false,
             url: "https://eslint.org/docs/rules/no-div-regex"
         },

package/lib/rules/no-dupe-args.js

@@ -29,6 +29,8 @@ module.exports = {
 
     create(context) {
 
+        const sourceCode = context.getSourceCode();
+
         //--------------------------------------------------------------------------
         // Helpers
         //--------------------------------------------------------------------------
@@ -49,7 +51,7 @@ module.exports = {
          * @private
          */
         function checkParams(node) {
-            const variables = context.getDeclaredVariables(node);
+            const variables = sourceCode.getDeclaredVariables(node);
 
             for (let i = 0; i < variables.length; ++i) {
                 const variable = variables[i];

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

@@ -31,6 +31,8 @@ module.exports = {
 
     create(context) {
 
+        const sourceCode = context.getSourceCode();
+
         /**
          * Finds and reports references that are non initializer and writable.
          * @param {Variable} variable A variable to check.
@@ -44,7 +46,7 @@ module.exports = {
 
         return {
             CatchClause(node) {
-                context.getDeclaredVariables(node).forEach(checkVariable);
+                sourceCode.getDeclaredVariables(node).forEach(checkVariable);
             }
         };
 

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

@@ -31,6 +31,8 @@ module.exports = {
 
     create(context) {
 
+        const sourceCode = context.getSourceCode();
+
         /**
          * Reports a reference if is non initializer and writable.
          * @param {References} references Collection of reference to check.
@@ -65,7 +67,7 @@ module.exports = {
          * @returns {void}
          */
         function checkForFunction(node) {
-            context.getDeclaredVariables(node).forEach(checkVariable);
+            sourceCode.getDeclaredVariables(node).forEach(checkVariable);
         }
 
         return {

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

@@ -200,7 +200,7 @@ module.exports = {
             ImportDeclaration(node) {
                 const scope = sourceCode.getScope(node);
 
-                for (const variable of context.getDeclaredVariables(node)) {
+                for (const variable of sourceCode.getDeclaredVariables(node)) {
                     const shouldCheckMembers = variable.defs.some(
                         d => d.node.type === "ImportNamespaceSpecifier"
                     );

package/lib/rules/no-lone-blocks.js

@@ -68,14 +68,15 @@ module.exports = {
         /**
          * Checks the enclosing block of the current node for block-level bindings,
          * and "marks it" as valid if any.
+         * @param {ASTNode} node The current node to check.
          * @returns {void}
          */
-        function markLoneBlock() {
+        function markLoneBlock(node) {
             if (loneBlocks.length === 0) {
                 return;
             }
 
-            const block = context.getAncestors().pop();
+            const block = sourceCode.getAncestors(node).pop();
 
             if (loneBlocks[loneBlocks.length - 1] === block) {
                 loneBlocks.pop();
@@ -117,13 +118,13 @@ module.exports = {
 
             ruleDef.VariableDeclaration = function(node) {
                 if (node.kind === "let" || node.kind === "const") {
-                    markLoneBlock();
+                    markLoneBlock(node);
                 }
             };
 
             ruleDef.FunctionDeclaration = function(node) {
                 if (sourceCode.getScope(node).isStrict) {
-                    markLoneBlock();
+                    markLoneBlock(node);
                 }
             };
 

package/lib/rules/no-lonely-if.js

@@ -32,7 +32,7 @@ module.exports = {
 
         return {
             IfStatement(node) {
-                const ancestors = context.getAncestors(),
+                const ancestors = sourceCode.getAncestors(node),
                     parent = ancestors.pop(),
                     grandparent = ancestors.pop();
 

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

@@ -70,6 +70,7 @@ module.exports = {
         const props = context.options[0] && context.options[0].props;
         const ignoredPropertyAssignmentsFor = context.options[0] && context.options[0].ignorePropertyModificationsFor || [];
         const ignoredPropertyAssignmentsForRegex = context.options[0] && context.options[0].ignorePropertyModificationsForRegex || [];
+        const sourceCode = context.getSourceCode();
 
         /**
          * Checks whether or not the reference modifies properties of its variable.
@@ -214,7 +215,7 @@ module.exports = {
          * @returns {void}
          */
         function checkForFunction(node) {
-            context.getDeclaredVariables(node).forEach(checkVariable);
+            sourceCode.getDeclaredVariables(node).forEach(checkVariable);
         }
 
         return {

package/lib/rules/no-restricted-exports.js

@@ -99,6 +99,7 @@ module.exports = {
 
         const restrictedNames = new Set(context.options[0] && context.options[0].restrictedNamedExports);
         const restrictDefaultExports = context.options[0] && context.options[0].restrictDefaultExports;
+        const sourceCode = context.getSourceCode();
 
         /**
          * Checks and reports given exported name.
@@ -176,7 +177,7 @@ module.exports = {
                     if (declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") {
                         checkExportedName(declaration.id);
                     } else if (declaration.type === "VariableDeclaration") {
-                        context.getDeclaredVariables(declaration)
+                        sourceCode.getDeclaredVariables(declaration)
                             .map(v => v.defs.find(d => d.parent === declaration))
                             .map(d => d.name) // Identifier nodes
                             .forEach(checkExportedName);

package/lib/rules/no-shadow-restricted-names.js

@@ -43,10 +43,11 @@ module.exports = {
 
 
         const RESTRICTED = new Set(["undefined", "NaN", "Infinity", "arguments", "eval"]);
+        const sourceCode = context.getSourceCode();
 
         return {
             "VariableDeclaration, :function, CatchClause"(node) {
-                for (const variable of context.getDeclaredVariables(node)) {
+                for (const variable of sourceCode.getDeclaredVariables(node)) {
                     if (variable.defs.length > 0 && RESTRICTED.has(variable.name) && !safelyShadowsUndefined(variable)) {
                         context.report({
                             node: variable.defs[0].name,

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

@@ -84,6 +84,7 @@ module.exports = {
         const allowFunctionParams = typeof options.allowFunctionParams !== "undefined" ? options.allowFunctionParams : true;
         const allowInArrayDestructuring = typeof options.allowInArrayDestructuring !== "undefined" ? options.allowInArrayDestructuring : true;
         const allowInObjectDestructuring = typeof options.allowInObjectDestructuring !== "undefined" ? options.allowInObjectDestructuring : true;
+        const sourceCode = context.getSourceCode();
 
         //-------------------------------------------------------------------------
         // Helpers
@@ -213,7 +214,7 @@ module.exports = {
          * @private
          */
         function checkForDanglingUnderscoreInVariableExpression(node) {
-            context.getDeclaredVariables(node).forEach(variable => {
+            sourceCode.getDeclaredVariables(node).forEach(variable => {
                 const definition = variable.defs.find(def => def.node === node);
                 const identifierNode = definition.name;
                 const identifier = identifierNode.name;

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

@@ -70,7 +70,8 @@ module.exports = {
             allowShortCircuit = config.allowShortCircuit || false,
             allowTernary = config.allowTernary || false,
             allowTaggedTemplates = config.allowTaggedTemplates || false,
-            enforceForJSX = config.enforceForJSX || false;
+            enforceForJSX = config.enforceForJSX || false,
+            sourceCode = context.getSourceCode();
 
         /**
          * Has AST suggesting a directive.
@@ -180,7 +181,7 @@ module.exports = {
 
         return {
             ExpressionStatement(node) {
-                if (Checker.isDisallowed(node.expression) && !isDirective(node, context.getAncestors())) {
+                if (Checker.isDisallowed(node.expression) && !isDirective(node, sourceCode.getAncestors(node))) {
                     context.report({ node, messageId: "unusedExpression" });
                 }
             }

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

@@ -555,7 +555,7 @@ module.exports = {
          */
         function isAfterLastUsedArg(variable) {
             const def = variable.defs[0];
-            const params = context.getDeclaredVariables(def.node);
+            const params = sourceCode.getDeclaredVariables(def.node);
             const posteriorParams = params.slice(params.indexOf(variable) + 1);
 
             // If any used parameters occur after this parameter, do not report.

package/lib/rules/no-var.js

@@ -210,7 +210,7 @@ module.exports = {
             if (!declarator.init) {
                 return false;
             }
-            const variables = context.getDeclaredVariables(declarator);
+            const variables = sourceCode.getDeclaredVariables(declarator);
 
             return variables.some(hasReferenceInTDZ(declarator.init));
         }
@@ -268,7 +268,7 @@ module.exports = {
          * @returns {boolean} `true` if it can fix the node.
          */
         function canFix(node) {
-            const variables = context.getDeclaredVariables(node);
+            const variables = sourceCode.getDeclaredVariables(node);
             const scopeNode = getScopeNode(node);
 
             if (node.parent.type === "SwitchCase" ||

package/lib/rules/prefer-arrow-callback.js

@@ -263,7 +263,7 @@ module.exports = {
                 }
 
                 // Skip recursive functions.
-                const nameVar = context.getDeclaredVariables(node)[0];
+                const nameVar = sourceCode.getDeclaredVariables(node)[0];
 
                 if (isFunctionName(nameVar) && nameVar.references.length > 0) {
                     return;

package/lib/rules/prefer-const.js

@@ -493,7 +493,7 @@ module.exports = {
 
             VariableDeclaration(node) {
                 if (node.kind === "let" && !isInitOfForStatement(node)) {
-                    variables.push(...context.getDeclaredVariables(node));
+                    variables.push(...sourceCode.getDeclaredVariables(node));
                 }
             }
         };

package/lib/rules/prefer-promise-reject-errors.js

@@ -41,6 +41,7 @@ module.exports = {
     create(context) {
 
         const ALLOW_EMPTY_REJECT = context.options.length && context.options[0].allowEmptyReject;
+        const sourceCode = context.getSourceCode();
 
         //----------------------------------------------------------------------
         // Helpers
@@ -100,7 +101,7 @@ module.exports = {
                     node.arguments.length && astUtils.isFunction(node.arguments[0]) &&
                     node.arguments[0].params.length > 1 && node.arguments[0].params[1].type === "Identifier"
                 ) {
-                    context.getDeclaredVariables(node.arguments[0])
+                    sourceCode.getDeclaredVariables(node.arguments[0])
 
                         /*
                          * Find the first variable that matches the second parameter's name.

package/lib/rules/require-unicode-regexp.js

@@ -78,6 +78,10 @@ module.exports = {
 
                 for (const { node: refNode } of tracker.iterateGlobalReferences(trackMap)) {
                     const [patternNode, flagsNode] = refNode.arguments;
+
+                    if (patternNode && patternNode.type === "SpreadElement") {
+                        continue;
+                    }
                     const pattern = getStringIfConstant(patternNode, scope);
                     const flags = getStringIfConstant(flagsNode, scope);
 

package/lib/rules/valid-typeof.js

@@ -83,7 +83,7 @@ module.exports = {
 
             UnaryExpression(node) {
                 if (isTypeofExpression(node)) {
-                    const parent = context.getAncestors().pop();
+                    const parent = sourceCode.getAncestors(node).pop();
 
                     if (parent.type === "BinaryExpression" && OPERATORS.has(parent.operator)) {
                         const sibling = parent.left === node ? parent.right : parent.left;

package/lib/rules/wrap-regex.js

@@ -40,7 +40,7 @@ module.exports = {
                 if (nodeType === "RegularExpression") {
                     const beforeToken = sourceCode.getTokenBefore(node);
                     const afterToken = sourceCode.getTokenAfter(node);
-                    const ancestors = context.getAncestors();
+                    const ancestors = sourceCode.getAncestors(node);
                     const grandparent = ancestors[ancestors.length - 1];
 
                     if (grandparent.type === "MemberExpression" && grandparent.object === node &&

package/lib/rules/yoda.js

@@ -343,7 +343,7 @@ module.exports = {
                     ) &&
                     !(!isEqualityOperator(node.operator) && onlyEquality) &&
                     isComparisonOperator(node.operator) &&
-                    !(exceptRange && isRangeTest(context.getAncestors().pop()))
+                    !(exceptRange && isRangeTest(sourceCode.getAncestors(node).pop()))
                 ) {
                     context.report({
                         node,

package/lib/source-code/source-code.js

@@ -14,6 +14,12 @@ const
     astUtils = require("../shared/ast-utils"),
     Traverser = require("../shared/traverser");
 
+//------------------------------------------------------------------------------
+// Type Definitions
+//------------------------------------------------------------------------------
+
+/** @typedef {import("eslint-scope").Variable} Variable */
+
 //------------------------------------------------------------------------------
 // Private
 //------------------------------------------------------------------------------
@@ -639,6 +645,42 @@ class SourceCode extends TokenStore {
         return this.scopeManager.scopes[0];
     }
 
+    /**
+     * Gets all of the declared variables in the scope associated
+     * with `node`. This is a convenience method that passes through
+     * to the same method on the `scopeManager`.
+     * @param {ASTNode} node The node from which to retrieve the scope to check.
+     * @returns {Array<Variable>} An array of variable nodes representing
+     *      the declared variables in the scope associated with `node`.
+     */
+    getDeclaredVariables(node) {
+        return this.scopeManager.getDeclaredVariables(node);
+    }
+
+    /* eslint-disable class-methods-use-this -- node is owned by SourceCode */
+    /**
+     * Gets all the ancestors of a given node
+     * @param {ASTNode} node The node
+     * @returns {Array<ASTNode>} All the ancestor nodes in the AST, not including the provided node, starting
+     * from the root node at index 0 and going inwards to the parent node.
+     * @throws {TypeError} When `node` is missing.
+     */
+    getAncestors(node) {
+
+        if (!node) {
+            throw new TypeError("Missing required argument: node.");
+        }
+
+        const ancestorsStartingAtParent = [];
+
+        for (let ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
+            ancestorsStartingAtParent.push(ancestor);
+        }
+
+        return ancestorsStartingAtParent.reverse();
+    }
+    /* eslint-enable class-methods-use-this -- node is owned by SourceCode */
+
 }
 
 module.exports = SourceCode;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "8.37.0",
+  "version": "8.38.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -63,7 +63,7 @@
     "@eslint-community/eslint-utils": "^4.2.0",
     "@eslint-community/regexpp": "^4.4.0",
     "@eslint/eslintrc": "^2.0.2",
-    "@eslint/js": "8.37.0",
+    "@eslint/js": "8.38.0",
     "@humanwhocodes/config-array": "^0.11.8",
     "@humanwhocodes/module-importer": "^1.0.1",
     "@nodelib/fs.walk": "^1.2.8",