@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/regexLiterals.js

@@ -0,0 +1,92 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { parseRegexpAst } from "./utils/parseRegexpAst.js";
+import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/regexLiterals.ts
+function escapeForRegexLiteral(pattern) {
+	if (pattern === "") return "(?:)";
+	let result = "";
+	let escaped = false;
+	for (const char of pattern) {
+		if (escaped) {
+			result += char;
+			escaped = false;
+			continue;
+		}
+		switch (char) {
+			case "\n":
+				result += "\\n";
+				break;
+			case "\r":
+				result += "\\r";
+				break;
+			case "\u2028":
+				result += "\\u2028";
+				break;
+			case "\u2029":
+				result += "\\u2029";
+				break;
+			case "/":
+				result += "\\/";
+				break;
+			case "\\":
+				result += char;
+				escaped = true;
+				break;
+			default:
+				result += char;
+				break;
+		}
+	}
+	return result;
+}
+function isStaticString(node) {
+	return node.kind === ts$1.SyntaxKind.StringLiteral || node.kind === ts$1.SyntaxKind.NoSubstitutionTemplateLiteral;
+}
+var regexLiterals_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Use a regular expression literal when the pattern is static.",
+		id: "regexLiterals",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { preferLiteral: {
+		primary: "This `RegExp` construction with a static value can be simplified to a regular expression literal.",
+		secondary: ["Regex literals are more concise and avoid unnecessary constructor calls."],
+		suggestions: ["Replace with regex literal `{{ literal }}`."]
+	} },
+	setup(context) {
+		function checkRegExpCall(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			if (!isStaticString(construction.args[0])) return;
+			if (construction.args.length === 2 && !isStaticString(construction.args[1])) return;
+			if (!parseRegexpAst(construction.pattern, construction.flags)) return;
+			const literal = `/${escapeForRegexLiteral(construction.raw)}/${construction.flags}`;
+			const begin = node.getStart(services.sourceFile);
+			context.report({
+				data: { literal },
+				fix: {
+					range: {
+						begin,
+						end: node.getEnd()
+					},
+					text: literal
+				},
+				message: "preferLiteral",
+				range: {
+					begin,
+					end: node.expression.getEnd()
+				}
+			});
+		}
+		return { visitors: {
+			CallExpression: checkRegExpCall,
+			NewExpression: checkRegExpCall
+		} };
+	}
+});
+//#endregion
+export { regexLiterals_default as default };
+
+//# sourceMappingURL=regexLiterals.js.map

package/lib/rules/regexLookaroundAssertions.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports capturing groups at pattern boundaries that can be replaced with lookaround assertions.";
+    readonly id: "regexLookaroundAssertions";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferLookaround", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexLookaroundAssertions.d.ts.map

package/lib/rules/regexLookaroundAssertions.js

@@ -0,0 +1,163 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
+import { parseRegexpAst } from "./utils/parseRegexpAst.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+import { visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexLookaroundAssertions.ts
+function buildFixedPattern(originalPattern, boundaryGroups) {
+	let result = originalPattern;
+	for (const { group, position } of [...boundaryGroups].reverse()) {
+		const replacement = `${position === "start" ? "(?<=" : "(?="}${groupToRaw(group)})`;
+		result = result.slice(0, group.start) + replacement + result.slice(group.end);
+	}
+	return result;
+}
+function buildFixedReplacement(originalText, boundaryGroups) {
+	let result = originalText;
+	for (let i = boundaryGroups.length; i >= 1; i--) result = result.replaceAll(`$${i}`, "");
+	return result;
+}
+function getBoundaryGroups(pattern, groups) {
+	if (!groups.length || groups.length > 2 || groups.some((group) => group.name != null)) return;
+	const alternatives = pattern.alternatives;
+	if (alternatives.length !== 1) return;
+	const elements = alternatives[0].elements;
+	if (elements.length < 2) return;
+	const result = [];
+	const firstElement = elements[0];
+	const lastElement = elements.at(-1);
+	if (groups.length === 1) {
+		const group = groups[0];
+		if (firstElement === group) result.push({
+			group,
+			position: "start"
+		});
+		else if (lastElement === group) result.push({
+			group,
+			position: "end"
+		});
+		else return;
+	} else {
+		const [first, second] = groups;
+		if (firstElement === first && lastElement === second) result.push({
+			group: first,
+			position: "start"
+		}, {
+			group: second,
+			position: "end"
+		});
+		else return;
+	}
+	return result;
+}
+function getCapturingGroups(pattern) {
+	const groups = [];
+	visitRegExpAST(pattern, { onCapturingGroupEnter(groupNode) {
+		groups.push(groupNode);
+	} });
+	return groups;
+}
+function getRegexPatternAndFlags(node) {
+	if (node.kind !== ts.SyntaxKind.RegularExpressionLiteral) return;
+	const match = /^\/(.+)\/([dgimsuyv]*)$/.exec(node.text);
+	if (!match) return;
+	return {
+		flags: match[2],
+		pattern: match[1]
+	};
+}
+function groupToRaw(group) {
+	return group.alternatives.flatMap((alternative) => alternative.elements.flatMap((element) => element.raw)).join("");
+}
+function hasBackreferences(pattern) {
+	let found = false;
+	visitRegExpAST(pattern, { onBackreferenceEnter() {
+		found = true;
+	} });
+	return found;
+}
+function hasSpecialDollarSyntax(text) {
+	return /\$[$&'`]|\$<[^>]+>/.test(text);
+}
+function hasVariableLengthContent(node) {
+	let found = false;
+	visitRegExpAST(node, { onQuantifierEnter(quantifier) {
+		if (quantifier.min !== quantifier.max) found = true;
+	} });
+	return found;
+}
+function parseReplacementReferences(text) {
+	const references = /* @__PURE__ */ new Map();
+	const pattern = /\$(\d+)/g;
+	let match;
+	while (match = pattern.exec(text)) {
+		const index = parseInt(match[1], 10);
+		if (index > 0) references.set(index, (references.get(index) ?? 0) + 1);
+	}
+	return references;
+}
+var regexLookaroundAssertions_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports capturing groups at pattern boundaries that can be replaced with lookaround assertions.",
+		id: "regexLookaroundAssertions",
+		presets: ["stylisticStrict"]
+	},
+	messages: { preferLookaround: {
+		primary: "This capturing group can be optimized by switching to a lookaround assertion.",
+		secondary: ["Lookaround assertions avoid re-inserting captured content in the replacement string.", "Using them allows engines to more easily optimize regular expressions."],
+		suggestions: ["Convert to a lookahead or lookbehind assertion."]
+	} },
+	setup(context) {
+		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
+			if (!ts.isPropertyAccessExpression(node.expression) || node.expression.name.text !== "replace" && node.expression.name.text !== "replaceAll" || node.arguments.length < 2) return;
+			if (!(getConstrainedTypeAtLocation(node.expression.expression, typeChecker).flags & ts.TypeFlags.StringLike)) return;
+			const regexArgument = node.arguments[0];
+			const replacementArgument = node.arguments[1];
+			if (!ts.isStringLiteral(replacementArgument) || hasSpecialDollarSyntax(replacementArgument.text)) return;
+			const regexInfo = getRegexPatternAndFlags(regexArgument);
+			if (!regexInfo) return;
+			const regexpAst = parseRegexpAst(regexInfo.pattern, regexInfo.flags);
+			if (!regexpAst || hasBackreferences(regexpAst)) return;
+			const capturingGroups = getCapturingGroups(regexpAst);
+			if (!capturingGroups.length || capturingGroups.length > 2) return;
+			const boundaryGroups = getBoundaryGroups(regexpAst, capturingGroups);
+			if (!boundaryGroups) return;
+			const references = parseReplacementReferences(replacementArgument.text);
+			for (let i = 0; i < boundaryGroups.length; i++) if (references.get(i + 1) !== 1) return;
+			for (const { group, position } of boundaryGroups) if (position === "start" && hasVariableLengthContent(group)) return;
+			const regexRange = getTSNodeRange(regexArgument, sourceFile);
+			const replacementRange = getTSNodeRange(replacementArgument, sourceFile);
+			const fixedPattern = buildFixedPattern(regexInfo.pattern, boundaryGroups);
+			const fixedReplacement = buildFixedReplacement(replacementArgument.text, boundaryGroups);
+			const fix = [{
+				range: {
+					begin: regexRange.begin + 1,
+					end: regexRange.end - 1 - regexInfo.flags.length
+				},
+				text: fixedPattern
+			}, {
+				range: {
+					begin: replacementRange.begin + 1,
+					end: replacementRange.end - 1
+				},
+				text: fixedReplacement
+			}];
+			for (const { group } of boundaryGroups) {
+				const groupRange = {
+					begin: regexRange.begin + 1 + group.start,
+					end: regexRange.begin + 1 + group.end
+				};
+				context.report({
+					fix,
+					message: "preferLookaround",
+					range: groupRange
+				});
+			}
+		} } };
+	}
+});
+//#endregion
+export { regexLookaroundAssertions_default as default };
+
+//# sourceMappingURL=regexLookaroundAssertions.js.map

package/lib/rules/regexLookaroundQuantifierOptimizations.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports non-constant quantifiers in lookaround assertions that could be simplified.";
+    readonly id: "regexLookaroundQuantifierOptimizations";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "replace" | "remove", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexLookaroundQuantifierOptimizations.d.ts.map

package/lib/rules/regexLookaroundQuantifierOptimizations.js

@@ -0,0 +1,94 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { parseRegexpAst } from "./utils/parseRegexpAst.js";
+import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
+import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexLookaroundQuantifierOptimizations.ts
+function* extractInvalidQuantifiers(alternatives, kind) {
+	for (const { elements } of alternatives) {
+		if (!elements.length) continue;
+		const last = elements[kind === "lookahead" ? elements.length - 1 : 0];
+		switch (last.type) {
+			case "Group":
+				yield* extractInvalidQuantifiers(last.alternatives, kind);
+				break;
+			case "Quantifier":
+				if (last.min !== last.max && !hasCapturingGroupDescendant(last.element)) yield last;
+				break;
+		}
+	}
+}
+function hasCapturingGroupDescendant(element) {
+	switch (element.type) {
+		case "CapturingGroup": return true;
+		case "Group":
+			for (const alternative of element.alternatives) for (const child of alternative.elements) if (hasCapturingGroupDescendant(child)) return true;
+			return false;
+		case "Quantifier": return hasCapturingGroupDescendant(element.element);
+		default: return false;
+	}
+}
+var regexLookaroundQuantifierOptimizations_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports non-constant quantifiers in lookaround assertions that could be simplified.",
+		id: "regexLookaroundQuantifierOptimizations",
+		presets: ["logical"]
+	},
+	messages: {
+		remove: {
+			primary: "Quantifier '{{ raw }}' at the {{ endOrStart }} of the {{ kind }} can be removed.",
+			secondary: ["Non-constant quantifiers at the end of lookaheads or start of lookbehinds only match their minimum because the lookaround only checks for a match, not how much is matched."],
+			suggestions: ["Remove the quantifier."]
+		},
+		replace: {
+			primary: "Quantifier '{{ raw }}' at the {{ endOrStart }} of the {{ kind }} can be replaced with '{{ replacer }}'.",
+			secondary: ["Non-constant quantifiers at the end of lookaheads or start of lookbehinds only match their minimum because the lookaround only checks for a match, not how much is matched."],
+			suggestions: ["Replace the quantifier with the constant minimum."]
+		}
+	},
+	setup(context) {
+		function checkPattern(pattern, start, flags) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, { onAssertionEnter(assertionNode) {
+				if (assertionNode.kind !== "lookahead" && assertionNode.kind !== "lookbehind") return;
+				const endOrStart = assertionNode.kind === "lookahead" ? "end" : "start";
+				const kind = assertionNode.negate ? `negative ${assertionNode.kind}` : assertionNode.kind;
+				for (const quantifier of extractInvalidQuantifiers(assertionNode.alternatives, assertionNode.kind)) {
+					const replacer = quantifier.min === 0 ? "" : quantifier.min === 1 ? quantifier.element.raw : `${quantifier.element.raw}{${quantifier.min}}`;
+					context.report({
+						data: {
+							endOrStart,
+							kind,
+							raw: quantifier.raw,
+							replacer
+						},
+						message: quantifier.min === 0 ? "remove" : "replace",
+						range: {
+							begin: start + quantifier.start,
+							end: start + quantifier.end
+						}
+					});
+				}
+			} });
+		}
+		function checkRegexLiteral(node, services) {
+			const details = getRegExpLiteralDetails(node, services);
+			checkPattern(details.pattern, details.start, details.flags);
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (construction) checkPattern(construction.pattern, construction.start + 1, construction.flags);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexLookaroundQuantifierOptimizations_default as default };
+
+//# sourceMappingURL=regexLookaroundQuantifierOptimizations.js.map

package/lib/rules/regexMatchNotation.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports inconsistent notations for matching any character in regular expressions.";
+    readonly id: "regexMatchNotation";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unexpected", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexMatchNotation.d.ts.map

package/lib/rules/regexMatchNotation.js

@@ -0,0 +1,139 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { parseRegexpAst } from "./utils/parseRegexpAst.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+import { visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexMatchNotation.ts
+const allowedNotation = String.raw`[\s\S]`;
+function isMatchAnyCharacterClass(node, flags) {
+	if (node.negate) return !node.elements.length;
+	const positiveElements = [];
+	const negativeElements = [];
+	for (const element of node.elements) if (element.type === "CharacterSet") switch (element.kind) {
+		case "digit":
+			if (element.negate) negativeElements.push({
+				kind: "digit",
+				type: "CharacterSet"
+			});
+			else positiveElements.push({
+				kind: "digit",
+				type: "CharacterSet"
+			});
+			break;
+		case "property": {
+			if (!flags.unicode && !flags.unicodeSets) break;
+			const key = `property:${element.key}:${element.value ?? ""}`;
+			if (element.negate) negativeElements.push({
+				kind: key,
+				negate: true,
+				type: "CharacterSet"
+			});
+			else positiveElements.push({
+				kind: key,
+				type: "CharacterSet"
+			});
+			break;
+		}
+		case "space":
+			if (element.negate) negativeElements.push({
+				kind: "space",
+				type: "CharacterSet"
+			});
+			else positiveElements.push({
+				kind: "space",
+				type: "CharacterSet"
+			});
+			break;
+		case "word":
+			if (element.negate) negativeElements.push({
+				kind: "word",
+				type: "CharacterSet"
+			});
+			else positiveElements.push({
+				kind: "word",
+				type: "CharacterSet"
+			});
+			break;
+		default: break;
+	}
+	else if (element.type === "CharacterClassRange" && element.min.value === 0 && (element.max.value === 65535 || element.max.value === 1114111 || flags.unicode && element.max.value >= 1114111)) return true;
+	for (const positive of positiveElements) if (negativeElements.find((negative) => negative.kind === positive.kind)) return true;
+	const hasSpace = positiveElements.some((e) => e.kind === "space");
+	const hasNonSpace = negativeElements.some((e) => e.kind === "space");
+	if (hasSpace && hasNonSpace) return true;
+	const hasDigit = positiveElements.some((e) => e.kind === "digit");
+	const hasNonDigit = negativeElements.some((e) => e.kind === "digit");
+	if (hasDigit && hasNonDigit) return true;
+	const hasWord = positiveElements.some((e) => e.kind === "word");
+	const hasNonWord = negativeElements.some((e) => e.kind === "word");
+	if (hasWord && hasNonWord) return true;
+	return false;
+}
+var regexMatchNotation_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports inconsistent notations for matching any character in regular expressions.",
+		id: "regexMatchNotation",
+		presets: ["stylisticStrict"]
+	},
+	messages: { unexpected: {
+		primary: "For consistency, prefer '{{ preferred }}' over '{{ raw }}' to match any character.",
+		secondary: ["Using a consistent notation for matching any character improves readability."],
+		suggestions: ["Replace with the standard notation."]
+	} },
+	setup(context) {
+		function checkPattern(pattern, patternStart, flags) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			const flagsInfo = {
+				dotAll: flags.includes("s"),
+				unicode: flags.includes("u"),
+				unicodeSets: flags.includes("v")
+			};
+			visitRegExpAST(regexpAst, { onCharacterClassEnter(ccNode) {
+				if (isMatchAnyCharacterClass(ccNode, flagsInfo) && ccNode.raw !== allowedNotation) {
+					const preferred = flagsInfo.dotAll ? "." : allowedNotation;
+					context.report({
+						data: {
+							preferred,
+							raw: ccNode.raw
+						},
+						message: "unexpected",
+						range: {
+							begin: patternStart + ccNode.start,
+							end: patternStart + ccNode.end
+						}
+					});
+				}
+			} });
+		}
+		function checkRegexLiteral(node, { sourceFile }) {
+			const text = node.getText(sourceFile);
+			const match = /^\/(.*)\/([dgimsuyv]*)$/.exec(text);
+			if (!match) return;
+			const [, pattern, flags] = match;
+			if (!pattern) return;
+			checkPattern(pattern, node.getStart(sourceFile) + 1, flags ?? "");
+		}
+		function checkRegExpConstructor(node, { sourceFile }) {
+			if (node.expression.kind !== ts$1.SyntaxKind.Identifier || node.expression.text !== "RegExp") return;
+			const args = node.arguments;
+			if (!args?.length) return;
+			const firstArgument = args[0];
+			if (firstArgument?.kind !== ts$1.SyntaxKind.StringLiteral) return;
+			const patternStart = firstArgument.getStart(sourceFile) + 1;
+			let flags = "";
+			const secondArgument = args[1];
+			if (secondArgument?.kind === ts$1.SyntaxKind.StringLiteral) flags = secondArgument.text;
+			checkPattern(firstArgument.text, patternStart, flags);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexMatchNotation_default as default };
+
+//# sourceMappingURL=regexMatchNotation.js.map

package/lib/rules/regexMisleadingCapturingGroups.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports capturing groups that capture less text than their pattern suggests.";
+    readonly id: "regexMisleadingCapturingGroups";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "misleadingEnd" | "misleadingStart", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexMisleadingCapturingGroups.d.ts.map