eslint 8.36.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/config/default-config.js

@@ -19,9 +19,6 @@ exports.defaultConfig = [
     {
         plugins: {
             "@": {
-                parsers: {
-                    espree: require("espree")
-                },
 
                 /*
                  * Because we try to delay loading rules until absolutely
@@ -43,7 +40,7 @@ exports.defaultConfig = [
         languageOptions: {
             sourceType: "module",
             ecmaVersion: "latest",
-            parser: "@/espree",
+            parser: require("espree"),
             parserOptions: {}
         }
     },

package/lib/config/flat-config-array.js

@@ -192,17 +192,7 @@ class FlatConfigArray extends ConfigArray {
         if (languageOptions && languageOptions.parser) {
             const { parser } = languageOptions;
 
-            if (typeof parser === "string") {
-                const { pluginName, objectName: localParserName } = splitPluginIdentifier(parser);
-
-                parserName = parser;
-
-                if (!plugins || !plugins[pluginName] || !plugins[pluginName].parsers || !plugins[pluginName].parsers[localParserName]) {
-                    throw new TypeError(`Key "parser": Could not find "${localParserName}" in plugin "${pluginName}".`);
-                }
-
-                languageOptions.parser = plugins[pluginName].parsers[localParserName];
-            } else if (typeof parser === "object") {
+            if (typeof parser === "object") {
                 parserName = getObjectId(parser);
 
                 if (!parserName) {
@@ -255,7 +245,16 @@ class FlatConfigArray extends ConfigArray {
 
                 return {
                     ...this,
-                    plugins: Object.keys(plugins),
+                    plugins: Object.entries(plugins).map(([namespace, plugin]) => {
+
+                        const pluginId = getObjectId(plugin);
+
+                        if (!pluginId) {
+                            return namespace;
+                        }
+
+                        return `${namespace}:${pluginId}`;
+                    }),
                     languageOptions: {
                         ...languageOptions,
                         parser: parserName

package/lib/config/flat-config-schema.js

@@ -179,18 +179,6 @@ function assertIsObject(value) {
     }
 }
 
-/**
- * Validates that a value is an object or a string.
- * @param {any} value The value to check.
- * @returns {void}
- * @throws {TypeError} If the value isn't an object or a string.
- */
-function assertIsObjectOrString(value) {
-    if ((!value || typeof value !== "object") && typeof value !== "string") {
-        throw new TypeError("Expected an object or string.");
-    }
-}
-
 //-----------------------------------------------------------------------------
 // Low-Level Schemas
 //-----------------------------------------------------------------------------
@@ -242,15 +230,13 @@ const globalsSchema = {
 const parserSchema = {
     merge: "replace",
     validate(value) {
-        assertIsObjectOrString(value);
 
-        if (typeof value === "object" && typeof value.parse !== "function" && typeof value.parseForESLint !== "function") {
-            throw new TypeError("Expected object to have a parse() or parseForESLint() method.");
+        if (!value || typeof value !== "object" ||
+            (typeof value.parse !== "function" && typeof value.parseForESLint !== "function")
+        ) {
+            throw new TypeError("Expected object with parse() or parseForESLint() method.");
         }
 
-        if (typeof value === "string") {
-            assertIsPluginMemberName(value);
-        }
     }
 };
 

package/lib/linter/linter.js

@@ -857,47 +857,22 @@ function parse(text, languageOptions, filePath) {
     }
 }
 
-/**
- * Gets the scope for the current node
- * @param {ScopeManager} scopeManager The scope manager for this AST
- * @param {ASTNode} currentNode The node to get the scope of
- * @returns {eslint-scope.Scope} The scope information for this node
- */
-function getScope(scopeManager, currentNode) {
-
-    // On Program node, get the outermost scope to avoid return Node.js special function scope or ES modules scope.
-    const inner = currentNode.type !== "Program";
-
-    for (let node = currentNode; node; node = node.parent) {
-        const scope = scopeManager.acquire(node, inner);
-
-        if (scope) {
-            if (scope.type === "function-expression-name") {
-                return scope.childScopes[0];
-            }
-            return scope;
-        }
-    }
-
-    return scopeManager.scopes[0];
-}
-
 /**
  * Marks a variable as used in the current scope
- * @param {ScopeManager} scopeManager The scope manager for this AST. The scope may be mutated by this function.
+ * @param {SourceCode} sourceCode The source code for the currently linted file.
  * @param {ASTNode} currentNode The node currently being traversed
  * @param {LanguageOptions} languageOptions The options used to parse this text
  * @param {string} name The name of the variable that should be marked as used.
  * @returns {boolean} True if the variable was found and marked as used, false if not.
  */
-function markVariableAsUsed(scopeManager, currentNode, languageOptions, name) {
+function markVariableAsUsed(sourceCode, currentNode, languageOptions, name) {
     const parserOptions = languageOptions.parserOptions;
     const sourceType = languageOptions.sourceType;
     const hasGlobalReturn =
         (parserOptions.ecmaFeatures && parserOptions.ecmaFeatures.globalReturn) ||
         sourceType === "commonjs";
     const specialScope = hasGlobalReturn || sourceType === "module";
-    const currentScope = getScope(scopeManager, currentNode);
+    const currentScope = sourceCode.getScope(currentNode);
 
     // Special Node.js scope means we need to start one level deeper
     const initialScope = currentScope.type === "global" && specialScope ? currentScope.childScopes[0] : currentScope;
@@ -930,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",
@@ -1021,14 +980,14 @@ 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,
-                getScope: () => getScope(sourceCode.scopeManager, currentNode),
+                getScope: () => sourceCode.getScope(currentNode),
                 getSourceCode: () => sourceCode,
-                markVariableAsUsed: name => markVariableAsUsed(sourceCode.scopeManager, currentNode, languageOptions, name),
+                markVariableAsUsed: name => markVariableAsUsed(sourceCode, currentNode, languageOptions, name),
                 parserOptions: {
                     ...languageOptions.parserOptions
                 },

package/lib/rule-tester/flat-rule-tester.js

@@ -345,7 +345,7 @@ class FlatRuleTester {
      * @returns {void}
      */
     static setDefaultConfig(config) {
-        if (typeof config !== "object") {
+        if (typeof config !== "object" || config === null) {
             throw new TypeError("FlatRuleTester.setDefaultConfig: config must be an object");
         }
         sharedDefaultConfig = config;

package/lib/rule-tester/rule-tester.js

@@ -412,7 +412,7 @@ class RuleTester {
      * @returns {void}
      */
     static setDefaultConfig(config) {
-        if (typeof config !== "object") {
+        if (typeof config !== "object" || config === null) {
             throw new TypeError("RuleTester.setDefaultConfig: config must be an object");
         }
         defaultConfig = config;

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

@@ -73,6 +73,7 @@ module.exports = {
         const ignoreImports = options.ignoreImports;
         const ignoreGlobals = options.ignoreGlobals;
         const allow = options.allow || [];
+        const sourceCode = context.getSourceCode();
 
         //--------------------------------------------------------------------------
         // Helpers
@@ -245,8 +246,8 @@ module.exports = {
         return {
 
             // Report camelcase of global variable references ------------------
-            Program() {
-                const scope = context.getScope();
+            Program(node) {
+                const scope = sourceCode.getScope(node);
 
                 if (!ignoreGlobals) {
 
@@ -295,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;
                     }
@@ -345,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/consistent-this.js

@@ -36,6 +36,7 @@ module.exports = {
 
     create(context) {
         let aliases = [];
+        const sourceCode = context.getSourceCode();
 
         if (context.options.length === 0) {
             aliases.push("that");
@@ -115,10 +116,11 @@ module.exports = {
 
         /**
          * Check each alias to ensure that is was assigned to the correct value.
+         * @param {ASTNode} node The node that represents the scope to check.
          * @returns {void}
          */
-        function ensureWasAssigned() {
-            const scope = context.getScope();
+        function ensureWasAssigned(node) {
+            const scope = sourceCode.getScope(node);
 
             aliases.forEach(alias => {
                 checkWasAssigned(alias, scope);

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

@@ -71,12 +71,14 @@ module.exports = {
     },
 
     create(context) {
+        const sourceCode = context.getSourceCode();
+
         return {
             CallExpression(node) {
-                const currentScope = context.getScope();
+                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/handle-callback-err.js

@@ -38,6 +38,7 @@ module.exports = {
     create(context) {
 
         const errorArgument = context.options[0] || "err";
+        const sourceCode = context.getSourceCode();
 
         /**
          * Checks if the given argument should be interpreted as a regexp pattern.
@@ -79,7 +80,7 @@ module.exports = {
          * @returns {void}
          */
         function checkForError(node) {
-            const scope = context.getScope(),
+            const scope = sourceCode.getScope(node),
                 parameters = getParameters(scope),
                 firstParameter = parameters[0];
 

package/lib/rules/id-blacklist.js

@@ -140,6 +140,7 @@ module.exports = {
 
         const denyList = new Set(context.options);
         const reportedNodes = new Set();
+        const sourceCode = context.getSourceCode();
 
         let globalScope;
 
@@ -231,8 +232,8 @@ module.exports = {
 
         return {
 
-            Program() {
-                globalScope = context.getScope();
+            Program(node) {
+                globalScope = sourceCode.getScope(node);
             },
 
             Identifier(node) {

package/lib/rules/id-denylist.js

@@ -121,6 +121,7 @@ module.exports = {
 
         const denyList = new Set(context.options);
         const reportedNodes = new Set();
+        const sourceCode = context.getSourceCode();
 
         let globalScope;
 
@@ -210,8 +211,8 @@ module.exports = {
 
         return {
 
-            Program() {
-                globalScope = context.getScope();
+            Program(node) {
+                globalScope = sourceCode.getScope(node);
             },
 
             [[

package/lib/rules/id-match.js

@@ -67,6 +67,7 @@ module.exports = {
             onlyDeclarations = !!options.onlyDeclarations,
             ignoreDestructuring = !!options.ignoreDestructuring;
 
+        const sourceCode = context.getSourceCode();
         let globalScope;
 
         //--------------------------------------------------------------------------
@@ -170,8 +171,8 @@ module.exports = {
 
         return {
 
-            Program() {
-                globalScope = context.getScope();
+            Program(node) {
+                globalScope = sourceCode.getScope(node);
             },
 
             Identifier(node) {

package/lib/rules/logical-assignment-operators.js

@@ -159,7 +159,7 @@ module.exports = {
         type: "suggestion",
 
         docs: {
-            description: "Require or disallow logical assignment logical operator shorthand",
+            description: "Require or disallow logical assignment operator shorthand",
             recommended: false,
             url: "https://eslint.org/docs/rules/logical-assignment-operators"
         },
@@ -206,7 +206,7 @@ module.exports = {
         const mode = context.options[0] === "never" ? "never" : "always";
         const checkIf = mode === "always" && context.options.length > 1 && context.options[1].enforceForIfStatements;
         const sourceCode = context.getSourceCode();
-        const isStrict = context.getScope().isStrict;
+        const isStrict = sourceCode.getScope(sourceCode.ast).isStrict;
 
         /**
          * Returns false if the access could be a getter
@@ -409,7 +409,7 @@ module.exports = {
                 }
 
                 const body = hasBody ? ifNode.consequent.body[0] : ifNode.consequent;
-                const scope = context.getScope();
+                const scope = sourceCode.getScope(ifNode);
                 const existence = getExistence(ifNode.test, scope);
 
                 if (

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-alert.js

@@ -101,10 +101,12 @@ module.exports = {
     },
 
     create(context) {
+        const sourceCode = context.getSourceCode();
+
         return {
             CallExpression(node) {
                 const callee = skipChainExpression(node.callee),
-                    currentScope = context.getScope();
+                    currentScope = sourceCode.getScope(node);
 
                 // without window.
                 if (callee.type === "Identifier") {

package/lib/rules/no-catch-shadow.js

@@ -39,6 +39,8 @@ module.exports = {
 
     create(context) {
 
+        const sourceCode = context.getSourceCode();
+
         //--------------------------------------------------------------------------
         // Helpers
         //--------------------------------------------------------------------------
@@ -60,7 +62,7 @@ module.exports = {
         return {
 
             "CatchClause[param!=null]"(node) {
-                let scope = context.getScope();
+                let scope = sourceCode.getScope(node);
 
                 /*
                  * When ecmaVersion >= 6, CatchClause creates its own scope

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-console.js

@@ -51,6 +51,7 @@ module.exports = {
     create(context) {
         const options = context.options[0] || {};
         const allowed = options.allow || [];
+        const sourceCode = context.getSourceCode();
 
         /**
          * Checks whether the given reference is 'console' or not.
@@ -109,8 +110,8 @@ module.exports = {
         }
 
         return {
-            "Program:exit"() {
-                const scope = context.getScope();
+            "Program:exit"(node) {
+                const scope = sourceCode.getScope(node);
                 const consoleVar = astUtils.getVariableByName(scope, "console");
                 const shadowed = consoleVar && consoleVar.defs.length > 0;
 

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-constant-binary-expression.js

@@ -453,10 +453,12 @@ module.exports = {
     },
 
     create(context) {
+        const sourceCode = context.getSourceCode();
+
         return {
             LogicalExpression(node) {
                 const { operator, left } = node;
-                const scope = context.getScope();
+                const scope = sourceCode.getScope(node);
 
                 if ((operator === "&&" || operator === "||") && isConstant(scope, left, true)) {
                     context.report({ node: left, messageId: "constantShortCircuit", data: { property: "truthiness", operator } });
@@ -465,7 +467,7 @@ module.exports = {
                 }
             },
             BinaryExpression(node) {
-                const scope = context.getScope();
+                const scope = sourceCode.getScope(node);
                 const { right, left, operator } = node;
                 const rightConstantOperand = findBinaryExpressionConstantOperand(scope, left, right, operator);
                 const leftConstantOperand = findBinaryExpressionConstantOperand(scope, right, left, operator);

package/lib/rules/no-constant-condition.js

@@ -48,6 +48,7 @@ module.exports = {
         const options = context.options[0] || {},
             checkLoops = options.checkLoops !== false,
             loopSetStack = [];
+        const sourceCode = context.getSourceCode();
 
         let loopsInCurrentScope = new Set();
 
@@ -62,7 +63,7 @@ module.exports = {
          * @private
          */
         function trackConstantConditionLoop(node) {
-            if (node.test && isConstant(context.getScope(), node.test, true)) {
+            if (node.test && isConstant(sourceCode.getScope(node), node.test, true)) {
                 loopsInCurrentScope.add(node);
             }
         }
@@ -87,7 +88,7 @@ module.exports = {
          * @private
          */
         function reportIfConstant(node) {
-            if (node.test && isConstant(context.getScope(), node.test, true)) {
+            if (node.test && isConstant(sourceCode.getScope(node), node.test, true)) {
                 context.report({ node: node.test, messageId: "unexpected" });
             }
         }

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];