eslint 9.0.0-beta.1 → 9.0.0-beta.2

package/README.md

@@ -127,6 +127,18 @@ In other cases (including if rules need to warn on more or fewer cases due to ne
 
 Once a language feature has been adopted into the ECMAScript standard (stage 4 according to the [TC39 process](https://tc39.github.io/process-document/)), we will accept issues and pull requests related to the new feature, subject to our [contributing guidelines](https://eslint.org/docs/latest/contribute). Until then, please use the appropriate parser and plugin(s) for your experimental feature.
 
+### Which Node.js versions does ESLint support?
+
+ESLint updates the supported Node.js versions with each major release of ESLint. At that time, ESLint's supported Node.js versions are updated to be:
+
+1. The most recent maintenance release of Node.js
+1. The lowest minor version of the Node.js LTS release that includes the features the ESLint team wants to use.
+1. The Node.js Current release
+
+ESLint is also expected to work with Node.js versions released after the Node.js Current release.
+
+Refer to the [Quick Start Guide](https://eslint.org/docs/latest/use/getting-started#prerequisites) for the officially supported Node.js versions for a given ESLint release.
+
 ### Where to ask for help?
 
 Open a [discussion](https://github.com/eslint/eslint/discussions) or stop by our [Discord server](https://eslint.org/chat).
@@ -213,6 +225,11 @@ The people who manage releases, review feature requests, and meet regularly to e
 Nicholas C. Zakas
 </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" alt="Francesco Trotta's Avatar"><br />
+Francesco Trotta
+</a>
+</td><td align="center" valign="top" width="11%">
 <a href="https://github.com/mdjermanovic">
 <img src="https://github.com/mdjermanovic.png?s=75" width="75" height="75" alt="Milos Djermanovic's Avatar"><br />
 Milos Djermanovic
@@ -250,11 +267,6 @@ Bryan Mishkin
 Josh Goldberg ✨
 </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" alt="Francesco Trotta's Avatar"><br />
-Francesco Trotta
-</a>
-</td><td align="center" valign="top" width="11%">
 <a href="https://github.com/Tanujkanti4441">
 <img src="https://github.com/Tanujkanti4441.png?s=75" width="75" height="75" alt="Tanuj Kanti's Avatar"><br />
 Tanuj Kanti

package/lib/config/rule-validator.js

@@ -167,9 +167,22 @@ class RuleValidator {
                 validateRule(ruleOptions.slice(1));
 
                 if (validateRule.errors) {
-                    throw new Error(`Key "rules": Key "${ruleId}": ${
+                    throw new Error(`Key "rules": Key "${ruleId}":\n${
                         validateRule.errors.map(
-                            error => `\tValue ${JSON.stringify(error.data)} ${error.message}.\n`
+                            error => {
+                                if (
+                                    error.keyword === "additionalProperties" &&
+                                    error.schema === false &&
+                                    typeof error.parentSchema?.properties === "object" &&
+                                    typeof error.params?.additionalProperty === "string"
+                                ) {
+                                    const expectedProperties = Object.keys(error.parentSchema.properties).map(property => `"${property}"`);
+
+                                    return `\tValue ${JSON.stringify(error.data)} ${error.message}.\n\t\tUnexpected property "${error.params.additionalProperty}". Expected properties: ${expectedProperties.join(", ")}.\n`;
+                                }
+
+                                return `\tValue ${JSON.stringify(error.data)} ${error.message}.\n`;
+                            }
                         ).join("")
                     }`);
                 }

package/lib/eslint/eslint.js

@@ -838,6 +838,7 @@ class ESLint {
             configs,
             errorOnUnmatchedPattern
         });
+        const controller = new AbortController();
 
         debug(`${filePaths.length} files found in: ${Date.now() - startTime}ms`);
 
@@ -906,9 +907,12 @@ class ESLint {
                     fixer = message => shouldMessageBeFixed(message, config, fixTypesSet) && originalFix(message);
                 }
 
-                return fs.readFile(filePath, "utf8")
+                return fs.readFile(filePath, { encoding: "utf8", signal: controller.signal })
                     .then(text => {
 
+                        // fail immediately if an error occurred in another file
+                        controller.signal.throwIfAborted();
+
                         // do the linting
                         const result = verifyText({
                             text,
@@ -932,6 +936,9 @@ class ESLint {
                         }
 
                         return result;
+                    }).catch(error => {
+                        controller.abort(error);
+                        throw error;
                     });
 
             })

package/lib/linter/linter.js

@@ -439,6 +439,14 @@ function getDirectiveComments(sourceCode, ruleMapper, warnInlineConfig, config)
                             return;
                         }
 
+                        if (Object.hasOwn(configuredRules, name)) {
+                            problems.push(createLintingProblem({
+                                message: `Rule "${name}" is already configured by another configuration comment in the preceding code. This configuration is ignored.`,
+                                loc: comment.loc
+                            }));
+                            return;
+                        }
+
                         let ruleOptions = Array.isArray(ruleValue) ? ruleValue : [ruleValue];
 
                         /*
@@ -1706,6 +1714,14 @@ class Linter {
                             return;
                         }
 
+                        if (Object.hasOwn(mergedInlineConfig.rules, ruleId)) {
+                            inlineConfigProblems.push(createLintingProblem({
+                                message: `Rule "${ruleId}" is already configured by another configuration comment in the preceding code. This configuration is ignored.`,
+                                loc: node.loc
+                            }));
+                            return;
+                        }
+
                         try {
 
                             let ruleOptions = Array.isArray(ruleValue) ? ruleValue : [ruleValue];

package/lib/rules/complexity.js

@@ -109,6 +109,7 @@ module.exports = {
             IfStatement: increaseComplexity,
             WhileStatement: increaseComplexity,
             DoWhileStatement: increaseComplexity,
+            AssignmentPattern: increaseComplexity,
 
             // Avoid `default`
             "SwitchCase[test]": increaseComplexity,
@@ -120,6 +121,18 @@ module.exports = {
                 }
             },
 
+            MemberExpression(node) {
+                if (node.optional === true) {
+                    increaseComplexity();
+                }
+            },
+
+            CallExpression(node) {
+                if (node.optional === true) {
+                    increaseComplexity();
+                }
+            },
+
             onCodePathEnd(codePath, node) {
                 const complexity = complexities.pop();
 

package/lib/rules/no-misleading-character-class.js

@@ -3,11 +3,18 @@
  */
 "use strict";
 
-const { CALL, CONSTRUCT, ReferenceTracker, getStringIfConstant } = require("@eslint-community/eslint-utils");
+const {
+    CALL,
+    CONSTRUCT,
+    ReferenceTracker,
+    getStaticValue,
+    getStringIfConstant
+} = require("@eslint-community/eslint-utils");
 const { RegExpParser, visitRegExpAST } = require("@eslint-community/regexpp");
 const { isCombiningCharacter, isEmojiModifier, isRegionalIndicatorSymbol, isSurrogatePair } = require("./utils/unicode");
 const astUtils = require("./utils/ast-utils.js");
 const { isValidWithUnicodeFlag } = require("./utils/regular-expressions");
+const { parseStringLiteral, parseTemplateToken } = require("./utils/char-source");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -193,6 +200,33 @@ const findCharacterSequences = {
 
 const kinds = Object.keys(findCharacterSequences);
 
+/**
+ * Gets the value of the given node if it's a static value other than a regular expression object,
+ * or the node's `regex` property.
+ * The purpose of this method is to provide a replacement for `getStaticValue` in environments where certain regular expressions cannot be evaluated.
+ * A known example is Node.js 18 which does not support the `v` flag.
+ * Calling `getStaticValue` on a regular expression node with the `v` flag on Node.js 18 always returns `null`.
+ * A limitation of this method is that it can only detect a regular expression if the specified node is itself a regular expression literal node.
+ * @param {ASTNode | undefined} node The node to be inspected.
+ * @param {Scope} initialScope Scope to start finding variables. This function tries to resolve identifier references which are in the given scope.
+ * @returns {{ value: any } | { regex: { pattern: string, flags: string } } | null} The static value of the node, or `null`.
+ */
+function getStaticValueOrRegex(node, initialScope) {
+    if (!node) {
+        return null;
+    }
+    if (node.type === "Literal" && node.regex) {
+        return { regex: node.regex };
+    }
+
+    const staticValue = getStaticValue(node, initialScope);
+
+    if (staticValue?.value instanceof RegExp) {
+        return null;
+    }
+    return staticValue;
+}
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -225,62 +259,7 @@ module.exports = {
     create(context) {
         const sourceCode = context.sourceCode;
         const parser = new RegExpParser();
-
-        /**
-         * Generates a granular loc for context.report, if directly calculable.
-         * @param {Character[]} chars Individual characters being reported on.
-         * @param {Node} node Parent string node to report within.
-         * @returns {Object | null} Granular loc for context.report, if directly calculable.
-         * @see https://github.com/eslint/eslint/pull/17515
-         */
-        function generateReportLocation(chars, node) {
-
-            // Limit to to literals and expression-less templates with raw values === their value.
-            switch (node.type) {
-                case "TemplateLiteral":
-                    if (node.expressions.length || sourceCode.getText(node).slice(1, -1) !== node.quasis[0].value.cooked) {
-                        return null;
-                    }
-                    break;
-
-                case "Literal":
-                    if (typeof node.value === "string" && node.value !== node.raw.slice(1, -1)) {
-                        return null;
-                    }
-                    break;
-
-                default:
-                    return null;
-            }
-
-            return {
-                start: sourceCode.getLocFromIndex(node.range[0] + 1 + chars[0].start),
-                end: sourceCode.getLocFromIndex(node.range[0] + 1 + chars.at(-1).end)
-            };
-        }
-
-        /**
-         * Finds the report loc(s) for a range of matches.
-         * @param {Character[][]} matches Characters that should trigger a report.
-         * @param {Node} node The node to report.
-         * @returns {Object | null} Node loc(s) for context.report.
-         */
-        function getNodeReportLocations(matches, node) {
-            const locs = [];
-
-            for (const chars of matches) {
-                const loc = generateReportLocation(chars, node);
-
-                // If a report can't match to a range, don't report any others
-                if (!loc) {
-                    return [node.loc];
-                }
-
-                locs.push(loc);
-            }
-
-            return locs;
-        }
+        const checkedPatternNodes = new Set();
 
         /**
          * Verify a given regular expression.
@@ -320,12 +299,58 @@ module.exports = {
                             } else {
                                 foundKindMatches.set(kind, [...findCharacterSequences[kind](chars)]);
                             }
-
                         }
                     }
                 }
             });
 
+            let codeUnits = null;
+
+            /**
+             * Finds the report loc(s) for a range of matches.
+             * Only literals and expression-less templates generate granular errors.
+             * @param {Character[][]} matches Lists of individual characters being reported on.
+             * @returns {Location[]} locs for context.report.
+             * @see https://github.com/eslint/eslint/pull/17515
+             */
+            function getNodeReportLocations(matches) {
+                if (!astUtils.isStaticTemplateLiteral(node) && node.type !== "Literal") {
+                    return matches.length ? [node.loc] : [];
+                }
+                return matches.map(chars => {
+                    const firstIndex = chars[0].start;
+                    const lastIndex = chars.at(-1).end - 1;
+                    let start;
+                    let end;
+
+                    if (node.type === "TemplateLiteral") {
+                        const source = sourceCode.getText(node);
+                        const offset = node.range[0];
+
+                        codeUnits ??= parseTemplateToken(source);
+                        start = offset + codeUnits[firstIndex].start;
+                        end = offset + codeUnits[lastIndex].end;
+                    } else if (typeof node.value === "string") { // String Literal
+                        const source = node.raw;
+                        const offset = node.range[0];
+
+                        codeUnits ??= parseStringLiteral(source);
+                        start = offset + codeUnits[firstIndex].start;
+                        end = offset + codeUnits[lastIndex].end;
+                    } else { // RegExp Literal
+                        const offset = node.range[0] + 1; // Add 1 to skip the leading slash.
+
+                        start = offset + firstIndex;
+                        end = offset + lastIndex + 1;
+                    }
+
+                    return {
+                        start: sourceCode.getLocFromIndex(start),
+                        end: sourceCode.getLocFromIndex(end)
+                    };
+                });
+            }
+
             for (const [kind, matches] of foundKindMatches) {
                 let suggest;
 
@@ -336,7 +361,7 @@ module.exports = {
                     }];
                 }
 
-                const locs = getNodeReportLocations(matches, node);
+                const locs = getNodeReportLocations(matches);
 
                 for (const loc of locs) {
                     context.report({
@@ -351,6 +376,9 @@ module.exports = {
 
         return {
             "Literal[regex]"(node) {
+                if (checkedPatternNodes.has(node)) {
+                    return;
+                }
                 verify(node, node.regex.pattern, node.regex.flags, fixer => {
                     if (!isValidWithUnicodeFlag(context.languageOptions.ecmaVersion, node.regex.pattern)) {
                         return null;
@@ -371,12 +399,31 @@ module.exports = {
                 for (const { node: refNode } of tracker.iterateGlobalReferences({
                     RegExp: { [CALL]: true, [CONSTRUCT]: true }
                 })) {
+                    let pattern, flags;
                     const [patternNode, flagsNode] = refNode.arguments;
-                    const pattern = getStringIfConstant(patternNode, scope);
-                    const flags = getStringIfConstant(flagsNode, scope);
+                    const evaluatedPattern = getStaticValueOrRegex(patternNode, scope);
+
+                    if (!evaluatedPattern) {
+                        continue;
+                    }
+                    if (flagsNode) {
+                        if (evaluatedPattern.regex) {
+                            pattern = evaluatedPattern.regex.pattern;
+                            checkedPatternNodes.add(patternNode);
+                        } else {
+                            pattern = String(evaluatedPattern.value);
+                        }
+                        flags = getStringIfConstant(flagsNode, scope);
+                    } else {
+                        if (evaluatedPattern.regex) {
+                            continue;
+                        }
+                        pattern = String(evaluatedPattern.value);
+                        flags = "";
+                    }
 
-                    if (typeof pattern === "string") {
-                        verify(patternNode, pattern, flags || "", fixer => {
+                    if (typeof flags === "string") {
+                        verify(patternNode, pattern, flags, fixer => {
 
                             if (!isValidWithUnicodeFlag(context.languageOptions.ecmaVersion, pattern)) {
                                 return null;

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

@@ -34,10 +34,17 @@ const arrayOfStringsOrObjects = {
                         items: {
                             type: "string"
                         }
+                    },
+                    allowImportNames: {
+                        type: "array",
+                        items: {
+                            type: "string"
+                        }
                     }
                 },
                 additionalProperties: false,
-                required: ["name"]
+                required: ["name"],
+                not: { required: ["importNames", "allowImportNames"] }
             }
         ]
     },
@@ -66,6 +73,14 @@ const arrayOfStringsOrObjectPatterns = {
                         minItems: 1,
                         uniqueItems: true
                     },
+                    allowImportNames: {
+                        type: "array",
+                        items: {
+                            type: "string"
+                        },
+                        minItems: 1,
+                        uniqueItems: true
+                    },
                     group: {
                         type: "array",
                         items: {
@@ -77,6 +92,9 @@ const arrayOfStringsOrObjectPatterns = {
                     importNamePattern: {
                         type: "string"
                     },
+                    allowImportNamePattern: {
+                        type: "string"
+                    },
                     message: {
                         type: "string",
                         minLength: 1
@@ -86,7 +104,16 @@ const arrayOfStringsOrObjectPatterns = {
                     }
                 },
                 additionalProperties: false,
-                required: ["group"]
+                required: ["group"],
+                not: {
+                    anyOf: [
+                        { required: ["importNames", "allowImportNames"] },
+                        { required: ["importNamePattern", "allowImportNamePattern"] },
+                        { required: ["importNames", "allowImportNamePattern"] },
+                        { required: ["importNamePattern", "allowImportNames"] },
+                        { required: ["allowImportNames", "allowImportNamePattern"] }
+                    ]
+                }
             },
             uniqueItems: true
         }
@@ -131,7 +158,23 @@ module.exports = {
 
             importName: "'{{importName}}' import from '{{importSource}}' is restricted.",
             // eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
-            importNameWithCustomMessage: "'{{importName}}' import from '{{importSource}}' is restricted. {{customMessage}}"
+            importNameWithCustomMessage: "'{{importName}}' import from '{{importSource}}' is restricted. {{customMessage}}",
+
+            allowedImportName: "'{{importName}}' import from '{{importSource}}' is restricted because only '{{allowedImportNames}}' import(s) is/are allowed.",
+            // eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
+            allowedImportNameWithCustomMessage: "'{{importName}}' import from '{{importSource}}' is restricted because only '{{allowedImportNames}}' import(s) is/are allowed. {{customMessage}}",
+
+            everythingWithAllowImportNames: "* import is invalid because only '{{allowedImportNames}}' from '{{importSource}}' is/are allowed.",
+            // eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
+            everythingWithAllowImportNamesAndCustomMessage: "* import is invalid because only '{{allowedImportNames}}' from '{{importSource}}' is/are allowed. {{customMessage}}",
+
+            allowedImportNamePattern: "'{{importName}}' import from '{{importSource}}' is restricted because only imports that match the pattern '{{allowedImportNamePattern}}' are allowed from '{{importSource}}'.",
+            // eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
+            allowedImportNamePatternWithCustomMessage: "'{{importName}}' import from '{{importSource}}' is restricted because only imports that match the pattern '{{allowedImportNamePattern}}' are allowed from '{{importSource}}'. {{customMessage}}",
+
+            everythingWithAllowedImportNamePattern: "* import is invalid because only imports that match the pattern '{{allowedImportNamePattern}}' from '{{importSource}}' are allowed.",
+            // eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
+            everythingWithAllowedImportNamePatternWithCustomMessage: "* import is invalid because only imports that match the pattern '{{allowedImportNamePattern}}' from '{{importSource}}' are allowed. {{customMessage}}"
         },
 
         schema: {
@@ -175,7 +218,8 @@ module.exports = {
             } else {
                 memo[path].push({
                     message: importSource.message,
-                    importNames: importSource.importNames
+                    importNames: importSource.importNames,
+                    allowImportNames: importSource.allowImportNames
                 });
             }
             return memo;
@@ -190,12 +234,18 @@ module.exports = {
         }
 
         // relative paths are supported for this rule
-        const restrictedPatternGroups = restrictedPatterns.map(({ group, message, caseSensitive, importNames, importNamePattern }) => ({
-            matcher: ignore({ allowRelativePaths: true, ignorecase: !caseSensitive }).add(group),
-            customMessage: message,
-            importNames,
-            importNamePattern
-        }));
+        const restrictedPatternGroups = restrictedPatterns.map(
+            ({ group, message, caseSensitive, importNames, importNamePattern, allowImportNames, allowImportNamePattern }) => (
+                {
+                    matcher: ignore({ allowRelativePaths: true, ignorecase: !caseSensitive }).add(group),
+                    customMessage: message,
+                    importNames,
+                    importNamePattern,
+                    allowImportNames,
+                    allowImportNamePattern
+                }
+            )
+        );
 
         // if no imports are restricted we don't need to check
         if (Object.keys(restrictedPaths).length === 0 && restrictedPatternGroups.length === 0) {
@@ -218,42 +268,9 @@ module.exports = {
             groupedRestrictedPaths[importSource].forEach(restrictedPathEntry => {
                 const customMessage = restrictedPathEntry.message;
                 const restrictedImportNames = restrictedPathEntry.importNames;
+                const allowedImportNames = restrictedPathEntry.allowImportNames;
 
-                if (restrictedImportNames) {
-                    if (importNames.has("*")) {
-                        const specifierData = importNames.get("*")[0];
-
-                        context.report({
-                            node,
-                            messageId: customMessage ? "everythingWithCustomMessage" : "everything",
-                            loc: specifierData.loc,
-                            data: {
-                                importSource,
-                                importNames: restrictedImportNames,
-                                customMessage
-                            }
-                        });
-                    }
-
-                    restrictedImportNames.forEach(importName => {
-                        if (importNames.has(importName)) {
-                            const specifiers = importNames.get(importName);
-
-                            specifiers.forEach(specifier => {
-                                context.report({
-                                    node,
-                                    messageId: customMessage ? "importNameWithCustomMessage" : "importName",
-                                    loc: specifier.loc,
-                                    data: {
-                                        importSource,
-                                        customMessage,
-                                        importName
-                                    }
-                                });
-                            });
-                        }
-                    });
-                } else {
+                if (!restrictedImportNames && !allowedImportNames) {
                     context.report({
                         node,
                         messageId: customMessage ? "pathWithCustomMessage" : "path",
@@ -262,7 +279,72 @@ module.exports = {
                             customMessage
                         }
                     });
+
+                    return;
                 }
+
+                importNames.forEach((specifiers, importName) => {
+                    if (importName === "*") {
+                        const [specifier] = specifiers;
+
+                        if (restrictedImportNames) {
+                            context.report({
+                                node,
+                                messageId: customMessage ? "everythingWithCustomMessage" : "everything",
+                                loc: specifier.loc,
+                                data: {
+                                    importSource,
+                                    importNames: restrictedImportNames,
+                                    customMessage
+                                }
+                            });
+                        } else if (allowedImportNames) {
+                            context.report({
+                                node,
+                                messageId: customMessage ? "everythingWithAllowImportNamesAndCustomMessage" : "everythingWithAllowImportNames",
+                                loc: specifier.loc,
+                                data: {
+                                    importSource,
+                                    allowedImportNames,
+                                    customMessage
+                                }
+                            });
+                        }
+
+                        return;
+                    }
+
+                    if (restrictedImportNames && restrictedImportNames.includes(importName)) {
+                        specifiers.forEach(specifier => {
+                            context.report({
+                                node,
+                                messageId: customMessage ? "importNameWithCustomMessage" : "importName",
+                                loc: specifier.loc,
+                                data: {
+                                    importSource,
+                                    customMessage,
+                                    importName
+                                }
+                            });
+                        });
+                    }
+
+                    if (allowedImportNames && !allowedImportNames.includes(importName)) {
+                        specifiers.forEach(specifier => {
+                            context.report({
+                                node,
+                                loc: specifier.loc,
+                                messageId: customMessage ? "allowedImportNameWithCustomMessage" : "allowedImportName",
+                                data: {
+                                    importSource,
+                                    customMessage,
+                                    importName,
+                                    allowedImportNames
+                                }
+                            });
+                        });
+                    }
+                });
             });
         }
 
@@ -281,12 +363,14 @@ module.exports = {
             const customMessage = group.customMessage;
             const restrictedImportNames = group.importNames;
             const restrictedImportNamePattern = group.importNamePattern ? new RegExp(group.importNamePattern, "u") : null;
+            const allowedImportNames = group.allowImportNames;
+            const allowedImportNamePattern = group.allowImportNamePattern ? new RegExp(group.allowImportNamePattern, "u") : null;
 
-            /*
+            /**
              * If we are not restricting to any specific import names and just the pattern itself,
              * report the error and move on
              */
-            if (!restrictedImportNames && !restrictedImportNamePattern) {
+            if (!restrictedImportNames && !allowedImportNames && !restrictedImportNamePattern && !allowedImportNamePattern) {
                 context.report({
                     node,
                     messageId: customMessage ? "patternWithCustomMessage" : "patterns",
@@ -313,6 +397,28 @@ module.exports = {
                                 customMessage
                             }
                         });
+                    } else if (allowedImportNames) {
+                        context.report({
+                            node,
+                            messageId: customMessage ? "everythingWithAllowImportNamesAndCustomMessage" : "everythingWithAllowImportNames",
+                            loc: specifier.loc,
+                            data: {
+                                importSource,
+                                allowedImportNames,
+                                customMessage
+                            }
+                        });
+                    } else if (allowedImportNamePattern) {
+                        context.report({
+                            node,
+                            messageId: customMessage ? "everythingWithAllowedImportNamePatternWithCustomMessage" : "everythingWithAllowedImportNamePattern",
+                            loc: specifier.loc,
+                            data: {
+                                importSource,
+                                allowedImportNamePattern,
+                                customMessage
+                            }
+                        });
                     } else {
                         context.report({
                             node,
@@ -346,6 +452,36 @@ module.exports = {
                         });
                     });
                 }
+
+                if (allowedImportNames && !allowedImportNames.includes(importName)) {
+                    specifiers.forEach(specifier => {
+                        context.report({
+                            node,
+                            messageId: customMessage ? "allowedImportNameWithCustomMessage" : "allowedImportName",
+                            loc: specifier.loc,
+                            data: {
+                                importSource,
+                                customMessage,
+                                importName,
+                                allowedImportNames
+                            }
+                        });
+                    });
+                } else if (allowedImportNamePattern && !allowedImportNamePattern.test(importName)) {
+                    specifiers.forEach(specifier => {
+                        context.report({
+                            node,
+                            messageId: customMessage ? "allowedImportNamePatternWithCustomMessage" : "allowedImportNamePattern",
+                            loc: specifier.loc,
+                            data: {
+                                importSource,
+                                customMessage,
+                                importName,
+                                allowedImportNamePattern
+                            }
+                        });
+                    });
+                }
             });
         }
 

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

@@ -70,6 +70,9 @@ module.exports = {
                             },
                             destructuredArrayIgnorePattern: {
                                 type: "string"
+                            },
+                            ignoreClassWithStaticInitBlock: {
+                                type: "boolean"
                             }
                         },
                         additionalProperties: false
@@ -92,7 +95,8 @@ module.exports = {
             vars: "all",
             args: "after-used",
             ignoreRestSiblings: false,
-            caughtErrors: "all"
+            caughtErrors: "all",
+            ignoreClassWithStaticInitBlock: false
         };
 
         const firstOption = context.options[0];
@@ -105,6 +109,7 @@ module.exports = {
                 config.args = firstOption.args || config.args;
                 config.ignoreRestSiblings = firstOption.ignoreRestSiblings || config.ignoreRestSiblings;
                 config.caughtErrors = firstOption.caughtErrors || config.caughtErrors;
+                config.ignoreClassWithStaticInitBlock = firstOption.ignoreClassWithStaticInitBlock || config.ignoreClassWithStaticInitBlock;
 
                 if (firstOption.varsIgnorePattern) {
                     config.varsIgnorePattern = new RegExp(firstOption.varsIgnorePattern, "u");
@@ -613,6 +618,14 @@ module.exports = {
                             continue;
                         }
 
+                        if (type === "ClassName") {
+                            const hasStaticBlock = def.node.body.body.some(node => node.type === "StaticBlock");
+
+                            if (config.ignoreClassWithStaticInitBlock && hasStaticBlock) {
+                                continue;
+                            }
+                        }
+
                         // skip catch variables
                         if (type === "CatchClause") {
                             if (config.caughtErrors === "none") {

package/lib/rules/utils/char-source.js

@@ -0,0 +1,240 @@
+/**
+ * @fileoverview Utility functions to locate the source text of each code unit in the value of a string literal or template token.
+ * @author Francesco Trotta
+ */
+
+"use strict";
+
+/**
+ * Represents a code unit produced by the evaluation of a JavaScript common token like a string
+ * literal or template token.
+ */
+class CodeUnit {
+    constructor(start, source) {
+        this.start = start;
+        this.source = source;
+    }
+
+    get end() {
+        return this.start + this.length;
+    }
+
+    get length() {
+        return this.source.length;
+    }
+}
+
+/**
+ * An object used to keep track of the position in a source text where the next characters will be read.
+ */
+class TextReader {
+    constructor(source) {
+        this.source = source;
+        this.pos = 0;
+    }
+
+    /**
+     * Advances the reading position of the specified number of characters.
+     * @param {number} length Number of characters to advance.
+     * @returns {void}
+     */
+    advance(length) {
+        this.pos += length;
+    }
+
+    /**
+     * Reads characters from the source.
+     * @param {number} [offset=0] The offset where reading starts, relative to the current position.
+     * @param {number} [length=1] Number of characters to read.
+     * @returns {string} A substring of source characters.
+     */
+    read(offset = 0, length = 1) {
+        const start = offset + this.pos;
+
+        return this.source.slice(start, start + length);
+    }
+}
+
+const SIMPLE_ESCAPE_SEQUENCES =
+{ __proto__: null, b: "\b", f: "\f", n: "\n", r: "\r", t: "\t", v: "\v" };
+
+/**
+ * Reads a hex escape sequence.
+ * @param {TextReader} reader The reader should be positioned on the first hexadecimal digit.
+ * @param {number} length The number of hexadecimal digits.
+ * @returns {string} A code unit.
+ */
+function readHexSequence(reader, length) {
+    const str = reader.read(0, length);
+    const charCode = parseInt(str, 16);
+
+    reader.advance(length);
+    return String.fromCharCode(charCode);
+}
+
+/**
+ * Reads a Unicode escape sequence.
+ * @param {TextReader} reader The reader should be positioned after the "u".
+ * @returns {string} A code unit.
+ */
+function readUnicodeSequence(reader) {
+    const regExp = /\{(?<hexDigits>[\dA-Fa-f]+)\}/uy;
+
+    regExp.lastIndex = reader.pos;
+    const match = regExp.exec(reader.source);
+
+    if (match) {
+        const codePoint = parseInt(match.groups.hexDigits, 16);
+
+        reader.pos = regExp.lastIndex;
+        return String.fromCodePoint(codePoint);
+    }
+    return readHexSequence(reader, 4);
+}
+
+/**
+ * Reads an octal escape sequence.
+ * @param {TextReader} reader The reader should be positioned after the first octal digit.
+ * @param {number} maxLength The maximum number of octal digits.
+ * @returns {string} A code unit.
+ */
+function readOctalSequence(reader, maxLength) {
+    const [octalStr] = reader.read(-1, maxLength).match(/^[0-7]+/u);
+
+    reader.advance(octalStr.length - 1);
+    const octal = parseInt(octalStr, 8);
+
+    return String.fromCharCode(octal);
+}
+
+/**
+ * Reads an escape sequence or line continuation.
+ * @param {TextReader} reader The reader should be positioned on the backslash.
+ * @returns {string} A string of zero, one or two code units.
+ */
+function readEscapeSequenceOrLineContinuation(reader) {
+    const char = reader.read(1);
+
+    reader.advance(2);
+    const unitChar = SIMPLE_ESCAPE_SEQUENCES[char];
+
+    if (unitChar) {
+        return unitChar;
+    }
+    switch (char) {
+        case "x":
+            return readHexSequence(reader, 2);
+        case "u":
+            return readUnicodeSequence(reader);
+        case "\r":
+            if (reader.read() === "\n") {
+                reader.advance(1);
+            }
+
+            // fallthrough
+        case "\n":
+        case "\u2028":
+        case "\u2029":
+            return "";
+        case "0":
+        case "1":
+        case "2":
+        case "3":
+            return readOctalSequence(reader, 3);
+        case "4":
+        case "5":
+        case "6":
+        case "7":
+            return readOctalSequence(reader, 2);
+        default:
+            return char;
+    }
+}
+
+/**
+ * Reads an escape sequence or line continuation and generates the respective `CodeUnit` elements.
+ * @param {TextReader} reader The reader should be positioned on the backslash.
+ * @returns {Generator<CodeUnit>} Zero, one or two `CodeUnit` elements.
+ */
+function *mapEscapeSequenceOrLineContinuation(reader) {
+    const start = reader.pos;
+    const str = readEscapeSequenceOrLineContinuation(reader);
+    const end = reader.pos;
+    const source = reader.source.slice(start, end);
+
+    switch (str.length) {
+        case 0:
+            break;
+        case 1:
+            yield new CodeUnit(start, source);
+            break;
+        default:
+            yield new CodeUnit(start, source);
+            yield new CodeUnit(start, source);
+            break;
+    }
+}
+
+/**
+ * Parses a string literal.
+ * @param {string} source The string literal to parse, including the delimiting quotes.
+ * @returns {CodeUnit[]} A list of code units produced by the string literal.
+ */
+function parseStringLiteral(source) {
+    const reader = new TextReader(source);
+    const quote = reader.read();
+
+    reader.advance(1);
+    const codeUnits = [];
+
+    for (;;) {
+        const char = reader.read();
+
+        if (char === quote) {
+            break;
+        }
+        if (char === "\\") {
+            codeUnits.push(...mapEscapeSequenceOrLineContinuation(reader));
+        } else {
+            codeUnits.push(new CodeUnit(reader.pos, char));
+            reader.advance(1);
+        }
+    }
+    return codeUnits;
+}
+
+/**
+ * Parses a template token.
+ * @param {string} source The template token to parse, including the delimiting sequences `` ` ``, `${` and `}`.
+ * @returns {CodeUnit[]} A list of code units produced by the template token.
+ */
+function parseTemplateToken(source) {
+    const reader = new TextReader(source);
+
+    reader.advance(1);
+    const codeUnits = [];
+
+    for (;;) {
+        const char = reader.read();
+
+        if (char === "`" || char === "$" && reader.read(1) === "{") {
+            break;
+        }
+        if (char === "\\") {
+            codeUnits.push(...mapEscapeSequenceOrLineContinuation(reader));
+        } else {
+            let unitSource;
+
+            if (char === "\r" && reader.read(1) === "\n") {
+                unitSource = "\r\n";
+            } else {
+                unitSource = char;
+            }
+            codeUnits.push(new CodeUnit(reader.pos, unitSource));
+            reader.advance(unitSource.length);
+        }
+    }
+    return codeUnits;
+}
+
+module.exports = { parseStringLiteral, parseTemplateToken };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "9.0.0-beta.1",
+  "version": "9.0.0-beta.2",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -66,7 +66,7 @@
     "@eslint-community/eslint-utils": "^4.2.0",
     "@eslint-community/regexpp": "^4.6.1",
     "@eslint/eslintrc": "^3.0.2",
-    "@eslint/js": "9.0.0-beta.1",
+    "@eslint/js": "9.0.0-beta.2",
     "@humanwhocodes/config-array": "^0.11.14",
     "@humanwhocodes/module-importer": "^1.0.1",
     "@nodelib/fs.walk": "^1.2.8",