eslint 9.5.0 → 9.7.0

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

@@ -147,6 +147,36 @@ module.exports = {
             }
         }
 
+        /**
+         * Determines what variable type a def is.
+         * @param  {Object} def the declaration to check
+         * @returns {VariableType} a simple name for the types of variables that this rule supports
+         */
+        function defToVariableType(def) {
+
+            /*
+             * This `destructuredArrayIgnorePattern` error report works differently from the catch
+             * clause and parameter error reports. _Both_ the `varsIgnorePattern` and the
+             * `destructuredArrayIgnorePattern` will be checked for array destructuring. However,
+             * for the purposes of the report, the currently defined behavior is to only inform the
+             * user of the `destructuredArrayIgnorePattern` if it's present (regardless of the fact
+             * that the `varsIgnorePattern` would also apply). If it's not present, the user will be
+             * informed of the `varsIgnorePattern`, assuming that's present.
+             */
+            if (config.destructuredArrayIgnorePattern && def.name.parent.type === "ArrayPattern") {
+                return "array-destructure";
+            }
+
+            switch (def.type) {
+                case "CatchClause":
+                    return "catch-clause";
+                case "Parameter":
+                    return "parameter";
+                default:
+                    return "variable";
+            }
+        }
+
         /**
          * Gets a given variable's description and configured ignore pattern
          * based on the provided variableType
@@ -167,7 +197,7 @@ module.exports = {
 
                 case "catch-clause":
                     pattern = config.caughtErrorsIgnorePattern;
-                    variableDescription = "args";
+                    variableDescription = "caught errors";
                     break;
 
                 case "parameter":
@@ -202,28 +232,7 @@ module.exports = {
             let additionalMessageData = "";
 
             if (def) {
-                let pattern;
-                let variableDescription;
-
-                switch (def.type) {
-                    case "CatchClause":
-                        if (config.caughtErrorsIgnorePattern) {
-                            [variableDescription, pattern] = getVariableDescription("catch-clause");
-                        }
-                        break;
-
-                    case "Parameter":
-                        if (config.argsIgnorePattern) {
-                            [variableDescription, pattern] = getVariableDescription("parameter");
-                        }
-                        break;
-
-                    default:
-                        if (config.varsIgnorePattern) {
-                            [variableDescription, pattern] = getVariableDescription("variable");
-                        }
-                        break;
-                }
+                const [variableDescription, pattern] = getVariableDescription(defToVariableType(def));
 
                 if (pattern && variableDescription) {
                     additionalMessageData = `. Allowed unused ${variableDescription} must match ${pattern}`;
@@ -248,14 +257,7 @@ module.exports = {
             let additionalMessageData = "";
 
             if (def) {
-                let pattern;
-                let variableDescription;
-
-                if (def.name.parent.type === "ArrayPattern" && config.destructuredArrayIgnorePattern) {
-                    [variableDescription, pattern] = getVariableDescription("array-destructure");
-                } else if (config.varsIgnorePattern) {
-                    [variableDescription, pattern] = getVariableDescription("variable");
-                }
+                const [variableDescription, pattern] = getVariableDescription(defToVariableType(def));
 
                 if (pattern && variableDescription) {
                     additionalMessageData = `. Allowed unused ${variableDescription} must match ${pattern}`;
@@ -338,7 +340,7 @@ module.exports = {
         /**
          * Determines if a variable has a sibling rest property
          * @param {Variable} variable eslint-scope variable object.
-         * @returns {boolean} True if the variable is exported, false if not.
+         * @returns {boolean} True if the variable has a sibling rest property, false if not.
          * @private
          */
         function hasRestSpreadSibling(variable) {

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

@@ -72,11 +72,11 @@ module.exports = {
         schema: [],
 
         messages: {
-            nested: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}' from within that group.",
-            forward: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}' which appears later in the pattern.",
-            backward: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}' which appears before in the same lookbehind.",
-            disjunctive: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}' which is in another alternative.",
-            intoNegativeLookaround: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}' which is in a negative lookaround."
+            nested: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} from within that group.",
+            forward: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} which appears later in the pattern.",
+            backward: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} which appears before in the same lookbehind.",
+            disjunctive: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} which is in another alternative.",
+            intoNegativeLookaround: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} which is in a negative lookaround."
         }
     },
 
@@ -104,16 +104,21 @@ module.exports = {
 
             visitRegExpAST(regExpAST, {
                 onBackreferenceEnter(bref) {
-                    const group = bref.resolved,
-                        brefPath = getPathToRoot(bref),
-                        groupPath = getPathToRoot(group);
-                    let messageId = null;
+                    const groups = [bref.resolved].flat(),
+                        brefPath = getPathToRoot(bref);
 
-                    if (brefPath.includes(group)) {
+                    const problems = groups.map(group => {
+                        const groupPath = getPathToRoot(group);
+
+                        if (brefPath.includes(group)) {
+
+                            // group is bref's ancestor => bref is nested ('nested reference') => group hasn't matched yet when bref starts to match.
+                            return {
+                                messageId: "nested",
+                                group
+                            };
+                        }
 
-                        // group is bref's ancestor => bref is nested ('nested reference') => group hasn't matched yet when bref starts to match.
-                        messageId = "nested";
-                    } else {
 
                         // Start from the root to find the lowest common ancestor.
                         let i = brefPath.length - 1,
@@ -130,35 +135,80 @@ module.exports = {
                             lowestCommonLookaround = commonPath.find(isLookaround),
                             isMatchingBackward = lowestCommonLookaround && lowestCommonLookaround.kind === "lookbehind";
 
+                        if (groupCut.at(-1).type === "Alternative") {
+
+                            // group's and bref's ancestor nodes below the lowest common ancestor are sibling alternatives => they're disjunctive.
+                            return {
+                                messageId: "disjunctive",
+                                group
+                            };
+                        }
                         if (!isMatchingBackward && bref.end <= group.start) {
 
                             // bref is left, group is right ('forward reference') => group hasn't matched yet when bref starts to match.
-                            messageId = "forward";
-                        } else if (isMatchingBackward && group.end <= bref.start) {
+                            return {
+                                messageId: "forward",
+                                group
+                            };
+                        }
+                        if (isMatchingBackward && group.end <= bref.start) {
 
                             // the opposite of the previous when the regex is matching backward in a lookbehind context.
-                            messageId = "backward";
-                        } else if (groupCut.at(-1).type === "Alternative") {
-
-                            // group's and bref's ancestor nodes below the lowest common ancestor are sibling alternatives => they're disjunctive.
-                            messageId = "disjunctive";
-                        } else if (groupCut.some(isNegativeLookaround)) {
+                            return {
+                                messageId: "backward",
+                                group
+                            };
+                        }
+                        if (groupCut.some(isNegativeLookaround)) {
 
                             // group is in a negative lookaround which isn't bref's ancestor => group has already failed when bref starts to match.
-                            messageId = "intoNegativeLookaround";
+                            return {
+                                messageId: "intoNegativeLookaround",
+                                group
+                            };
                         }
+
+                        return null;
+                    });
+
+                    if (problems.length === 0 || problems.some(problem => !problem)) {
+
+                        // If there are no problems or no problems with any group then do not report it.
+                        return;
                     }
 
-                    if (messageId) {
-                        context.report({
-                            node,
-                            messageId,
-                            data: {
-                                bref: bref.raw,
-                                group: group.raw
-                            }
-                        });
+                    let problemsToReport;
+
+                    // Gets problems that appear in the same disjunction.
+                    const problemsInSameDisjunction = problems.filter(problem => problem.messageId !== "disjunctive");
+
+                    if (problemsInSameDisjunction.length) {
+
+                        // Only report problems that appear in the same disjunction.
+                        problemsToReport = problemsInSameDisjunction;
+                    } else {
+
+                        // If all groups appear in different disjunctions, report it.
+                        problemsToReport = problems;
                     }
+
+                    const [{ messageId, group }, ...other] = problemsToReport;
+                    let otherGroups = "";
+
+                    if (other.length === 1) {
+                        otherGroups = " and another group";
+                    } else if (other.length > 1) {
+                        otherGroups = ` and other ${other.length} groups`;
+                    }
+                    context.report({
+                        node,
+                        messageId,
+                        data: {
+                            bref: bref.raw,
+                            group: group.raw,
+                            otherGroups
+                        }
+                    });
                 }
             });
         }

package/lib/rules/utils/regular-expressions.js

@@ -8,7 +8,7 @@
 
 const { RegExpValidator } = require("@eslint-community/regexpp");
 
-const REGEXPP_LATEST_ECMA_VERSION = 2024;
+const REGEXPP_LATEST_ECMA_VERSION = 2025;
 
 /**
  * Checks if the given regular expression pattern would be valid with the `u` flag.

package/lib/shared/flags.js

@@ -0,0 +1,26 @@
+/**
+ * @fileoverview Shared flags for ESLint.
+ */
+
+"use strict";
+
+/**
+ * The set of flags that change ESLint behavior with a description.
+ * @type {Map<string, string>}
+ */
+const activeFlags = new Map([
+    ["test_only", "This flag is only used for testing."]
+]);
+
+/**
+ * The set of flags that used to be active but no longer have an effect.
+ * @type {Map<string, string>}
+ */
+const inactiveFlags = new Map([
+    ["test_only_old", "This flag is no longer used for testing."]
+]);
+
+module.exports = {
+    activeFlags,
+    inactiveFlags
+};

package/lib/shared/logging.js

@@ -11,7 +11,7 @@
 module.exports = {
 
     /**
-     * Cover for console.log
+     * Cover for console.info
      * @param {...any} args The elements to log.
      * @returns {void}
      */
@@ -19,6 +19,15 @@ module.exports = {
         console.log(...args);
     },
 
+    /**
+     * Cover for console.warn
+     * @param {...any} args The elements to log.
+     * @returns {void}
+     */
+    warn(...args) {
+        console.warn(...args);
+    },
+
     /**
      * Cover for console.error
      * @param {...any} args The elements to log.

package/lib/shared/types.js

@@ -21,7 +21,7 @@ module.exports = {};
 /**
  * @typedef {Object} ParserOptions
  * @property {EcmaFeatures} [ecmaFeatures] The optional features.
- * @property {3|5|6|7|8|9|10|11|12|13|14|15|2015|2016|2017|2018|2019|2020|2021|2022|2023|2024} [ecmaVersion] The ECMAScript version (or revision number).
+ * @property {3|5|6|7|8|9|10|11|12|13|14|15|16|2015|2016|2017|2018|2019|2020|2021|2022|2023|2024|2025} [ecmaVersion] The ECMAScript version (or revision number).
  * @property {"script"|"module"} [sourceType] The source code type.
  * @property {boolean} [allowReserved] Allowing the use of reserved words as identifiers in ES3.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "9.5.0",
+  "version": "9.7.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -67,10 +67,10 @@
   "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-community/regexpp": "^4.11.0",
+    "@eslint/config-array": "^0.17.0",
     "@eslint/eslintrc": "^3.1.0",
-    "@eslint/js": "9.5.0",
+    "@eslint/js": "9.7.0",
     "@humanwhocodes/module-importer": "^1.0.1",
     "@humanwhocodes/retry": "^0.3.0",
     "@nodelib/fs.walk": "^1.2.8",
@@ -79,9 +79,9 @@
     "cross-spawn": "^7.0.2",
     "debug": "^4.3.2",
     "escape-string-regexp": "^4.0.0",
-    "eslint-scope": "^8.0.1",
+    "eslint-scope": "^8.0.2",
     "eslint-visitor-keys": "^4.0.0",
-    "espree": "^10.0.1",
+    "espree": "^10.1.0",
     "esquery": "^1.5.0",
     "esutils": "^2.0.2",
     "fast-deep-equal": "^3.1.3",
@@ -104,13 +104,12 @@
   "devDependencies": {
     "@babel/core": "^7.4.3",
     "@babel/preset-env": "^7.4.3",
-    "@eslint-community/eslint-plugin-eslint-comments": "^4.3.0",
+    "@eslint/core": "^0.1.0",
     "@types/estree": "^1.0.5",
     "@types/node": "^20.11.5",
     "@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",
@@ -122,11 +121,8 @@
     "eslint": "file:.",
     "eslint-config-eslint": "file:packages/eslint-config-eslint",
     "eslint-plugin-eslint-plugin": "^6.0.0",
-    "eslint-plugin-internal-rules": "file:tools/internal-rules",
-    "eslint-plugin-jsdoc": "^48.2.3",
-    "eslint-plugin-n": "^17.2.0",
-    "eslint-plugin-unicorn": "^52.0.0",
     "eslint-release": "^3.2.2",
+    "eslint-rule-composer": "^0.3.0",
     "eslump": "^3.0.0",
     "esprima": "^4.0.1",
     "fast-glob": "^3.2.11",
@@ -136,7 +132,7 @@
     "got": "^11.8.3",
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.0",
-    "knip": "^5.8.0",
+    "knip": "^5.21.0",
     "lint-staged": "^11.0.0",
     "load-perf": "^0.2.0",
     "markdown-it": "^12.2.0",