@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/regexAmbiguousInvalidity.js

@@ -0,0 +1,297 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+import { RegExpParser, RegExpValidator, visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexAmbiguousInvalidity.ts
+const validator = new RegExpValidator({
+	ecmaVersion: 2020,
+	strict: true
+});
+const CHARACTER_CLASS_SYNTAX_CHARACTERS = new Set("\\/()[]{}^$.|-+*?".split(""));
+const SYNTAX_CHARACTERS = new Set("\\/()[]{}^$.|+*?".split(""));
+function isControlEscape(raw) {
+	return /^\\c[A-Za-z]$/u.test(raw);
+}
+function isEscapeSequence(raw) {
+	return isOctalEscape(raw) || isControlEscape(raw) || isHexadecimalEscape(raw) || isUnicodeEscape(raw) || isUnicodeCodePointEscape(raw);
+}
+function isHexadecimalEscape(raw) {
+	return /^\\x[\dA-Fa-f]{2}$/u.test(raw);
+}
+function isOctalEscape(raw) {
+	return /^\\[0-7]{1,3}$/u.test(raw);
+}
+function isUnicodeCodePointEscape(raw) {
+	return /^\\u\{[\dA-Fa-f]{1,8}\}$/u.test(raw);
+}
+function isUnicodeEscape(raw) {
+	return /^\\u[\dA-Fa-f]{4}$/u.test(raw);
+}
+function parseFlags(flagsStr) {
+	return {
+		unicode: flagsStr.includes("u"),
+		unicodeSets: flagsStr.includes("v")
+	};
+}
+function validateRegExpPattern(pattern, flags) {
+	try {
+		validator.validatePattern(pattern, void 0, void 0, flags);
+		return null;
+	} catch (error) {
+		return error instanceof Error ? error.message : null;
+	}
+}
+function checkPatternWithRegexpp(pattern, flags) {
+	if (flags.unicode || flags.unicodeSets) return [];
+	const issues = [];
+	const parser = new RegExpParser();
+	let ast;
+	try {
+		ast = parser.parsePattern(pattern, void 0, void 0, flags);
+	} catch {
+		const message = validateRegExpPattern(pattern, flags);
+		if (message) issues.push({
+			data: { message },
+			end: pattern.length,
+			message: "regexMessage",
+			start: 0
+		});
+		return issues;
+	}
+	let reported = false;
+	let hasNamedBackreference = false;
+	visitRegExpAST(ast, {
+		onBackreferenceEnter(bNode) {
+			if (typeof bNode.ref === "string") hasNamedBackreference = true;
+		},
+		onCharacterClassEnter(ccNode) {
+			for (let i = 0; i < ccNode.elements.length; i++) {
+				const current = ccNode.elements[i];
+				if (current?.type === "CharacterSet") {
+					const next = ccNode.elements[i + 1];
+					const nextNext = ccNode.elements[i + 2];
+					if (next?.raw === "-" && nextNext) {
+						issues.push({
+							data: {},
+							end: current.end,
+							message: "invalidRange",
+							start: current.start
+						});
+						reported = true;
+						return;
+					}
+					const prev = ccNode.elements[i - 1];
+					const prevPrev = ccNode.elements[i - 2];
+					if (prev?.raw === "-" && prevPrev && prevPrev.type !== "CharacterClassRange") {
+						issues.push({
+							data: {},
+							end: current.end,
+							message: "invalidRange",
+							start: current.start
+						});
+						reported = true;
+						return;
+					}
+				}
+			}
+		},
+		onCharacterEnter(cNode) {
+			if (cNode.raw === "\\") {
+				issues.push({
+					data: {},
+					end: cNode.end,
+					message: "invalidControlEscape",
+					start: cNode.start
+				});
+				reported = true;
+				return;
+			}
+			if (cNode.raw === "\\u" || cNode.raw === "\\x") {
+				issues.push({
+					data: { expr: cNode.raw },
+					end: cNode.end,
+					message: "incompleteEscapeSequence",
+					start: cNode.start
+				});
+				reported = true;
+				return;
+			}
+			if (cNode.raw === "\\p" || cNode.raw === "\\P") {
+				issues.push({
+					data: { expr: cNode.raw },
+					end: cNode.end,
+					message: "invalidPropertyEscape",
+					start: cNode.start
+				});
+				reported = true;
+				return;
+			}
+			if (cNode.value !== 0 && isOctalEscape(cNode.raw)) {
+				issues.push({
+					data: {
+						escape: cNode.raw,
+						hex: `\\x${cNode.value.toString(16).padStart(2, "0")}`
+					},
+					end: cNode.end,
+					message: "octalEscape",
+					start: cNode.start
+				});
+				reported = true;
+				return;
+			}
+			const insideCharClass = cNode.parent.type === "CharacterClass" || cNode.parent.type === "CharacterClassRange";
+			if (!insideCharClass) {
+				if (cNode.raw === "\\k") {
+					issues.push({
+						data: { expr: cNode.raw },
+						end: cNode.end,
+						message: "incompleteBackreference",
+						start: cNode.start
+					});
+					reported = true;
+					return;
+				}
+				if (cNode.raw === "{" || cNode.raw === "}" || cNode.raw === "]") {
+					issues.push({
+						data: { character: cNode.raw },
+						end: cNode.end,
+						message: "unescapedSourceCharacter",
+						start: cNode.start
+					});
+					reported = true;
+					return;
+				}
+			}
+			if (isEscapeSequence(cNode.raw)) return;
+			if (cNode.raw.startsWith("\\")) {
+				const identity = cNode.raw.slice(1);
+				const syntaxChars = insideCharClass ? CHARACTER_CLASS_SYNTAX_CHARACTERS : SYNTAX_CHARACTERS;
+				if (cNode.value === identity.charCodeAt(0) && !syntaxChars.has(identity)) {
+					issues.push({
+						data: { escaped: identity },
+						end: cNode.end,
+						message: "uselessEscape",
+						start: cNode.start
+					});
+					reported = true;
+				}
+			}
+		},
+		onQuantifierEnter(quantifierNode) {
+			if (quantifierNode.element.type === "Assertion") {
+				issues.push({
+					data: {},
+					end: quantifierNode.end,
+					message: "quantifiedAssertion",
+					start: quantifierNode.start
+				});
+				reported = true;
+			}
+		}
+	});
+	if (hasNamedBackreference) return issues;
+	if (!reported) {
+		const message = validateRegExpPattern(pattern, flags);
+		if (message) issues.push({
+			data: { message },
+			end: pattern.length,
+			message: "regexMessage",
+			start: 0
+		});
+	}
+	return issues;
+}
+var regexAmbiguousInvalidity_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports regex patterns that use ambiguous or invalid syntax from Annex B.",
+		id: "regexAmbiguousInvalidity",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: {
+		incompleteBackreference: {
+			primary: "Incomplete backreference '{{ expr }}'.",
+			secondary: ["This regex uses syntax from ECMAScript Annex B which is ambiguous or deprecated.", "Either use a valid backreference or remove the useless escaping."],
+			suggestions: ["Complete the backreference or remove the escape."]
+		},
+		incompleteEscapeSequence: {
+			primary: "Incomplete escape sequence '{{ expr }}'.",
+			secondary: ["This regex uses syntax from ECMAScript Annex B which is ambiguous or deprecated.", "Either use a valid escape sequence or remove the useless escaping."],
+			suggestions: ["Complete the escape sequence or remove the escape."]
+		},
+		invalidControlEscape: {
+			primary: "Invalid or incomplete control escape sequence.",
+			secondary: ["This regex uses syntax from ECMAScript Annex B which is ambiguous or deprecated.", "Either use a valid control escape sequence or escape the standalone backslash."],
+			suggestions: ["Use a valid control escape like \\cA or escape the backslash."]
+		},
+		invalidPropertyEscape: {
+			primary: "Invalid property escape sequence '{{ expr }}'.",
+			secondary: ["This regex uses syntax from ECMAScript Annex B which is ambiguous or deprecated.", "Either use a valid property escape sequence or remove the useless escaping."],
+			suggestions: ["Use a valid Unicode property escape like \\p{L} with the 'u' flag."]
+		},
+		invalidRange: {
+			primary: "Invalid character class range. A character set cannot be the minimum or maximum of a character class range.",
+			secondary: ["This regex uses syntax from ECMAScript Annex B which is ambiguous or deprecated.", "Either escape the `-` or fix the character class range."],
+			suggestions: ["Escape the `-` character or reorder the character class."]
+		},
+		octalEscape: {
+			primary: "Invalid legacy octal escape sequence '{{ escape }}'. Use a hexadecimal escape instead.",
+			secondary: ["This regex uses syntax from ECMAScript Annex B which is ambiguous or deprecated.", "Octal escapes can be confused with backreferences."],
+			suggestions: ["Replace with hexadecimal escape '{{ hex }}'."]
+		},
+		quantifiedAssertion: {
+			primary: "Assertions are not allowed to be quantified directly.",
+			secondary: ["This regex uses syntax from ECMAScript Annex B which is ambiguous or deprecated.", "Wrap the assertion in a non-capturing group if you need to quantify it."],
+			suggestions: ["Wrap the assertion in a non-capturing group: (?:...)"]
+		},
+		regexMessage: {
+			primary: "{{ message }}.",
+			secondary: ["This regex uses syntax from ECMAScript Annex B which is ambiguous or deprecated.", "Consider using strict regex syntax for clarity and cross-platform compatibility."],
+			suggestions: ["Fix the regex syntax error."]
+		},
+		unescapedSourceCharacter: {
+			primary: "Unescaped source character '{{ character }}' should be escaped.",
+			secondary: ["This regex uses syntax from ECMAScript Annex B which is ambiguous or deprecated.", "Consider using strict regex syntax for clarity and cross-platform compatibility."],
+			suggestions: ["Escape the character with a backslash."]
+		},
+		uselessEscape: {
+			primary: "Useless escape '\\{{ escaped }}'.",
+			secondary: ["This regex uses syntax from ECMAScript Annex B which is ambiguous or deprecated.", "Identity escapes with non-syntax characters are forbidden in strict mode."],
+			suggestions: ["Remove the unnecessary backslash."]
+		}
+	},
+	setup(context) {
+		function reportIssues(issues, start) {
+			for (const issue of issues) context.report({
+				data: issue.data,
+				message: issue.message,
+				range: {
+					begin: start + issue.start + 1,
+					end: start + issue.end + 1
+				}
+			});
+		}
+		function checkCallOrNewExpression(node, { sourceFile, typeChecker }) {
+			if (!ts.isIdentifier(node.expression) || node.expression.text !== "RegExp" || !isGlobalDeclarationOfName(node.expression, "RegExp", typeChecker) || !node.arguments?.length) return;
+			const patternArg = node.arguments[0];
+			if (!ts.isStringLiteral(patternArg)) return;
+			const flagsArg = node.arguments[1];
+			const flags = parseFlags(flagsArg && ts.isStringLiteral(flagsArg) ? flagsArg.text : "");
+			reportIssues(checkPatternWithRegexpp(patternArg.text, flags), patternArg.getStart(sourceFile));
+		}
+		return { visitors: {
+			CallExpression: checkCallOrNewExpression,
+			NewExpression: checkCallOrNewExpression,
+			RegularExpressionLiteral: (node, { sourceFile }) => {
+				const text = node.getText(sourceFile);
+				const lastSlash = text.lastIndexOf("/");
+				if (lastSlash <= 0) return;
+				const flags = parseFlags(text.slice(lastSlash + 1));
+				reportIssues(checkPatternWithRegexpp(text.slice(1, lastSlash), flags), node.getStart(sourceFile));
+			}
+		} };
+	}
+});
+//#endregion
+export { regexAmbiguousInvalidity_default as default };
+
+//# sourceMappingURL=regexAmbiguousInvalidity.js.map

package/lib/rules/regexCharacterClassRanges.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports character class elements that can be simplified to ranges.";
+    readonly id: "regexCharacterClassRanges";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferRange", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexCharacterClassRanges.d.ts.map

package/lib/rules/regexCharacterClassRanges.js

@@ -0,0 +1,137 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { parseRegexpAst } from "./utils/parseRegexpAst.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexCharacterClassRanges.ts
+const ALPHANUMERIC_RANGES = [
+	{
+		max: 57,
+		min: 48
+	},
+	{
+		max: 90,
+		min: 65
+	},
+	{
+		max: 122,
+		min: 97
+	}
+];
+function inRange(ranges, min, max = min) {
+	for (const range of ranges) if (range.min <= min && max <= range.max) return true;
+	return false;
+}
+function processCharacterClass(node) {
+	const groups = [];
+	for (const element of node.elements) {
+		let data;
+		if (element.type === "Character") {
+			if (!inRange(ALPHANUMERIC_RANGES, element.value)) continue;
+			data = {
+				max: {
+					raw: element.raw,
+					value: element.value
+				},
+				min: {
+					raw: element.raw,
+					value: element.value
+				},
+				node: element
+			};
+		} else if (element.type === "CharacterClassRange") {
+			if (!inRange(ALPHANUMERIC_RANGES, element.min.value, element.max.value)) continue;
+			data = {
+				max: {
+					raw: element.max.raw,
+					value: element.max.value
+				},
+				min: {
+					raw: element.min.raw,
+					value: element.min.value
+				},
+				node: element
+			};
+		} else continue;
+		const group = groups.find((gp) => {
+			if (!(gp.min.value - 1 <= data.max.value && data.min.value <= gp.max.value + 1)) return false;
+			return inRange(ALPHANUMERIC_RANGES, Math.min(gp.min.value, data.min.value), Math.max(gp.max.value, data.max.value));
+		});
+		if (group) {
+			if (data.min.value < group.min.value) group.min = data.min;
+			if (group.max.value < data.max.value) group.max = data.max;
+			group.nodes.push(data.node);
+		} else groups.push({
+			max: data.max,
+			min: data.min,
+			nodes: [data.node]
+		});
+	}
+	for (const group of groups) if (group.max.value - group.min.value + 1 >= 4 && group.nodes.length > 1) return {
+		newRange: `${group.min.raw}-${group.max.raw}`,
+		nodes: group.nodes
+	};
+}
+var regexCharacterClassRanges_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports character class elements that can be simplified to ranges.",
+		id: "regexCharacterClassRanges",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { preferRange: {
+		primary: "Multiple adjacent characters can be simplified to a range '{{ range }}'.",
+		secondary: ["Character class ranges are more concise and readable than listing individual characters."],
+		suggestions: ["Replace the characters with the range '{{ range }}'."]
+	} },
+	setup(context) {
+		return { visitors: { RegularExpressionLiteral: (node, { sourceFile }) => {
+			const text = node.getText(sourceFile);
+			const match = /^\/(.+)\/([dgimsuyv]*)$/.exec(text);
+			if (!match) return;
+			const [, pattern, flags] = match;
+			if (!pattern) return;
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			const nodeStart = node.getStart(sourceFile);
+			const patternOffset = 1;
+			visitRegExpAST(regexpAst, { onCharacterClassEnter(ccNode) {
+				const result = processCharacterClass(ccNode);
+				if (result) {
+					const sortedNodes = [...result.nodes].sort((a, b) => a.start - b.start);
+					const firstNode = sortedNodes[0];
+					const lastNode = sortedNodes.at(-1);
+					if (!firstNode || !lastNode) return;
+					const fixRanges = [];
+					for (const currentNode of sortedNodes) {
+						const begin = nodeStart + patternOffset + currentNode.start;
+						const end = nodeStart + patternOffset + currentNode.end;
+						if (!fixRanges.length) fixRanges.push({
+							begin,
+							end
+						});
+						else {
+							const lastRange = fixRanges.at(-1);
+							if (lastRange && lastRange.end >= begin) lastRange.end = Math.max(lastRange.end, end);
+							else fixRanges.push({
+								begin,
+								end
+							});
+						}
+					}
+					context.report({
+						data: { range: result.newRange },
+						fix: fixRanges.map((range, index) => ({
+							range,
+							text: index === 0 ? result.newRange : ""
+						})),
+						message: "preferRange",
+						range: getTSNodeRange(node, sourceFile)
+					});
+				}
+			} });
+		} } };
+	}
+});
+//#endregion
+export { regexCharacterClassRanges_default as default };
+
+//# sourceMappingURL=regexCharacterClassRanges.js.map

package/lib/rules/regexCharacterClassSetOperations.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports lookarounds that can be replaced with character class set operations.";
+    readonly id: "regexCharacterClassSetOperations";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferSetOperation", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexCharacterClassSetOperations.d.ts.map

package/lib/rules/regexCharacterClassSetOperations.js

@@ -0,0 +1,81 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { parseRegexpAst } from "./utils/parseRegexpAst.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexCharacterClassSetOperations.ts
+function escapeRaw(raw) {
+	return /^[&\-^]$/u.test(raw) ? `\\${raw}` : raw;
+}
+function isCharElement(node) {
+	return node.type === "Character" || node.type === "CharacterSet" || node.type === "CharacterClass" || node.type === "ExpressionCharacterClass";
+}
+function isCharLookaround(node) {
+	if (node.type !== "Assertion" || node.kind !== "lookahead" && node.kind !== "lookbehind") return false;
+	const firstAlt = node.alternatives[0];
+	if (!firstAlt || node.alternatives.length !== 1) return false;
+	const firstElement = firstAlt.elements[0];
+	if (firstAlt.elements.length !== 1) return false;
+	return isCharElement(firstElement);
+}
+var regexCharacterClassSetOperations_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports lookarounds that can be replaced with character class set operations.",
+		id: "regexCharacterClassSetOperations",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { preferSetOperation: {
+		primary: "This lookaround can be combined with '{{ char }}' using a set operation.",
+		secondary: ["Character class set operations (using the v flag) are more readable and performant than lookarounds."],
+		suggestions: ["Replace the lookaround with a character class set operation."]
+	} },
+	setup(context) {
+		return { visitors: { RegularExpressionLiteral: (node, { sourceFile }) => {
+			const text = node.getText(sourceFile);
+			const match = /^\/(.+)\/([dgimsuyv]*)$/.exec(text);
+			if (!match) return;
+			const [, pattern, flagsStr] = match;
+			if (!pattern || !flagsStr?.includes("v")) return;
+			const regexpAst = parseRegexpAst(pattern);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, { onAlternativeEnter(alternative) {
+				const { elements } = alternative;
+				for (let i = 1; i < elements.length; i++) {
+					const previous = elements[i - 1];
+					const current = elements[i];
+					if (isCharElement(previous) && isCharLookaround(current) && current.kind === "lookbehind") {
+						const assertElement = current.alternatives[0].elements[0];
+						const operator = current.negate ? "--" : "&&";
+						const replacement = `[${escapeRaw(previous.raw)}${operator}${escapeRaw(assertElement.raw)}]`;
+						const nodeRange = getTSNodeRange(node, sourceFile);
+						context.report({
+							data: {
+								char: previous.raw,
+								replacement
+							},
+							message: "preferSetOperation",
+							range: nodeRange
+						});
+					}
+					if (isCharLookaround(previous) && previous.kind === "lookahead" && isCharElement(current)) {
+						const assertElement = previous.alternatives[0].elements[0];
+						const operator = previous.negate ? "--" : "&&";
+						const replacement = `[${escapeRaw(current.raw)}${operator}${escapeRaw(assertElement.raw)}]`;
+						const nodeRange = getTSNodeRange(node, sourceFile);
+						context.report({
+							data: {
+								char: current.raw,
+								replacement
+							},
+							message: "preferSetOperation",
+							range: nodeRange
+						});
+					}
+				}
+			} });
+		} } };
+	}
+});
+//#endregion
+export { regexCharacterClassSetOperations_default as default };
+
+//# sourceMappingURL=regexCharacterClassSetOperations.js.map

package/lib/rules/regexCharacterClasses.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports regex alternations that can be simplified to character classes.";
+    readonly id: "regexCharacterClasses";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferCharacterClass", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexCharacterClasses.d.ts.map