eslint 9.0.0-beta.0 → 9.0.0-beta.2

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/use-isnan.js

@@ -74,7 +74,8 @@ module.exports = {
             caseNaN: "'case NaN' can never match. Use Number.isNaN before the switch.",
             indexOfNaN: "Array prototype method '{{ methodName }}' cannot find NaN.",
             replaceWithIsNaN: "Replace with Number.isNaN.",
-            replaceWithCastingAndIsNaN: "Replace with Number.isNaN cast to a Number."
+            replaceWithCastingAndIsNaN: "Replace with Number.isNaN and cast to a Number.",
+            replaceWithFindIndex: "Replace with Array.prototype.{{ methodName }}."
         }
     },
 
@@ -126,10 +127,10 @@ module.exports = {
                 const NaNNode = isNaNIdentifier(node.left) ? node.left : node.right;
 
                 const isSequenceExpression = NaNNode.type === "SequenceExpression";
-                const isFixable = fixableOperators.has(node.operator) && !isSequenceExpression;
+                const isSuggestable = fixableOperators.has(node.operator) && !isSequenceExpression;
                 const isCastable = castableOperators.has(node.operator);
 
-                if (isFixable) {
+                if (isSuggestable) {
                     suggestedFixes.push({
                         messageId: "replaceWithIsNaN",
                         fix: getBinaryExpressionFixer(node, value => `Number.isNaN(${value})`)
@@ -184,7 +185,35 @@ module.exports = {
                     node.arguments.length === 1 &&
                     isNaNIdentifier(node.arguments[0])
                 ) {
-                    context.report({ node, messageId: "indexOfNaN", data: { methodName } });
+
+                    /*
+                     * To retain side effects, it's essential to address `NaN` beforehand, which
+                     * is not possible with fixes like `arr.findIndex(Number.isNaN)`.
+                     */
+                    const isSuggestable = node.arguments[0].type !== "SequenceExpression";
+                    const suggestedFixes = [];
+
+                    if (isSuggestable) {
+                        const shouldWrap = callee.computed;
+                        const findIndexMethod = methodName === "indexOf" ? "findIndex" : "findLastIndex";
+                        const propertyName = shouldWrap ? `"${findIndexMethod}"` : findIndexMethod;
+
+                        suggestedFixes.push({
+                            messageId: "replaceWithFindIndex",
+                            data: { methodName: findIndexMethod },
+                            fix: fixer => [
+                                fixer.replaceText(callee.property, propertyName),
+                                fixer.replaceText(node.arguments[0], "Number.isNaN")
+                            ]
+                        });
+                    }
+
+                    context.report({
+                        node,
+                        messageId: "indexOfNaN",
+                        data: { methodName },
+                        suggest: suggestedFixes
+                    });
                 }
             }
         }