eslint 9.9.1 → 9.11.0

package/lib/rules/no-invalid-regexp.js

@@ -10,7 +10,7 @@
 
 const RegExpValidator = require("@eslint-community/regexpp").RegExpValidator;
 const validator = new RegExpValidator();
-const validFlags = /[dgimsuvy]/gu;
+const validFlags = "dgimsuvy";
 const undefined1 = void 0;
 
 //------------------------------------------------------------------------------
@@ -49,13 +49,13 @@ module.exports = {
     create(context) {
 
         const options = context.options[0];
-        let allowedFlags = null;
+        let allowedFlags = [];
 
         if (options && options.allowConstructorFlags) {
-            const temp = options.allowConstructorFlags.join("").replace(validFlags, "");
+            const temp = options.allowConstructorFlags.join("").replace(new RegExp(`[${validFlags}]`, "gu"), "");
 
             if (temp) {
-                allowedFlags = new RegExp(`[${temp}]`, "gu");
+                allowedFlags = [...new Set(temp)];
             }
         }
 
@@ -125,16 +125,19 @@ module.exports = {
         /**
          * Check syntax error in a given flags.
          * @param {string|null} flags The RegExp flags to validate.
+         * @param {string|null} flagsToCheck The RegExp invalid flags.
+         * @param {string} allFlags all valid and allowed flags.
          * @returns {string|null} The syntax error.
          */
-        function validateRegExpFlags(flags) {
-            if (!flags) {
-                return null;
-            }
-            try {
-                validator.validateFlags(flags);
-            } catch {
-                return `Invalid flags supplied to RegExp constructor '${flags}'`;
+        function validateRegExpFlags(flags, flagsToCheck, allFlags) {
+            const duplicateFlags = [];
+
+            if (typeof flagsToCheck === "string") {
+                for (const flag of flagsToCheck) {
+                    if (allFlags.includes(flag)) {
+                        duplicateFlags.push(flag);
+                    }
+                }
             }
 
             /*
@@ -142,10 +145,19 @@ module.exports = {
              * but this rule may check only the flag when the pattern is unidentifiable, so check it here.
              * https://tc39.es/ecma262/multipage/text-processing.html#sec-parsepattern
              */
-            if (flags.includes("u") && flags.includes("v")) {
+            if (flags && flags.includes("u") && flags.includes("v")) {
                 return "Regex 'u' and 'v' flags cannot be used together";
             }
-            return null;
+
+            if (duplicateFlags.length > 0) {
+                return `Duplicate flags ('${duplicateFlags.join("")}') supplied to RegExp constructor`;
+            }
+
+            if (!flagsToCheck) {
+                return null;
+            }
+
+            return `Invalid flags supplied to RegExp constructor '${flagsToCheck}'`;
         }
 
         return {
@@ -154,13 +166,17 @@ module.exports = {
                     return;
                 }
 
-                let flags = getFlags(node);
+                const flags = getFlags(node);
+                let flagsToCheck = flags;
+                const allFlags = allowedFlags.length > 0 ? validFlags.split("").concat(allowedFlags) : validFlags.split("");
 
-                if (flags && allowedFlags) {
-                    flags = flags.replace(allowedFlags, "");
+                if (flags) {
+                    allFlags.forEach(flag => {
+                        flagsToCheck = flagsToCheck.replace(flag, "");
+                    });
                 }
 
-                let message = validateRegExpFlags(flags);
+                let message = validateRegExpFlags(flags, flagsToCheck, allFlags);
 
                 if (message) {
                     report(node, message);

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

@@ -4,6 +4,8 @@
  */
 "use strict";
 
+const astUtils = require("./utils/ast-utils");
+
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
@@ -143,10 +145,13 @@ module.exports = {
             url: "https://eslint.org/docs/latest/rules/no-useless-constructor"
         },
 
+        hasSuggestions: true,
+
         schema: [],
 
         messages: {
-            noUselessConstructor: "Useless constructor."
+            noUselessConstructor: "Useless constructor.",
+            removeConstructor: "Remove the constructor."
         }
     },
 
@@ -177,7 +182,18 @@ module.exports = {
             if (superClass ? isRedundantSuperCall(body, ctorParams) : (body.length === 0)) {
                 context.report({
                     node,
-                    messageId: "noUselessConstructor"
+                    messageId: "noUselessConstructor",
+                    suggest: [
+                        {
+                            messageId: "removeConstructor",
+                            *fix(fixer) {
+                                const nextToken = context.sourceCode.getTokenAfter(node);
+                                const addSemiColon = nextToken.type === "Punctuator" && nextToken.value === "[" && astUtils.needsPrecedingSemicolon(context.sourceCode, node);
+
+                                yield fixer.replaceText(node, addSemiColon ? ";" : "");
+                            }
+                        }
+                    ]
                 });
             }
         }

package/lib/rules/require-unicode-regexp.js

@@ -18,6 +18,26 @@ const {
 const astUtils = require("./utils/ast-utils.js");
 const { isValidWithUnicodeFlag } = require("./utils/regular-expressions");
 
+/**
+ * Checks whether the flag configuration should be treated as a missing flag.
+ * @param {"u"|"v"|undefined} requireFlag A particular flag to require
+ * @param {string} flags The regex flags
+ * @returns {boolean} Whether the flag configuration results in a missing flag.
+ */
+function checkFlags(requireFlag, flags) {
+    let missingFlag;
+
+    if (requireFlag === "v") {
+        missingFlag = !flags.includes("v");
+    } else if (requireFlag === "u") {
+        missingFlag = !flags.includes("u");
+    } else {
+        missingFlag = !flags.includes("u") && !flags.includes("v");
+    }
+
+    return missingFlag;
+}
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -37,31 +57,65 @@ module.exports = {
 
         messages: {
             addUFlag: "Add the 'u' flag.",
-            requireUFlag: "Use the 'u' flag."
+            addVFlag: "Add the 'v' flag.",
+            requireUFlag: "Use the 'u' flag.",
+            requireVFlag: "Use the 'v' flag."
         },
 
-        schema: []
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    requireFlag: {
+                        enum: ["u", "v"]
+                    }
+                },
+                additionalProperties: false
+            }
+        ]
     },
 
     create(context) {
 
         const sourceCode = context.sourceCode;
 
+        const {
+            requireFlag
+        } = context.options[0] ?? {};
+
         return {
             "Literal[regex]"(node) {
                 const flags = node.regex.flags || "";
 
-                if (!flags.includes("u") && !flags.includes("v")) {
+                const missingFlag = checkFlags(requireFlag, flags);
+
+                if (missingFlag) {
                     context.report({
-                        messageId: "requireUFlag",
+                        messageId: requireFlag === "v" ? "requireVFlag" : "requireUFlag",
                         node,
-                        suggest: isValidWithUnicodeFlag(context.languageOptions.ecmaVersion, node.regex.pattern)
+                        suggest: isValidWithUnicodeFlag(context.languageOptions.ecmaVersion, node.regex.pattern, requireFlag)
                             ? [
                                 {
                                     fix(fixer) {
-                                        return fixer.insertTextAfter(node, "u");
+                                        const replaceFlag = requireFlag ?? "u";
+                                        const regex = sourceCode.getText(node);
+                                        const slashPos = regex.lastIndexOf("/");
+
+                                        if (requireFlag) {
+                                            const flag = requireFlag === "u" ? "v" : "u";
+
+                                            if (regex.includes(flag, slashPos)) {
+                                                return fixer.replaceText(
+                                                    node,
+                                                    regex.slice(0, slashPos) +
+                                                    regex.slice(slashPos).replace(flag, requireFlag)
+                                                );
+                                            }
+                                        }
+
+                                        return fixer.insertTextAfter(node, replaceFlag);
                                     },
-                                    messageId: "addUFlag"
+                                    messageId: requireFlag === "v" ? "addVFlag" : "addUFlag"
                                 }
                             ]
                             : null
@@ -85,22 +139,49 @@ module.exports = {
                     const pattern = getStringIfConstant(patternNode, scope);
                     const flags = getStringIfConstant(flagsNode, scope);
 
-                    if (!flagsNode || (typeof flags === "string" && !flags.includes("u") && !flags.includes("v"))) {
+                    let missingFlag = !flagsNode;
+
+                    if (typeof flags === "string") {
+                        missingFlag = checkFlags(requireFlag, flags);
+                    }
+
+                    if (missingFlag) {
                         context.report({
-                            messageId: "requireUFlag",
+                            messageId: requireFlag === "v" ? "requireVFlag" : "requireUFlag",
                             node: refNode,
-                            suggest: typeof pattern === "string" && isValidWithUnicodeFlag(context.languageOptions.ecmaVersion, pattern)
+                            suggest: typeof pattern === "string" && isValidWithUnicodeFlag(context.languageOptions.ecmaVersion, pattern, requireFlag)
                                 ? [
                                     {
                                         fix(fixer) {
+                                            const replaceFlag = requireFlag ?? "u";
+
                                             if (flagsNode) {
                                                 if ((flagsNode.type === "Literal" && typeof flagsNode.value === "string") || flagsNode.type === "TemplateLiteral") {
                                                     const flagsNodeText = sourceCode.getText(flagsNode);
+                                                    const flag = requireFlag === "u" ? "v" : "u";
+
+                                                    if (flags.includes(flag)) {
+
+                                                        // Avoid replacing "u" in escapes like `\uXXXX`
+                                                        if (flagsNode.type === "Literal" && flagsNode.raw.includes("\\")) {
+                                                            return null;
+                                                        }
+
+                                                        // Avoid replacing "u" in expressions like "`${regularFlags}g`"
+                                                        if (flagsNode.type === "TemplateLiteral" && (
+                                                            flagsNode.expressions.length ||
+                                                            flagsNode.quasis.some(({ value: { raw } }) => raw.includes("\\"))
+                                                        )) {
+                                                            return null;
+                                                        }
+
+                                                        return fixer.replaceText(flagsNode, flagsNodeText.replace(flag, replaceFlag));
+                                                    }
 
                                                     return fixer.replaceText(flagsNode, [
                                                         flagsNodeText.slice(0, flagsNodeText.length - 1),
                                                         flagsNodeText.slice(flagsNodeText.length - 1)
-                                                    ].join("u"));
+                                                    ].join(replaceFlag));
                                                 }
 
                                                 // We intentionally don't suggest concatenating + "u" to non-literals
@@ -112,11 +193,11 @@ module.exports = {
                                             return fixer.insertTextAfter(
                                                 penultimateToken,
                                                 astUtils.isCommaToken(penultimateToken)
-                                                    ? ' "u",'
-                                                    : ', "u"'
+                                                    ? ` "${replaceFlag}",`
+                                                    : `, "${replaceFlag}"`
                                             );
                                         },
-                                        messageId: "addUFlag"
+                                        messageId: requireFlag === "v" ? "addVFlag" : "addUFlag"
                                     }
                                 ]
                                 : null

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

@@ -14,12 +14,16 @@ const REGEXPP_LATEST_ECMA_VERSION = 2025;
  * Checks if the given regular expression pattern would be valid with the `u` flag.
  * @param {number} ecmaVersion ECMAScript version to parse in.
  * @param {string} pattern The regular expression pattern to verify.
+ * @param {"u"|"v"} flag The type of Unicode flag
  * @returns {boolean} `true` if the pattern would be valid with the `u` flag.
  * `false` if the pattern would be invalid with the `u` flag or the configured
  * ecmaVersion doesn't support the `u` flag.
  */
-function isValidWithUnicodeFlag(ecmaVersion, pattern) {
-    if (ecmaVersion <= 5) { // ecmaVersion <= 5 doesn't support the 'u' flag
+function isValidWithUnicodeFlag(ecmaVersion, pattern, flag = "u") {
+    if (flag === "u" && ecmaVersion <= 5) { // ecmaVersion <= 5 doesn't support the 'u' flag
+        return false;
+    }
+    if (flag === "v" && ecmaVersion <= 2023) {
         return false;
     }
 
@@ -28,7 +32,11 @@ function isValidWithUnicodeFlag(ecmaVersion, pattern) {
     });
 
     try {
-        validator.validatePattern(pattern, void 0, void 0, { unicode: /* uFlag = */ true });
+        validator.validatePattern(pattern, void 0, void 0, flag === "u" ? {
+            unicode: /* uFlag = */ true
+        } : {
+            unicodeSets: true
+        });
     } catch {
         return false;
     }

package/lib/services/processor-service.js

@@ -0,0 +1,109 @@
+/**
+ * @fileoverview ESLint Processor Service
+ * @author Nicholas C. Zakas
+ */
+/* eslint class-methods-use-this: off -- Anticipate future constructor arguments. */
+
+"use strict";
+
+//-----------------------------------------------------------------------------
+// Requirements
+//-----------------------------------------------------------------------------
+
+const path = require("node:path");
+const { VFile } = require("../linter/vfile.js");
+
+//-----------------------------------------------------------------------------
+// Types
+//-----------------------------------------------------------------------------
+
+/** @typedef {import("../shared/types.js").LintMessage} LintMessage */
+/** @typedef {import("../linter/vfile.js").VFile} VFile */
+/** @typedef {import("@eslint/core").Language} Language */
+/** @typedef {import("@eslint/core").LanguageOptions} LanguageOptions */
+/** @typedef {import("eslint").Linter.Processor} Processor */
+
+//-----------------------------------------------------------------------------
+// Exports
+//-----------------------------------------------------------------------------
+
+/**
+ * The service that applies processors to files.
+ */
+class ProcessorService {
+
+    /**
+     * Preprocesses the given file synchronously.
+     * @param {VFile} file The file to preprocess.
+     * @param {{processor:Processor}} config The configuration to use.
+     * @returns {{ok:boolean, files?: Array<VFile>, errors?: Array<LintMessage>}} An array of preprocessed files or errors.
+     * @throws {Error} If the preprocessor returns a promise.
+     */
+    preprocessSync(file, config) {
+
+        const { processor } = config;
+        let blocks;
+
+        try {
+            blocks = processor.preprocess(file.rawBody, file.path);
+        } catch (ex) {
+
+            // If the message includes a leading line number, strip it:
+            const message = `Preprocessing error: ${ex.message.replace(/^line \d+:/iu, "").trim()}`;
+
+            return {
+                ok: false,
+                errors: [
+                    {
+                        ruleId: null,
+                        fatal: true,
+                        severity: 2,
+                        message,
+                        line: ex.lineNumber,
+                        column: ex.column,
+                        nodeType: null
+                    }
+                ]
+            };
+        }
+
+        if (typeof blocks.then === "function") {
+            throw new Error("Unsupported: Preprocessor returned a promise.");
+        }
+
+        return {
+            ok: true,
+            files: blocks.map((block, i) => {
+
+                // Legacy behavior: return the block as a string
+                if (typeof block === "string") {
+                    return block;
+                }
+
+                const filePath = path.join(file.path, `${i}_${block.filename}`);
+
+                return new VFile(filePath, block.text, {
+                    physicalPath: file.physicalPath
+                });
+            })
+        };
+
+    }
+
+    /**
+     * Postprocesses the given messages synchronously.
+     * @param {VFile} file The file to postprocess.
+     * @param {LintMessage[][]} messages The messages to postprocess.
+     * @param {{processor:Processor}} config The configuration to use.
+     * @returns {LintMessage[]} The postprocessed messages.
+     */
+    postprocessSync(file, messages, config) {
+
+        const { processor } = config;
+
+        return processor.postprocess(messages, file.path);
+    }
+
+}
+
+module.exports = { ProcessorService };

package/lib/shared/types.js

@@ -245,6 +245,6 @@ module.exports = {};
  * A formatter function.
  * @callback FormatterFunction
  * @param {LintResult[]} results The list of linting results.
- * @param {{cwd: string, maxWarningsExceeded?: MaxWarningsExceeded, rulesMeta: Record<string, RuleMeta>}} [context] A context object.
+ * @param {{cwd: string, maxWarningsExceeded?: MaxWarningsExceeded, rulesMeta: Record<string, RuleMeta>}} context A context object.
  * @returns {string | Promise<string>} Formatted text.
  */