eslint 9.22.0 → 9.23.0

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

@@ -4,17 +4,25 @@
 "use strict";
 
 const {
-    CALL,
-    CONSTRUCT,
-    ReferenceTracker,
-    getStaticValue,
-    getStringIfConstant
+	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 {
+	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");
+const {
+	parseStringLiteral,
+	parseTemplateToken,
+} = require("./utils/char-source");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -33,40 +41,39 @@ const { parseStringLiteral, parseTemplateToken } = require("./utils/char-source"
  * @param {CharacterClassElement[]} nodes The node list to iterate character sequences.
  * @returns {IterableIterator<Character[]>} The list of character sequences.
  */
-function *iterateCharacterSequence(nodes) {
-
-    /** @type {Character[]} */
-    let seq = [];
-
-    for (const node of nodes) {
-        switch (node.type) {
-            case "Character":
-                seq.push(node);
-                break;
-
-            case "CharacterClassRange":
-                seq.push(node.min);
-                yield seq;
-                seq = [node.max];
-                break;
-
-            case "CharacterSet":
-            case "CharacterClass": // [[]] nesting character class
-            case "ClassStringDisjunction": // \q{...}
-            case "ExpressionCharacterClass": // [A--B]
-                if (seq.length > 0) {
-                    yield seq;
-                    seq = [];
-                }
-                break;
-
-            // no default
-        }
-    }
-
-    if (seq.length > 0) {
-        yield seq;
-    }
+function* iterateCharacterSequence(nodes) {
+	/** @type {Character[]} */
+	let seq = [];
+
+	for (const node of nodes) {
+		switch (node.type) {
+			case "Character":
+				seq.push(node);
+				break;
+
+			case "CharacterClassRange":
+				seq.push(node.min);
+				yield seq;
+				seq = [node.max];
+				break;
+
+			case "CharacterSet":
+			case "CharacterClass": // [[]] nesting character class
+			case "ClassStringDisjunction": // \q{...}
+			case "ExpressionCharacterClass": // [A--B]
+				if (seq.length > 0) {
+					yield seq;
+					seq = [];
+				}
+				break;
+
+			// no default
+		}
+	}
+
+	if (seq.length > 0) {
+		yield seq;
+	}
 }
 
 /**
@@ -75,7 +82,7 @@ function *iterateCharacterSequence(nodes) {
  * @returns {boolean} `true` if the character node is a Unicode code point escape.
  */
 function isUnicodeCodePointEscape(char) {
-    return /^\\u\{[\da-f]+\}$/iu.test(char.raw);
+	return /^\\u\{[\da-f]+\}$/iu.test(char.raw);
 }
 
 /**
@@ -83,115 +90,119 @@ function isUnicodeCodePointEscape(char) {
  * @type {Record<string, (chars: Character[]) => IterableIterator<Character[]>>}
  */
 const findCharacterSequences = {
-    *surrogatePairWithoutUFlag(chars) {
-        for (const [index, char] of chars.entries()) {
-            const previous = chars[index - 1];
-
-            if (
-                previous && char &&
-                isSurrogatePair(previous.value, char.value) &&
-                !isUnicodeCodePointEscape(previous) &&
-                !isUnicodeCodePointEscape(char)
-            ) {
-                yield [previous, char];
-            }
-        }
-    },
-
-    *surrogatePair(chars) {
-        for (const [index, char] of chars.entries()) {
-            const previous = chars[index - 1];
-
-            if (
-                previous && char &&
-                isSurrogatePair(previous.value, char.value) &&
-                (
-                    isUnicodeCodePointEscape(previous) ||
-                    isUnicodeCodePointEscape(char)
-                )
-            ) {
-                yield [previous, char];
-            }
-        }
-    },
-
-    *combiningClass(chars, unfilteredChars) {
-
-        /*
-         * When `allowEscape` is `true`, a combined character should only be allowed if the combining mark appears as an escape sequence.
-         * This means that the base character should be considered even if it's escaped.
-         */
-        for (const [index, char] of chars.entries()) {
-            const previous = unfilteredChars[index - 1];
-
-            if (
-                previous && char &&
-                isCombiningCharacter(char.value) &&
-                !isCombiningCharacter(previous.value)
-            ) {
-                yield [previous, char];
-            }
-        }
-    },
-
-    *emojiModifier(chars) {
-        for (const [index, char] of chars.entries()) {
-            const previous = chars[index - 1];
-
-            if (
-                previous && char &&
-                isEmojiModifier(char.value) &&
-                !isEmojiModifier(previous.value)
-            ) {
-                yield [previous, char];
-            }
-        }
-    },
-
-    *regionalIndicatorSymbol(chars) {
-        for (const [index, char] of chars.entries()) {
-            const previous = chars[index - 1];
-
-            if (
-                previous && char &&
-                isRegionalIndicatorSymbol(char.value) &&
-                isRegionalIndicatorSymbol(previous.value)
-            ) {
-                yield [previous, char];
-            }
-        }
-    },
-
-    *zwj(chars) {
-        let sequence = null;
-
-        for (const [index, char] of chars.entries()) {
-            const previous = chars[index - 1];
-            const next = chars[index + 1];
-
-            if (
-                previous && char && next &&
-                char.value === 0x200d &&
-                previous.value !== 0x200d &&
-                next.value !== 0x200d
-            ) {
-                if (sequence) {
-                    if (sequence.at(-1) === previous) {
-                        sequence.push(char, next); // append to the sequence
-                    } else {
-                        yield sequence;
-                        sequence = chars.slice(index - 1, index + 2);
-                    }
-                } else {
-                    sequence = chars.slice(index - 1, index + 2);
-                }
-            }
-        }
-
-        if (sequence) {
-            yield sequence;
-        }
-    }
+	*surrogatePairWithoutUFlag(chars) {
+		for (const [index, char] of chars.entries()) {
+			const previous = chars[index - 1];
+
+			if (
+				previous &&
+				char &&
+				isSurrogatePair(previous.value, char.value) &&
+				!isUnicodeCodePointEscape(previous) &&
+				!isUnicodeCodePointEscape(char)
+			) {
+				yield [previous, char];
+			}
+		}
+	},
+
+	*surrogatePair(chars) {
+		for (const [index, char] of chars.entries()) {
+			const previous = chars[index - 1];
+
+			if (
+				previous &&
+				char &&
+				isSurrogatePair(previous.value, char.value) &&
+				(isUnicodeCodePointEscape(previous) ||
+					isUnicodeCodePointEscape(char))
+			) {
+				yield [previous, char];
+			}
+		}
+	},
+
+	*combiningClass(chars, unfilteredChars) {
+		/*
+		 * When `allowEscape` is `true`, a combined character should only be allowed if the combining mark appears as an escape sequence.
+		 * This means that the base character should be considered even if it's escaped.
+		 */
+		for (const [index, char] of chars.entries()) {
+			const previous = unfilteredChars[index - 1];
+
+			if (
+				previous &&
+				char &&
+				isCombiningCharacter(char.value) &&
+				!isCombiningCharacter(previous.value)
+			) {
+				yield [previous, char];
+			}
+		}
+	},
+
+	*emojiModifier(chars) {
+		for (const [index, char] of chars.entries()) {
+			const previous = chars[index - 1];
+
+			if (
+				previous &&
+				char &&
+				isEmojiModifier(char.value) &&
+				!isEmojiModifier(previous.value)
+			) {
+				yield [previous, char];
+			}
+		}
+	},
+
+	*regionalIndicatorSymbol(chars) {
+		for (const [index, char] of chars.entries()) {
+			const previous = chars[index - 1];
+
+			if (
+				previous &&
+				char &&
+				isRegionalIndicatorSymbol(char.value) &&
+				isRegionalIndicatorSymbol(previous.value)
+			) {
+				yield [previous, char];
+			}
+		}
+	},
+
+	*zwj(chars) {
+		let sequence = null;
+
+		for (const [index, char] of chars.entries()) {
+			const previous = chars[index - 1];
+			const next = chars[index + 1];
+
+			if (
+				previous &&
+				char &&
+				next &&
+				char.value === 0x200d &&
+				previous.value !== 0x200d &&
+				next.value !== 0x200d
+			) {
+				if (sequence) {
+					if (sequence.at(-1) === previous) {
+						sequence.push(char, next); // append to the sequence
+					} else {
+						yield sequence;
+						sequence = chars.slice(index - 1, index + 2);
+					}
+				} else {
+					sequence = chars.slice(index - 1, index + 2);
+				}
+			}
+		}
+
+		if (sequence) {
+			yield sequence;
+		}
+	},
 };
 
 const kinds = Object.keys(findCharacterSequences);
@@ -208,19 +219,19 @@ const kinds = Object.keys(findCharacterSequences);
  * @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;
+	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;
 }
 
 /**
@@ -231,12 +242,12 @@ function getStaticValueOrRegex(node, initialScope) {
  * @returns {boolean} Whether the specified regexpp character is represented as an acceptable escape sequence.
  */
 function checkForAcceptableEscape(char, charSource) {
-    if (!charSource.startsWith("\\")) {
-        return false;
-    }
-    const match = /(?<=^\\+).$/su.exec(charSource);
+	if (!charSource.startsWith("\\")) {
+		return false;
+	}
+	const match = /(?<=^\\+).$/su.exec(charSource);
 
-    return match?.[0] !== String.fromCodePoint(char.value);
+	return match?.[0] !== String.fromCodePoint(char.value);
 }
 
 /**
@@ -249,13 +260,13 @@ function checkForAcceptableEscape(char, charSource) {
  * @returns {boolean} Whether the specified regexpp character is represented as an acceptable escape sequence.
  */
 function checkForAcceptableEscapeInString(char, nodeSource, codeUnits) {
-    const firstIndex = char.start;
-    const lastIndex = char.end - 1;
-    const start = codeUnits[firstIndex].start;
-    const end = codeUnits[lastIndex].end;
-    const charSource = nodeSource.slice(start, end);
+	const firstIndex = char.start;
+	const lastIndex = char.end - 1;
+	const start = codeUnits[firstIndex].start;
+	const end = codeUnits[lastIndex].end;
+	const charSource = nodeSource.slice(start, end);
 
-    return checkForAcceptableEscape(char, charSource);
+	return checkForAcceptableEscape(char, charSource);
 }
 
 //------------------------------------------------------------------------------
@@ -264,274 +275,316 @@ function checkForAcceptableEscapeInString(char, nodeSource, codeUnits) {
 
 /** @type {import('../shared/types').Rule} */
 module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow characters which are made with multiple code points in character class syntax",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-misleading-character-class"
-        },
-
-        hasSuggestions: true,
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    allowEscape: {
-                        type: "boolean",
-                        default: false
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            surrogatePairWithoutUFlag: "Unexpected surrogate pair in character class. Use 'u' flag.",
-            surrogatePair: "Unexpected surrogate pair in character class.",
-            combiningClass: "Unexpected combined character in character class.",
-            emojiModifier: "Unexpected modified Emoji in character class.",
-            regionalIndicatorSymbol: "Unexpected national flag in character class.",
-            zwj: "Unexpected joined character sequence in character class.",
-            suggestUnicodeFlag: "Add unicode 'u' flag to regex."
-        }
-    },
-    create(context) {
-        const allowEscape = context.options[0]?.allowEscape;
-        const sourceCode = context.sourceCode;
-        const parser = new RegExpParser();
-        const checkedPatternNodes = new Set();
-
-        /**
-         * Verify a given regular expression.
-         * @param {Node} node The node to report.
-         * @param {string} pattern The regular expression pattern to verify.
-         * @param {string} flags The flags of the regular expression.
-         * @param {Function} unicodeFixer Fixer for missing "u" flag.
-         * @returns {void}
-         */
-        function verify(node, pattern, flags, unicodeFixer) {
-            let patternNode;
-
-            try {
-                patternNode = parser.parsePattern(
-                    pattern,
-                    0,
-                    pattern.length,
-                    {
-                        unicode: flags.includes("u"),
-                        unicodeSets: flags.includes("v")
-                    }
-                );
-            } catch {
-
-                // Ignore regular expressions with syntax errors
-                return;
-            }
-
-            let codeUnits = null;
-
-            /**
-             * Checks whether a specified regexpp character is represented as an acceptable escape sequence.
-             * For the purposes of this rule, an escape sequence is considered acceptable if it consists of one or more backslashes followed by the character being escaped.
-             * @param {Character} char Character to check.
-             * @returns {boolean} Whether the specified regexpp character is represented as an acceptable escape sequence.
-             */
-            function isAcceptableEscapeSequence(char) {
-                if (node.type === "Literal" && node.regex) {
-                    return checkForAcceptableEscape(char, char.raw);
-                }
-                if (node.type === "Literal" && typeof node.value === "string") {
-                    const nodeSource = node.raw;
-
-                    codeUnits ??= parseStringLiteral(nodeSource);
-
-                    return checkForAcceptableEscapeInString(char, nodeSource, codeUnits);
-                }
-                if (astUtils.isStaticTemplateLiteral(node)) {
-                    const nodeSource = sourceCode.getText(node);
-
-                    codeUnits ??= parseTemplateToken(nodeSource);
-
-                    return checkForAcceptableEscapeInString(char, nodeSource, codeUnits);
-                }
-                return false;
-            }
-
-            const foundKindMatches = new Map();
-
-            visitRegExpAST(patternNode, {
-                onCharacterClassEnter(ccNode) {
-                    for (const unfilteredChars of iterateCharacterSequence(ccNode.elements)) {
-                        let chars;
-
-                        if (allowEscape) {
-
-                            // Replace escape sequences with null to avoid having them flagged.
-                            chars = unfilteredChars.map(char => (isAcceptableEscapeSequence(char) ? null : char));
-                        } else {
-                            chars = unfilteredChars;
-                        }
-                        for (const kind of kinds) {
-                            const matches = findCharacterSequences[kind](chars, unfilteredChars);
-
-                            if (foundKindMatches.has(kind)) {
-                                foundKindMatches.get(kind).push(...matches);
-                            } else {
-                                foundKindMatches.set(kind, [...matches]);
-                            }
-                        }
-                    }
-                }
-            });
-
-            /**
-             * 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;
-
-                if (kind === "surrogatePairWithoutUFlag") {
-                    suggest = [{
-                        messageId: "suggestUnicodeFlag",
-                        fix: unicodeFixer
-                    }];
-                }
-
-                const locs = getNodeReportLocations(matches);
-
-                for (const loc of locs) {
-                    context.report({
-                        node,
-                        loc,
-                        messageId: kind,
-                        suggest
-                    });
-                }
-            }
-        }
-
-        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;
-                    }
-
-                    return fixer.insertTextAfter(node, "u");
-                });
-            },
-            "Program"(node) {
-                const scope = sourceCode.getScope(node);
-                const tracker = new ReferenceTracker(scope);
-
-                /*
-                 * Iterate calls of RegExp.
-                 * E.g., `new RegExp()`, `RegExp()`, `new window.RegExp()`,
-                 *       `const {RegExp: a} = window; new a()`, etc...
-                 */
-                for (const { node: refNode } of tracker.iterateGlobalReferences({
-                    RegExp: { [CALL]: true, [CONSTRUCT]: true }
-                })) {
-                    let pattern, flags;
-                    const [patternNode, flagsNode] = refNode.arguments;
-                    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 flags === "string") {
-                        verify(patternNode, pattern, flags, fixer => {
-
-                            if (!isValidWithUnicodeFlag(context.languageOptions.ecmaVersion, pattern)) {
-                                return null;
-                            }
-
-                            if (refNode.arguments.length === 1) {
-                                const penultimateToken = sourceCode.getLastToken(refNode, { skip: 1 }); // skip closing parenthesis
-
-                                return fixer.insertTextAfter(
-                                    penultimateToken,
-                                    astUtils.isCommaToken(penultimateToken)
-                                        ? ' "u",'
-                                        : ', "u"'
-                                );
-                            }
-
-                            if ((flagsNode.type === "Literal" && typeof flagsNode.value === "string") || flagsNode.type === "TemplateLiteral") {
-                                const range = [flagsNode.range[0], flagsNode.range[1] - 1];
-
-                                return fixer.insertTextAfterRange(range, "u");
-                            }
-
-                            return null;
-                        });
-                    }
-                }
-            }
-        };
-    }
+	meta: {
+		type: "problem",
+
+		docs: {
+			description:
+				"Disallow characters which are made with multiple code points in character class syntax",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-misleading-character-class",
+		},
+
+		hasSuggestions: true,
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					allowEscape: {
+						type: "boolean",
+						default: false,
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			surrogatePairWithoutUFlag:
+				"Unexpected surrogate pair in character class. Use 'u' flag.",
+			surrogatePair: "Unexpected surrogate pair in character class.",
+			combiningClass: "Unexpected combined character in character class.",
+			emojiModifier: "Unexpected modified Emoji in character class.",
+			regionalIndicatorSymbol:
+				"Unexpected national flag in character class.",
+			zwj: "Unexpected joined character sequence in character class.",
+			suggestUnicodeFlag: "Add unicode 'u' flag to regex.",
+		},
+	},
+	create(context) {
+		const allowEscape = context.options[0]?.allowEscape;
+		const sourceCode = context.sourceCode;
+		const parser = new RegExpParser();
+		const checkedPatternNodes = new Set();
+
+		/**
+		 * Verify a given regular expression.
+		 * @param {Node} node The node to report.
+		 * @param {string} pattern The regular expression pattern to verify.
+		 * @param {string} flags The flags of the regular expression.
+		 * @param {Function} unicodeFixer Fixer for missing "u" flag.
+		 * @returns {void}
+		 */
+		function verify(node, pattern, flags, unicodeFixer) {
+			let patternNode;
+
+			try {
+				patternNode = parser.parsePattern(pattern, 0, pattern.length, {
+					unicode: flags.includes("u"),
+					unicodeSets: flags.includes("v"),
+				});
+			} catch {
+				// Ignore regular expressions with syntax errors
+				return;
+			}
+
+			let codeUnits = null;
+
+			/**
+			 * Checks whether a specified regexpp character is represented as an acceptable escape sequence.
+			 * For the purposes of this rule, an escape sequence is considered acceptable if it consists of one or more backslashes followed by the character being escaped.
+			 * @param {Character} char Character to check.
+			 * @returns {boolean} Whether the specified regexpp character is represented as an acceptable escape sequence.
+			 */
+			function isAcceptableEscapeSequence(char) {
+				if (node.type === "Literal" && node.regex) {
+					return checkForAcceptableEscape(char, char.raw);
+				}
+				if (node.type === "Literal" && typeof node.value === "string") {
+					const nodeSource = node.raw;
+
+					codeUnits ??= parseStringLiteral(nodeSource);
+
+					return checkForAcceptableEscapeInString(
+						char,
+						nodeSource,
+						codeUnits,
+					);
+				}
+				if (astUtils.isStaticTemplateLiteral(node)) {
+					const nodeSource = sourceCode.getText(node);
+
+					codeUnits ??= parseTemplateToken(nodeSource);
+
+					return checkForAcceptableEscapeInString(
+						char,
+						nodeSource,
+						codeUnits,
+					);
+				}
+				return false;
+			}
+
+			const foundKindMatches = new Map();
+
+			visitRegExpAST(patternNode, {
+				onCharacterClassEnter(ccNode) {
+					for (const unfilteredChars of iterateCharacterSequence(
+						ccNode.elements,
+					)) {
+						let chars;
+
+						if (allowEscape) {
+							// Replace escape sequences with null to avoid having them flagged.
+							chars = unfilteredChars.map(char =>
+								isAcceptableEscapeSequence(char) ? null : char,
+							);
+						} else {
+							chars = unfilteredChars;
+						}
+						for (const kind of kinds) {
+							const matches = findCharacterSequences[kind](
+								chars,
+								unfilteredChars,
+							);
+
+							if (foundKindMatches.has(kind)) {
+								foundKindMatches.get(kind).push(...matches);
+							} else {
+								foundKindMatches.set(kind, [...matches]);
+							}
+						}
+					}
+				},
+			});
+
+			/**
+			 * 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;
+
+				if (kind === "surrogatePairWithoutUFlag") {
+					suggest = [
+						{
+							messageId: "suggestUnicodeFlag",
+							fix: unicodeFixer,
+						},
+					];
+				}
+
+				const locs = getNodeReportLocations(matches);
+
+				for (const loc of locs) {
+					context.report({
+						node,
+						loc,
+						messageId: kind,
+						suggest,
+					});
+				}
+			}
+		}
+
+		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;
+					}
+
+					return fixer.insertTextAfter(node, "u");
+				});
+			},
+			Program(node) {
+				const scope = sourceCode.getScope(node);
+				const tracker = new ReferenceTracker(scope);
+
+				/*
+				 * Iterate calls of RegExp.
+				 * E.g., `new RegExp()`, `RegExp()`, `new window.RegExp()`,
+				 *       `const {RegExp: a} = window; new a()`, etc...
+				 */
+				for (const { node: refNode } of tracker.iterateGlobalReferences(
+					{
+						RegExp: { [CALL]: true, [CONSTRUCT]: true },
+					},
+				)) {
+					let pattern, flags;
+					const [patternNode, flagsNode] = refNode.arguments;
+					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 flags === "string") {
+						verify(patternNode, pattern, flags, fixer => {
+							if (
+								!isValidWithUnicodeFlag(
+									context.languageOptions.ecmaVersion,
+									pattern,
+								)
+							) {
+								return null;
+							}
+
+							if (refNode.arguments.length === 1) {
+								const penultimateToken =
+									sourceCode.getLastToken(refNode, {
+										skip: 1,
+									}); // skip closing parenthesis
+
+								return fixer.insertTextAfter(
+									penultimateToken,
+									astUtils.isCommaToken(penultimateToken)
+										? ' "u",'
+										: ', "u"',
+								);
+							}
+
+							if (
+								(flagsNode.type === "Literal" &&
+									typeof flagsNode.value === "string") ||
+								flagsNode.type === "TemplateLiteral"
+							) {
+								const range = [
+									flagsNode.range[0],
+									flagsNode.range[1] - 1,
+								];
+
+								return fixer.insertTextAfterRange(range, "u");
+							}
+
+							return null;
+						});
+					}
+				}
+			},
+		};
+	},
 };