@flint.fyi/ts 0.15.0 → 0.18.1

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

package/lib/rules/regexCharacterClasses.js

@@ -0,0 +1,234 @@
+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/regexCharacterClasses.ts
+const reservedDoublePunctuatorCharacters = new Set([
+	"!",
+	"#",
+	"$",
+	"%",
+	"&",
+	"*",
+	"+",
+	",",
+	".",
+	":",
+	";",
+	"<",
+	"=",
+	">",
+	"?",
+	"@",
+	"^",
+	"`",
+	"~"
+]);
+function categorizeAlternative(alternative) {
+	if (isSingleCharElement(alternative.elements)) {
+		const element = alternative.elements[0];
+		const elements = toCharacterClassElement(element);
+		if (elements) return {
+			elements,
+			isCharacter: true,
+			raw: alternative.raw
+		};
+	}
+	return {
+		isCharacter: false,
+		raw: alternative.raw
+	};
+}
+function containsCharacterClass(alternatives) {
+	for (const alt of alternatives) if (alt.isCharacter && alt.raw.startsWith("[") && !alt.raw.startsWith("[^")) return true;
+	return false;
+}
+function elementsToCharacterClass(elements) {
+	const parts = [];
+	for (const element of elements) switch (element.type) {
+		case "Character":
+			if (element.raw === "-") parts.push("\\-");
+			else if (element.raw === "]") parts.push("\\]");
+			else parts.push(element.raw);
+			break;
+		case "CharacterClass":
+		case "CharacterClassRange":
+		case "CharacterSet":
+		case "ClassStringDisjunction":
+		case "ExpressionCharacterClass":
+			parts.push(element.raw);
+			break;
+	}
+	if (!parts.length) return "[]";
+	if (parts[0]?.[0] === "^") parts[0] = `\\${parts[0]}`;
+	for (let i = 1; i < parts.length; i++) {
+		const prev = parts[i - 1];
+		const curr = parts[i];
+		if (prev && curr) {
+			const pChar = prev.slice(-1);
+			const cChar = curr[0];
+			if (cChar && reservedDoublePunctuatorCharacters.has(cChar) && cChar === pChar && !prev.endsWith(`\\${pChar}`)) parts[i - 1] = `${prev.slice(0, -1)}\\${pChar}`;
+		}
+	}
+	return `[${parts.join("")}]`;
+}
+function getParentPrefixAndSuffix(parent) {
+	switch (parent.type) {
+		case "Assertion": return [`(?${parent.kind === "lookahead" ? "" : "<"}${parent.negate ? "!" : "="}`, ")"];
+		case "CapturingGroup":
+			if (parent.name !== null) return [`(?<${parent.name}>`, ")"];
+			return ["(", ")"];
+		case "Group": return ["(?:", ")"];
+		case "Pattern": return ["", ""];
+	}
+}
+function isSingleCharElement(elements) {
+	if (elements.length !== 1) return false;
+	const element = elements[0];
+	return element !== void 0 && (element.type === "Character" || element.type === "CharacterClass" || element.type === "CharacterSet" || element.type === "ExpressionCharacterClass");
+}
+function mergeCharacterAlternatives(a, b) {
+	const elements = [...a.elements, ...b.elements];
+	return {
+		elements,
+		isCharacter: true,
+		raw: elementsToCharacterClass(elements)
+	};
+}
+function optimizeAlternatives(alternatives) {
+	const result = [...alternatives];
+	for (let i = 0; i < result.length - 1; i++) {
+		let current = result[i];
+		if (!current?.isCharacter) continue;
+		for (let j = i + 1; j < result.length; j++) {
+			const next = result[j];
+			if (!next) continue;
+			if (next.isCharacter) {
+				current = mergeCharacterAlternatives(current, next);
+				result.splice(j, 1);
+				j--;
+			} else break;
+		}
+		result[i] = current;
+	}
+	return result;
+}
+function toCharacterClassElement(element) {
+	switch (element.type) {
+		case "Character": return [element];
+		case "CharacterClass":
+			if (element.negate && !element.unicodeSets) return;
+			if (element.negate) return [element];
+			return element.elements;
+		case "CharacterSet":
+			if (element.kind === "any") return;
+			return [element];
+		case "ExpressionCharacterClass": return [element];
+		default: return;
+	}
+}
+var regexCharacterClasses_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports regex alternations that can be simplified to character classes.",
+		id: "regexCharacterClasses",
+		presets: ["stylisticStrict"]
+	},
+	messages: { preferCharacterClass: {
+		primary: "This alternation can be simplified to a character class '{{ replacement }}'.",
+		secondary: ["Character classes are more efficient than alternations and don't require backtracking."],
+		suggestions: ["Replace the alternation with a character class '{{ replacement }}'."]
+	} },
+	setup(context) {
+		function processAlternatives(node) {
+			const alternatives = node.alternatives;
+			if (alternatives.length < 2) return;
+			const parsed = alternatives.map(categorizeAlternative);
+			const characterCount = parsed.filter((a) => a.isCharacter).length;
+			if (characterCount < 2) return;
+			if (characterCount < 3 && !containsCharacterClass(parsed)) return;
+			const optimized = optimizeAlternatives(parsed);
+			if (optimized.length === parsed.length) return;
+			const replacement = optimized.map((a) => a.raw).join("|");
+			const [prefix, suffix] = getParentPrefixAndSuffix(node);
+			return {
+				fixedPattern: prefix + replacement + suffix,
+				replacement
+			};
+		}
+		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 nodeRange = getTSNodeRange(node, sourceFile);
+			visitRegExpAST(regexpAst, {
+				onAssertionEnter(assertion) {
+					if (assertion.kind === "lookahead" || assertion.kind === "lookbehind") {
+						const result = processAlternatives(assertion);
+						if (result) {
+							const newPattern = pattern.slice(0, assertion.start) + result.fixedPattern + pattern.slice(assertion.end);
+							context.report({
+								data: { replacement: result.replacement },
+								fix: {
+									range: nodeRange,
+									text: `/${newPattern}/${flags}`
+								},
+								message: "preferCharacterClass",
+								range: nodeRange
+							});
+						}
+					}
+				},
+				onCapturingGroupEnter(group) {
+					const result = processAlternatives(group);
+					if (result) {
+						const newPattern = pattern.slice(0, group.start) + result.fixedPattern + pattern.slice(group.end);
+						context.report({
+							data: { replacement: result.replacement },
+							fix: {
+								range: nodeRange,
+								text: `/${newPattern}/${flags}`
+							},
+							message: "preferCharacterClass",
+							range: nodeRange
+						});
+					}
+				},
+				onGroupEnter(group) {
+					const result = processAlternatives(group);
+					if (result) {
+						const newPattern = pattern.slice(0, group.start) + result.fixedPattern + pattern.slice(group.end);
+						context.report({
+							data: { replacement: result.replacement },
+							fix: {
+								range: nodeRange,
+								text: `/${newPattern}/${flags}`
+							},
+							message: "preferCharacterClass",
+							range: nodeRange
+						});
+					}
+				},
+				onPatternEnter(patternNode) {
+					const result = processAlternatives(patternNode);
+					if (result) context.report({
+						data: { replacement: result.replacement },
+						fix: {
+							range: nodeRange,
+							text: `/${result.replacement}/${flags}`
+						},
+						message: "preferCharacterClass",
+						range: nodeRange
+					});
+				}
+			});
+		} } };
+	}
+});
+//#endregion
+export { regexCharacterClasses_default as default };
+
+//# sourceMappingURL=regexCharacterClasses.js.map

package/lib/rules/regexConciseCharacterClassNegations.d.ts

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

package/lib/rules/regexConciseCharacterClassNegations.js

@@ -0,0 +1,52 @@
+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/regexConciseCharacterClassNegations.ts
+function getNegationText(node) {
+	if (node.type === "ExpressionCharacterClass") return `[${node.raw.slice(2, -1)}]`;
+	const kind = node.raw[1];
+	if (!kind) return;
+	return `\\${kind.toLowerCase() === kind ? kind.toUpperCase() : kind.toLowerCase()}${node.raw.slice(2)}`;
+}
+var regexConciseCharacterClassNegations_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports negated character classes that can use shorthand escapes.",
+		id: "regexConciseCharacterClassNegations",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { preferNegatedEscape: {
+		primary: "Use '{{ replacement }}' instead of negated character class.",
+		secondary: ["Shorthand escape sequences like \\D, \\W, and \\S are more concise than negated character classes."],
+		suggestions: ["Replace the negated character class with '{{ replacement }}'."]
+	} },
+	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 hasIgnoreCase = flags?.includes("i") ?? false;
+			visitRegExpAST(regexpAst, { onCharacterClassEnter(characterClassNode) {
+				if (!characterClassNode.negate || characterClassNode.elements.length !== 1) return;
+				const element = characterClassNode.elements[0];
+				if (element.type !== "CharacterSet" && element.type !== "ExpressionCharacterClass") return;
+				if (element.type === "CharacterSet" && element.kind === "property" && hasIgnoreCase) return;
+				const replacement = getNegationText(element);
+				if (!replacement) return;
+				context.report({
+					data: { replacement },
+					message: "preferNegatedEscape",
+					range: getTSNodeRange(node, sourceFile)
+				});
+			} });
+		} } };
+	}
+});
+//#endregion
+export { regexConciseCharacterClassNegations_default as default };
+
+//# sourceMappingURL=regexConciseCharacterClassNegations.js.map

package/lib/rules/regexContradictoryAssertions.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports elements in regular expressions that contradict assertions.";
+    readonly id: "regexContradictoryAssertions";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "alwaysEnter" | "cannotEnter", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexContradictoryAssertions.d.ts.map