eslint 9.3.0 → 9.4.0

package/lib/cli.js

@@ -448,14 +448,14 @@ const cli = {
 
         if (options.inspectConfig) {
 
-            log.info("You can also run this command directly using 'npx @eslint/config-inspector' in the same directory as your configuration file.");
+            log.info("You can also run this command directly using 'npx @eslint/config-inspector@latest' in the same directory as your configuration file.");
 
             try {
                 const flatOptions = await translateOptions(options, "flat");
                 const spawn = require("cross-spawn");
                 const flags = await cli.calculateInspectConfigFlags(flatOptions.overrideConfigFile);
 
-                spawn.sync("npx", ["@eslint/config-inspector", ...flags], { encoding: "utf8", stdio: "inherit" });
+                spawn.sync("npx", ["@eslint/config-inspector@latest", ...flags], { encoding: "utf8", stdio: "inherit" });
             } catch (error) {
                 log.error(error);
                 return 2;

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

@@ -9,7 +9,7 @@
 // Requirements
 //-----------------------------------------------------------------------------
 
-const { ConfigArray, ConfigArraySymbol } = require("@humanwhocodes/config-array");
+const { ConfigArray, ConfigArraySymbol } = require("@eslint/config-array");
 const { flatConfigSchema } = require("./flat-config-schema");
 const { RuleValidator } = require("./rule-validator");
 const { defaultConfig } = require("./default-config");

package/lib/eslint/eslint-helpers.js

@@ -335,15 +335,15 @@ async function globSearch({
 
                             /*
                              * We updated the unmatched patterns set only if the path
-                             * matches and the file isn't ignored. If the file is
-                             * ignored, that means there wasn't a match for the
+                             * matches and the file has a config. If the file has no
+                             * config, that means there wasn't a match for the
                              * pattern so it should not be removed.
                              *
-                             * Performance note: isFileIgnored() aggressively caches
+                             * Performance note: `getConfig()` aggressively caches
                              * results so there is no performance penalty for calling
-                             * it twice with the same argument.
+                             * it multiple times with the same argument.
                              */
-                            if (pathMatches && !configs.isFileIgnored(entry.path)) {
+                            if (pathMatches && configs.getConfig(entry.path)) {
                                 unmatchedPatterns.delete(matcher.pattern);
                             }
 
@@ -351,7 +351,7 @@ async function globSearch({
                         }, false)
                         : matchers.some(matcher => matcher.match(relativePath));
 
-                    return matchesPattern && !configs.isFileIgnored(entry.path);
+                    return matchesPattern && configs.getConfig(entry.path) !== void 0;
                 })
             },
             (error, entries) => {
@@ -545,7 +545,7 @@ async function findFiles({
             if (stat.isFile()) {
                 results.push({
                     filePath,
-                    ignored: configs.isFileIgnored(filePath)
+                    ignored: !configs.getConfig(filePath)
                 });
             }
 

package/lib/eslint/eslint.js

@@ -509,7 +509,7 @@ function verifyText({
              * @returns {boolean} `true` if the linter should adopt the code block.
              */
             filterCodeBlock(blockFilename) {
-                return configs.isExplicitMatch(blockFilename);
+                return configs.getConfig(blockFilename) !== void 0;
             }
         }
     );
@@ -881,15 +881,6 @@ class ESLint {
 
                 const config = configs.getConfig(filePath);
 
-                /*
-                 * Sometimes a file found through a glob pattern will
-                 * be ignored. In this case, `config` will be undefined
-                 * and we just silently ignore the file.
-                 */
-                if (!config) {
-                    return void 0;
-                }
-
                 // Skip if there is cached result.
                 if (lintResultCache) {
                     const cachedResult =

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

@@ -28,7 +28,7 @@ const ajv = require("../shared/ajv")({ strictDefaults: true });
 
 const parserSymbol = Symbol.for("eslint.RuleTester.parser");
 const { SourceCode } = require("../source-code");
-const { ConfigArraySymbol } = require("@humanwhocodes/config-array");
+const { ConfigArraySymbol } = require("@eslint/config-array");
 const { isSerializable } = require("../shared/serialization");
 
 //------------------------------------------------------------------------------

package/lib/rules/func-style.js

@@ -14,7 +14,7 @@ module.exports = {
         type: "suggestion",
 
         docs: {
-            description: "Enforce the consistent use of either `function` declarations or expressions",
+            description: "Enforce the consistent use of either `function` declarations or expressions assigned to variables",
             recommended: false,
             url: "https://eslint.org/docs/latest/rules/func-style"
         },
@@ -100,7 +100,7 @@ module.exports = {
                 stack.pop();
             },
 
-            ThisExpression() {
+            "ThisExpression, Super"() {
                 if (stack.length > 0) {
                     stack[stack.length - 1] = true;
                 }
@@ -113,9 +113,9 @@ module.exports = {
             };
 
             nodesToCheck["ArrowFunctionExpression:exit"] = function(node) {
-                const hasThisExpr = stack.pop();
+                const hasThisOrSuperExpr = stack.pop();
 
-                if (!hasThisExpr && node.parent.type === "VariableDeclarator") {
+                if (!hasThisOrSuperExpr && node.parent.type === "VariableDeclarator") {
                     if (
                         enforceDeclarations &&
                         (typeof exportFunctionStyle === "undefined" || node.parent.parent.parent.type !== "ExportNamedDeclaration")

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

@@ -49,7 +49,7 @@ module.exports = {
                 if (
                     last.parent.type === "MethodDefinition" &&
                     last.parent.kind === "constructor" &&
-                    (node.parent.parent === last || node.argument)
+                    node.argument
                 ) {
                     context.report({
                         node,

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

@@ -9,140 +9,16 @@
 // Helpers
 //------------------------------------------------------------------------------
 
-/**
- * Gets the containing loop node of a specified node.
- *
- * We don't need to check nested functions, so this ignores those.
- * `Scope.through` contains references of nested functions.
- * @param {ASTNode} node An AST node to get.
- * @returns {ASTNode|null} The containing loop node of the specified node, or
- *      `null`.
- */
-function getContainingLoopNode(node) {
-    for (let currentNode = node; currentNode.parent; currentNode = currentNode.parent) {
-        const parent = currentNode.parent;
-
-        switch (parent.type) {
-            case "WhileStatement":
-            case "DoWhileStatement":
-                return parent;
-
-            case "ForStatement":
-
-                // `init` is outside of the loop.
-                if (parent.init !== currentNode) {
-                    return parent;
-                }
-                break;
-
-            case "ForInStatement":
-            case "ForOfStatement":
-
-                // `right` is outside of the loop.
-                if (parent.right !== currentNode) {
-                    return parent;
-                }
-                break;
-
-            case "ArrowFunctionExpression":
-            case "FunctionExpression":
-            case "FunctionDeclaration":
-
-                // We don't need to check nested functions.
-                return null;
-
-            default:
-                break;
-        }
-    }
-
-    return null;
-}
 
 /**
- * Gets the containing loop node of a given node.
- * If the loop was nested, this returns the most outer loop.
- * @param {ASTNode} node A node to get. This is a loop node.
- * @param {ASTNode|null} excludedNode A node that the result node should not
- *      include.
- * @returns {ASTNode} The most outer loop node.
+ * Identifies is a node is a FunctionExpression which is part of an IIFE
+ * @param {ASTNode} node Node to test
+ * @returns {boolean} True if it's an IIFE
  */
-function getTopLoopNode(node, excludedNode) {
-    const border = excludedNode ? excludedNode.range[1] : 0;
-    let retv = node;
-    let containingLoopNode = node;
-
-    while (containingLoopNode && containingLoopNode.range[0] >= border) {
-        retv = containingLoopNode;
-        containingLoopNode = getContainingLoopNode(containingLoopNode);
-    }
-
-    return retv;
+function isIIFE(node) {
+    return (node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") && node.parent && node.parent.type === "CallExpression" && node.parent.callee === node;
 }
 
-/**
- * Checks whether a given reference which refers to an upper scope's variable is
- * safe or not.
- * @param {ASTNode} loopNode A containing loop node.
- * @param {eslint-scope.Reference} reference A reference to check.
- * @returns {boolean} `true` if the reference is safe or not.
- */
-function isSafe(loopNode, reference) {
-    const variable = reference.resolved;
-    const definition = variable && variable.defs[0];
-    const declaration = definition && definition.parent;
-    const kind = (declaration && declaration.type === "VariableDeclaration")
-        ? declaration.kind
-        : "";
-
-    // Variables which are declared by `const` is safe.
-    if (kind === "const") {
-        return true;
-    }
-
-    /*
-     * Variables which are declared by `let` in the loop is safe.
-     * It's a different instance from the next loop step's.
-     */
-    if (kind === "let" &&
-        declaration.range[0] > loopNode.range[0] &&
-        declaration.range[1] < loopNode.range[1]
-    ) {
-        return true;
-    }
-
-    /*
-     * WriteReferences which exist after this border are unsafe because those
-     * can modify the variable.
-     */
-    const border = getTopLoopNode(
-        loopNode,
-        (kind === "let") ? declaration : null
-    ).range[0];
-
-    /**
-     * Checks whether a given reference is safe or not.
-     * The reference is every reference of the upper scope's variable we are
-     * looking now.
-     *
-     * It's safe if the reference matches one of the following condition.
-     * - is readonly.
-     * - doesn't exist inside a local function and after the border.
-     * @param {eslint-scope.Reference} upperRef A reference to check.
-     * @returns {boolean} `true` if the reference is safe.
-     */
-    function isSafeReference(upperRef) {
-        const id = upperRef.identifier;
-
-        return (
-            !upperRef.isWrite() ||
-            variable.scope.variableScope === upperRef.from.variableScope &&
-            id.range[0] < border
-        );
-    }
-
-    return Boolean(variable) && variable.references.every(isSafeReference);
-}
 
 //------------------------------------------------------------------------------
 // Rule Definition
@@ -168,8 +44,147 @@ module.exports = {
 
     create(context) {
 
+        const SKIPPED_IIFE_NODES = new Set();
         const sourceCode = context.sourceCode;
 
+        /**
+         * Gets the containing loop node of a specified node.
+         *
+         * We don't need to check nested functions, so this ignores those, with the exception of IIFE.
+         * `Scope.through` contains references of nested functions.
+         * @param {ASTNode} node An AST node to get.
+         * @returns {ASTNode|null} The containing loop node of the specified node, or
+         *      `null`.
+         */
+        function getContainingLoopNode(node) {
+            for (let currentNode = node; currentNode.parent; currentNode = currentNode.parent) {
+                const parent = currentNode.parent;
+
+                switch (parent.type) {
+                    case "WhileStatement":
+                    case "DoWhileStatement":
+                        return parent;
+
+                    case "ForStatement":
+
+                        // `init` is outside of the loop.
+                        if (parent.init !== currentNode) {
+                            return parent;
+                        }
+                        break;
+
+                    case "ForInStatement":
+                    case "ForOfStatement":
+
+                        // `right` is outside of the loop.
+                        if (parent.right !== currentNode) {
+                            return parent;
+                        }
+                        break;
+
+                    case "ArrowFunctionExpression":
+                    case "FunctionExpression":
+                    case "FunctionDeclaration":
+
+                        // We need to check nested functions only in case of IIFE.
+                        if (SKIPPED_IIFE_NODES.has(parent)) {
+                            break;
+                        }
+
+                        return null;
+                    default:
+                        break;
+                }
+            }
+
+            return null;
+        }
+
+        /**
+         * Gets the containing loop node of a given node.
+         * If the loop was nested, this returns the most outer loop.
+         * @param {ASTNode} node A node to get. This is a loop node.
+         * @param {ASTNode|null} excludedNode A node that the result node should not
+         *      include.
+         * @returns {ASTNode} The most outer loop node.
+         */
+        function getTopLoopNode(node, excludedNode) {
+            const border = excludedNode ? excludedNode.range[1] : 0;
+            let retv = node;
+            let containingLoopNode = node;
+
+            while (containingLoopNode && containingLoopNode.range[0] >= border) {
+                retv = containingLoopNode;
+                containingLoopNode = getContainingLoopNode(containingLoopNode);
+            }
+
+            return retv;
+        }
+
+        /**
+         * Checks whether a given reference which refers to an upper scope's variable is
+         * safe or not.
+         * @param {ASTNode} loopNode A containing loop node.
+         * @param {eslint-scope.Reference} reference A reference to check.
+         * @returns {boolean} `true` if the reference is safe or not.
+         */
+        function isSafe(loopNode, reference) {
+            const variable = reference.resolved;
+            const definition = variable && variable.defs[0];
+            const declaration = definition && definition.parent;
+            const kind = (declaration && declaration.type === "VariableDeclaration")
+                ? declaration.kind
+                : "";
+
+            // Variables which are declared by `const` is safe.
+            if (kind === "const") {
+                return true;
+            }
+
+            /*
+             * Variables which are declared by `let` in the loop is safe.
+             * It's a different instance from the next loop step's.
+             */
+            if (kind === "let" &&
+                declaration.range[0] > loopNode.range[0] &&
+                declaration.range[1] < loopNode.range[1]
+            ) {
+                return true;
+            }
+
+            /*
+             * WriteReferences which exist after this border are unsafe because those
+             * can modify the variable.
+             */
+            const border = getTopLoopNode(
+                loopNode,
+                (kind === "let") ? declaration : null
+            ).range[0];
+
+            /**
+             * Checks whether a given reference is safe or not.
+             * The reference is every reference of the upper scope's variable we are
+             * looking now.
+             *
+             * It's safe if the reference matches one of the following condition.
+             * - is readonly.
+             * - doesn't exist inside a local function and after the border.
+             * @param {eslint-scope.Reference} upperRef A reference to check.
+             * @returns {boolean} `true` if the reference is safe.
+             */
+            function isSafeReference(upperRef) {
+                const id = upperRef.identifier;
+
+                return (
+                    !upperRef.isWrite() ||
+                    variable.scope.variableScope === upperRef.from.variableScope &&
+                    id.range[0] < border
+                );
+            }
+
+            return Boolean(variable) && variable.references.every(isSafeReference);
+        }
+
         /**
          * Reports functions which match the following condition:
          *
@@ -186,6 +201,23 @@ module.exports = {
             }
 
             const references = sourceCode.getScope(node).through;
+
+            // Check if the function is not asynchronous or a generator function
+            if (!(node.async || node.generator)) {
+                if (isIIFE(node)) {
+
+                    const isFunctionExpression = node.type === "FunctionExpression";
+
+                    // Check if the function is referenced elsewhere in the code
+                    const isFunctionReferenced = isFunctionExpression && node.id ? references.some(r => r.identifier.name === node.id.name) : false;
+
+                    if (!isFunctionReferenced) {
+                        SKIPPED_IIFE_NODES.add(node);
+                        return;
+                    }
+                }
+            }
+
             const unsafeRefs = references.filter(r => r.resolved && !isSafe(loopNode, r)).map(r => r.identifier.name);
 
             if (unsafeRefs.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "9.3.0",
+  "version": "9.4.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -68,9 +68,9 @@
   "dependencies": {
     "@eslint-community/eslint-utils": "^4.2.0",
     "@eslint-community/regexpp": "^4.6.1",
+    "@eslint/config-array": "^0.15.1",
     "@eslint/eslintrc": "^3.1.0",
-    "@eslint/js": "9.3.0",
-    "@humanwhocodes/config-array": "^0.13.0",
+    "@eslint/js": "9.4.0",
     "@humanwhocodes/module-importer": "^1.0.1",
     "@humanwhocodes/retry": "^0.3.0",
     "@nodelib/fs.walk": "^1.2.8",