eslint 9.3.0 → 9.5.0

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/lib/rules/no-sparse-arrays.js

@@ -4,6 +4,8 @@
  */
 "use strict";
 
+const astUtils = require("./utils/ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -36,11 +38,32 @@ module.exports = {
         return {
 
             ArrayExpression(node) {
+                if (!node.elements.includes(null)) {
+                    return;
+                }
+
+                const { sourceCode } = context;
+                let commaToken;
+
+                for (const [index, element] of node.elements.entries()) {
+                    if (index === node.elements.length - 1 && element) {
+                        return;
+                    }
+
+                    commaToken = sourceCode.getTokenAfter(
+                        element ?? commaToken ?? sourceCode.getFirstToken(node),
+                        astUtils.isCommaToken
+                    );
 
-                const emptySpot = node.elements.includes(null);
+                    if (element) {
+                        continue;
+                    }
 
-                if (emptySpot) {
-                    context.report({ node, messageId: "unexpectedSparseArray" });
+                    context.report({
+                        node,
+                        loc: commaToken.loc,
+                        messageId: "unexpectedSparseArray"
+                    });
                 }
             }
 

package/messages/all-matched-files-ignored.js

@@ -0,0 +1,21 @@
+"use strict";
+
+module.exports = function(it) {
+    const { pattern } = it;
+
+    return `
+You are linting "${pattern}", but all of the files matching the glob pattern "${pattern}" are ignored.
+
+If you don't want to lint these files, remove the pattern "${pattern}" from the list of arguments passed to ESLint.
+
+If you do want to lint these files, explicitly list one or more of the files from this glob that you'd like to lint to see more details about why they are ignored.
+
+  * If the file is ignored because of a matching ignore pattern, check global ignores in your config file.
+    https://eslint.org/docs/latest/use/configure/ignore
+
+  * If the file is ignored because no matching configuration was supplied, check file patterns in your config file.
+    https://eslint.org/docs/latest/use/configure/configuration-files#specifying-files-with-arbitrary-extensions
+
+  * If the file is ignored because it is located outside of the base path, change the location of your config file to be in a parent directory.
+`.trimStart();
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "9.3.0",
+  "version": "9.5.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -62,15 +62,15 @@
     "messages"
   ],
   "repository": "eslint/eslint",
-  "funding": "https://opencollective.com/eslint",
+  "funding": "https://eslint.org/donate",
   "homepage": "https://eslint.org",
   "bugs": "https://github.com/eslint/eslint/issues/",
   "dependencies": {
     "@eslint-community/eslint-utils": "^4.2.0",
     "@eslint-community/regexpp": "^4.6.1",
+    "@eslint/config-array": "^0.16.0",
     "@eslint/eslintrc": "^3.1.0",
-    "@eslint/js": "9.3.0",
-    "@humanwhocodes/config-array": "^0.13.0",
+    "@eslint/js": "9.5.0",
     "@humanwhocodes/module-importer": "^1.0.1",
     "@humanwhocodes/retry": "^0.3.0",
     "@nodelib/fs.walk": "^1.2.8",
@@ -82,7 +82,7 @@
     "eslint-scope": "^8.0.1",
     "eslint-visitor-keys": "^4.0.0",
     "espree": "^10.0.1",
-    "esquery": "^1.4.2",
+    "esquery": "^1.5.0",
     "esutils": "^2.0.2",
     "fast-deep-equal": "^3.1.3",
     "file-entry-cache": "^8.0.0",
@@ -107,11 +107,11 @@
     "@eslint-community/eslint-plugin-eslint-comments": "^4.3.0",
     "@types/estree": "^1.0.5",
     "@types/node": "^20.11.5",
-    "@wdio/browser-runner": "^8.14.6",
-    "@wdio/cli": "^8.14.6",
-    "@wdio/concise-reporter": "^8.14.0",
-    "@wdio/globals": "^8.14.6",
-    "@wdio/mocha-framework": "^8.14.0",
+    "@wdio/browser-runner": "^8.38.3",
+    "@wdio/cli": "^8.38.2",
+    "@wdio/concise-reporter": "^8.38.2",
+    "@wdio/globals": "^8.38.2",
+    "@wdio/mocha-framework": "^8.38.2",
     "babel-loader": "^8.0.5",
     "c8": "^7.12.0",
     "chai": "^4.0.1",
@@ -142,7 +142,7 @@
     "markdown-it": "^12.2.0",
     "markdown-it-container": "^3.0.0",
     "markdownlint": "^0.34.0",
-    "markdownlint-cli": "^0.40.0",
+    "markdownlint-cli": "^0.41.0",
     "marked": "^4.0.8",
     "metascraper": "^5.25.7",
     "metascraper-description": "^5.25.7",