@alexlit/lint-kit 127.0.0 → 127.2.0

package/packages/config-eslint/node_modules/eslint/lib/rules/no-misleading-character-class.js

@@ -1,537 +0,0 @@
-/**
- * @author Toru Nagashima <https://github.com/mysticatea>
- */
-"use strict";
-
-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
-//------------------------------------------------------------------------------
-
-/**
- * @typedef {import('@eslint-community/regexpp').AST.Character} Character
- * @typedef {import('@eslint-community/regexpp').AST.CharacterClassElement} CharacterClassElement
- */
-
-/**
- * Iterate character sequences of a given nodes.
- *
- * CharacterClassRange syntax can steal a part of character sequence,
- * so this function reverts CharacterClassRange syntax and restore the sequence.
- * @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;
-    }
-}
-
-/**
- * Checks whether the given character node is a Unicode code point escape or not.
- * @param {Character} char the character node to check.
- * @returns {boolean} `true` if the character node is a Unicode code point escape.
- */
-function isUnicodeCodePointEscape(char) {
-    return /^\\u\{[\da-f]+\}$/iu.test(char.raw);
-}
-
-/**
- * Each function returns matched characters if it detects that kind of problem.
- * @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;
-        }
-    }
-};
-
-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;
-}
-
-/**
- * Checks whether a specified regexpp character is represented as an acceptable escape sequence.
- * This function requires the source text of the character to be known.
- * @param {Character} char Character to check.
- * @param {string} charSource Source text of the character to check.
- * @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);
-
-    return match?.[0] !== String.fromCodePoint(char.value);
-}
-
-/**
- * Checks whether a specified regexpp character is represented as an acceptable escape sequence.
- * This function works with characters that are produced by a string or template literal.
- * It requires the source text and the CodeUnit list of the literal to be known.
- * @param {Character} char Character to check.
- * @param {string} nodeSource Source text of the string or template literal that produces the character.
- * @param {CodeUnit[]} codeUnits List of CodeUnit objects of the literal that produces the character.
- * @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);
-
-    return checkForAcceptableEscape(char, charSource);
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @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;
-                        });
-                    }
-                }
-            }
-        };
-    }
-};