@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/parseIntRadixes.js

@@ -0,0 +1,62 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/parseIntRadixes.ts
+function isParseIntCall(node, typeChecker) {
+	switch (node.expression.kind) {
+		case ts$1.SyntaxKind.Identifier: return isGlobalDeclarationOfName(node.expression, "parseInt", typeChecker);
+		case ts$1.SyntaxKind.PropertyAccessExpression: return ts$1.isIdentifier(node.expression.name) && node.expression.name.text === "parseInt" && ts$1.isIdentifier(node.expression.expression) && node.expression.expression.text === "Number" && isGlobalDeclarationOfName(node.expression.expression, "Number", typeChecker);
+		default: return false;
+	}
+}
+function isValidRadix(argument) {
+	switch (argument.kind) {
+		case ts$1.SyntaxKind.Identifier: return argument.text !== "undefined";
+		case ts$1.SyntaxKind.NumericLiteral: return isValidRadixValue(Number(argument.text));
+		case ts$1.SyntaxKind.PrefixUnaryExpression: return argument.operator === ts$1.SyntaxKind.MinusToken && ts$1.isNumericLiteral(argument.operand) && isValidRadixValue(-Number(argument.operand.text));
+		default: return true;
+	}
+}
+function isValidRadixValue(value) {
+	return value >= 2 && value <= 36;
+}
+var parseIntRadixes_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports parseInt calls that are missing or have an invalid radix parameter.",
+		id: "parseIntRadixes",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: {
+		invalidRadix: {
+			primary: "Invalid radix parameter; must be an integer between 2 and 36.",
+			secondary: ["The radix determines the base of the numeral system used for parsing.", "Valid radix values are integers from 2 (binary) to 36."],
+			suggestions: ["Use a valid radix value, typically 10 for decimal numbers."]
+		},
+		missingRadix: {
+			primary: "This `parseInt` call is missing a radix parameter to specify the numeral system base.",
+			secondary: ["Without a radix, parseInt may interpret the string differently based on its format.", "For example, strings starting with '0' were historically parsed as octal."],
+			suggestions: ["Add an explicit radix parameter."]
+		}
+	},
+	setup(context) {
+		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
+			if (!isParseIntCall(node, typeChecker)) return;
+			if (node.arguments.length <= 1) {
+				context.report({
+					message: "missingRadix",
+					range: getTSNodeRange(node, sourceFile)
+				});
+				return;
+			}
+			const radixArgument = node.arguments[1];
+			if (!isValidRadix(radixArgument)) context.report({
+				message: "invalidRadix",
+				range: getTSNodeRange(radixArgument, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+export { parseIntRadixes_default as default };
+
+//# sourceMappingURL=parseIntRadixes.js.map

package/lib/rules/propertyAccessNotation.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod/v4";
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports bracket notation property access when dot notation can be used.";
+    readonly id: "propertyAccessNotation";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferDotNotation", {
+    readonly allowIndexSignaturePropertyAccess: z.ZodDefault<z.ZodBoolean>;
+}>;
+export default _default;
+//# sourceMappingURL=propertyAccessNotation.d.ts.map

package/lib/rules/propertyAccessNotation.js

@@ -0,0 +1,119 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+import { z } from "zod/v4";
+//#region src/rules/propertyAccessNotation.ts
+const javascriptReservedWords = new Set([
+	"await",
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"enum",
+	"export",
+	"extends",
+	"false",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"instanceof",
+	"interface",
+	"let",
+	"new",
+	"null",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"return",
+	"static",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with",
+	"yield"
+]);
+function getModifiers(node) {
+	return node && ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0;
+}
+function getPropertyKeyText(node) {
+	switch (node.argumentExpression.kind) {
+		case ts.SyntaxKind.FalseKeyword: return "false";
+		case ts.SyntaxKind.NullKeyword: return "null";
+		case ts.SyntaxKind.StringLiteral: return node.argumentExpression.text;
+		case ts.SyntaxKind.TrueKeyword: return "true";
+		default: return;
+	}
+}
+function keyCannotBeUsedWithDotNotation(key) {
+	return !/^[\p{L}_$][\p{L}\d_$]*$/u.test(key) || javascriptReservedWords.has(key);
+}
+var propertyAccessNotation_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports bracket notation property access when dot notation can be used.",
+		id: "propertyAccessNotation",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { preferDotNotation: {
+		primary: "Prefer the cleaner dot notation instead of bracket notation for `{{ key }}`.",
+		secondary: ["Dot notation is more concise and easier to read.", "Bracket notation should only be used when the property name is not a valid identifier or is a reserved word."],
+		suggestions: ["Replace `[\"{{ key }}\"]` with `.{{ key }}`."]
+	} },
+	options: { allowIndexSignaturePropertyAccess: z.boolean().default(false).describe("Whether to allow accessing properties matching an index signature with bracket notation.") },
+	setup(context) {
+		function getKeyTypeInformation(node, typeChecker) {
+			const propertySymbol = typeChecker.getSymbolAtLocation(node.argumentExpression) ?? typeChecker.getTypeAtLocation(node.expression).getNonNullableType().getProperties().find((propertySymbol) => ts.isStringLiteral(node.argumentExpression) && propertySymbol.escapedName === node.argumentExpression.text);
+			const modifierKind = getModifiers(propertySymbol?.getDeclarations()?.[0])?.[0]?.kind;
+			return {
+				inaccessible: modifierKind === ts.SyntaxKind.PrivateKeyword || modifierKind === ts.SyntaxKind.ProtectedKeyword,
+				propertySymbol
+			};
+		}
+		return { visitors: { ElementAccessExpression: (node, { options, sourceFile, typeChecker }) => {
+			const key = getPropertyKeyText(node);
+			if (!key || keyCannotBeUsedWithDotNotation(key)) return;
+			const { inaccessible, propertySymbol } = getKeyTypeInformation(node, typeChecker);
+			if (inaccessible) return;
+			if (options.allowIndexSignaturePropertyAccess && !propertySymbol) {
+				const objectType = typeChecker.getTypeAtLocation(node.expression).getNonNullableType();
+				if (typeChecker.getIndexInfosOfType(objectType).some((info) => info.keyType.flags & ts.TypeFlags.StringLike)) return;
+			}
+			const objectText = node.expression.getText(sourceFile);
+			const dotOperator = node.questionDotToken !== void 0 ? "?." : ".";
+			context.report({
+				data: { key },
+				fix: {
+					range: getTSNodeRange(node, sourceFile),
+					text: `${objectText}${dotOperator}${key}`
+				},
+				message: "preferDotNotation",
+				range: {
+					begin: node.argumentExpression.getStart(sourceFile),
+					end: node.argumentExpression.getEnd()
+				}
+			});
+		} } };
+	}
+});
+//#endregion
+export { propertyAccessNotation_default as default };
+
+//# sourceMappingURL=propertyAccessNotation.js.map

package/lib/rules/recursionOnlyArguments.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports function parameters that are only used in recursive calls.";
+    readonly id: "recursionOnlyArguments";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "onlyUsedInRecursion", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=recursionOnlyArguments.d.ts.map

package/lib/rules/recursionOnlyArguments.js

@@ -0,0 +1,71 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getFunctionName } from "./utils/getFunctionName.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+import * as tsutils from "ts-api-utils";
+//#region src/rules/recursionOnlyArguments.ts
+function collectParameterReferences(parameterName, parameterNode, functionNode, functionBody) {
+	const references = [];
+	function collectNode(node) {
+		if (tsutils.isFunctionScopeBoundary(node) && node !== functionNode) return;
+		if (ts$1.isIdentifier(node) && node.text === parameterName && node !== parameterNode) references.push(node);
+		ts$1.forEachChild(node, collectNode);
+	}
+	ts$1.forEachChild(functionBody, collectNode);
+	return references;
+}
+function isParameterOnlyUsedInRecursion(parameter, parameterIndex, functionName, functionNode) {
+	if (!ts$1.isIdentifier(parameter.name) || !functionNode.body) return false;
+	const references = collectParameterReferences(parameter.name.text, parameter.name, functionNode, functionNode.body);
+	return references.length && references.every((reference) => isReferenceOnlyUsedInRecursion(reference, parameterIndex, functionName, functionNode));
+}
+function isRecursiveCall(callExpression, functionName, functionNode) {
+	const callee = callExpression.expression;
+	let calleeMatchesFunctionName = false;
+	if (ts$1.isIdentifier(callee)) calleeMatchesFunctionName = callee.text === functionName;
+	else if (ts$1.isPropertyAccessExpression(callee) && callee.expression.kind === ts$1.SyntaxKind.ThisKeyword && ts$1.isIdentifier(callee.name)) calleeMatchesFunctionName = callee.name.text === functionName;
+	if (!calleeMatchesFunctionName) return false;
+	for (let current = callExpression.parent; current; current = current.parent) {
+		if (current === functionNode) return true;
+		if (tsutils.isFunctionScopeBoundary(current)) return false;
+	}
+	return false;
+}
+function isReferenceOnlyUsedInRecursion(reference, parameterIndex, functionName, functionNode) {
+	const parent = reference.parent;
+	if (!ts$1.isCallExpression(parent)) return false;
+	if (!isRecursiveCall(parent, functionName, functionNode)) return false;
+	return parent.arguments.findIndex((argument) => argument === reference) === parameterIndex;
+}
+var recursionOnlyArguments_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports function parameters that are only used in recursive calls.",
+		id: "recursionOnlyArguments",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { onlyUsedInRecursion: {
+		primary: "This parameter is only used in recursive calls.",
+		secondary: ["Parameters that are only passed through to recursive calls serve no functional purpose.", "This increases cognitive complexity and may impact performance."],
+		suggestions: ["Remove the parameter if it's not needed.", "Use the parameter in the function body for some computation."]
+	} },
+	setup(context) {
+		function checkFunction(node, { sourceFile }) {
+			const functionName = getFunctionName(node);
+			if (!functionName || !node.body) return;
+			for (const [parameterIndex, parameter] of node.parameters.entries()) if (isParameterOnlyUsedInRecursion(parameter, parameterIndex, functionName, node)) context.report({
+				message: "onlyUsedInRecursion",
+				range: getTSNodeRange(parameter.name, sourceFile)
+			});
+		}
+		return { visitors: {
+			ArrowFunction: checkFunction,
+			FunctionDeclaration: checkFunction,
+			FunctionExpression: checkFunction,
+			MethodDeclaration: checkFunction
+		} };
+	}
+});
+//#endregion
+export { recursionOnlyArguments_default as default };
+
+//# sourceMappingURL=recursionOnlyArguments.js.map

package/lib/rules/redundantTypeConstituents.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports union and intersection type constituents that are redundant or override other types.";
+    readonly id: "redundantTypeConstituents";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "errorTypeOverrides" | "literalOverridden" | "overridden" | "overrides" | "primitiveOverridden", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=redundantTypeConstituents.d.ts.map

package/lib/rules/redundantTypeConstituents.js

@@ -0,0 +1,277 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+import * as tsutils from "ts-api-utils";
+//#region src/rules/redundantTypeConstituents.ts
+const literalToPrimitiveTypeFlags = {
+	[ts.TypeFlags.BigIntLiteral]: ts.TypeFlags.BigInt,
+	[ts.TypeFlags.BooleanLiteral]: ts.TypeFlags.Boolean,
+	[ts.TypeFlags.NumberLiteral]: ts.TypeFlags.Number,
+	[ts.TypeFlags.StringLiteral]: ts.TypeFlags.String,
+	[ts.TypeFlags.TemplateLiteral]: ts.TypeFlags.String
+};
+const literalTypeFlags = [
+	ts.TypeFlags.BigIntLiteral,
+	ts.TypeFlags.BooleanLiteral,
+	ts.TypeFlags.NumberLiteral,
+	ts.TypeFlags.StringLiteral,
+	ts.TypeFlags.TemplateLiteral
+];
+const primitiveTypeFlags = [
+	ts.TypeFlags.BigInt,
+	ts.TypeFlags.Boolean,
+	ts.TypeFlags.Number,
+	ts.TypeFlags.String
+];
+const primitiveTypeFlagNames = {
+	[ts.TypeFlags.BigInt]: "bigint",
+	[ts.TypeFlags.Boolean]: "boolean",
+	[ts.TypeFlags.Number]: "number",
+	[ts.TypeFlags.String]: "string"
+};
+function describeLiteralType(type) {
+	if (type.isStringLiteral()) return JSON.stringify(type.value);
+	if (tsutils.isBigIntLiteralType(type)) return `${type.value.negative ? "-" : ""}${type.value.base10Value}n`;
+	if (type.isLiteral()) return String(type.value);
+	if (tsutils.isIntrinsicErrorType(type) && type.aliasSymbol) return String(type.aliasSymbol.escapedName);
+	if (type.flags & ts.TypeFlags.Any) return "any";
+	if (type.flags & ts.TypeFlags.Never) return "never";
+	if (type.flags & ts.TypeFlags.Unknown) return "unknown";
+	if (tsutils.isTemplateLiteralType(type)) return "template literal type";
+	if (tsutils.isTrueLiteralType(type)) return "true";
+	if (tsutils.isFalseLiteralType(type)) return "false";
+	return "literal type";
+}
+function isDescendantOf(node, potentialAncestor) {
+	let current = node;
+	while (current) {
+		if (current === potentialAncestor) return true;
+		current = current.parent;
+	}
+	return false;
+}
+function isNodeInsideReturnType(node) {
+	let current = node.parent;
+	while (current) {
+		if (current.kind === ts.SyntaxKind.FunctionDeclaration || current.kind === ts.SyntaxKind.FunctionExpression || current.kind === ts.SyntaxKind.ArrowFunction || current.kind === ts.SyntaxKind.MethodDeclaration || current.kind === ts.SyntaxKind.MethodSignature || current.kind === ts.SyntaxKind.FunctionType || current.kind === ts.SyntaxKind.CallSignature || current.kind === ts.SyntaxKind.ConstructSignature || current.kind === ts.SyntaxKind.ConstructorType) return !!current.type && isDescendantOf(node, current.type);
+		current = current.parent;
+	}
+	return false;
+}
+function unionTypePartsUnlessBoolean(type) {
+	if (type.isUnion() && type.types.length === 2 && type.types[0] && type.types[1] && tsutils.isFalseLiteralType(type.types[0]) && tsutils.isTrueLiteralType(type.types[1])) return [type];
+	return tsutils.unionConstituents(type);
+}
+var redundantTypeConstituents_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports union and intersection type constituents that are redundant or override other types.",
+		id: "redundantTypeConstituents",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: {
+		errorTypeOverrides: {
+			primary: "{{ typeName }} is an 'error' type that acts as 'any' and overrides all other types in this {{ container }} type.",
+			secondary: ["Error types that resolve to 'any' make the entire union or intersection effectively 'any'.", "This typically indicates a type reference that TypeScript couldn't resolve."],
+			suggestions: ["Remove the redundant type constituent."]
+		},
+		literalOverridden: {
+			primary: "{{ literal }} is overridden by {{ primitive }} in this union type.",
+			secondary: ["When a primitive type like 'string' is in a union with a string literal, the literal is redundant.", "The primitive type already includes all possible literal values."],
+			suggestions: ["Remove the literal type."]
+		},
+		overridden: {
+			primary: "{{ typeName }} is overridden by other types in this {{ container }} type.",
+			secondary: ["This type constituent has no effect because it is subsumed by other types in the {{ container }}.", "Consider removing it to simplify the type."],
+			suggestions: ["Remove the redundant type."]
+		},
+		overrides: {
+			primary: "{{ typeName }} overrides all other types in this {{ container }} type.",
+			secondary: ["This type makes all other constituents in the {{ container }} redundant.", "Consider simplifying to just this type."],
+			suggestions: ["Simplify to just this type."]
+		},
+		primitiveOverridden: {
+			primary: "{{ primitive }} is overridden by {{ literal }} in this intersection type.",
+			secondary: ["When a primitive type intersects with its literal type, the result is the literal type.", "The primitive type is redundant in this intersection."],
+			suggestions: ["Remove the primitive type."]
+		}
+	},
+	setup(context) {
+		return { visitors: {
+			IntersectionType: (node, { sourceFile, typeChecker }) => {
+				const seenLiteralTypes = /* @__PURE__ */ new Map();
+				const seenPrimitiveTypes = /* @__PURE__ */ new Map();
+				const seenUnionTypes = /* @__PURE__ */ new Map();
+				for (const typeNode of node.types) {
+					const typeParts = unionTypePartsUnlessBoolean(typeChecker.getTypeAtLocation(typeNode));
+					for (const typePart of typeParts) {
+						const typeName = describeLiteralType(typePart);
+						if (typePart.flags === ts.TypeFlags.Any) {
+							context.report({
+								data: {
+									container: "intersection",
+									typeName
+								},
+								message: typeName !== "any" ? "errorTypeOverrides" : "overrides",
+								range: getTSNodeRange(typeNode, sourceFile)
+							});
+							continue;
+						}
+						if (typePart.flags === ts.TypeFlags.Never) {
+							context.report({
+								data: {
+									container: "intersection",
+									typeName
+								},
+								message: "overrides",
+								range: getTSNodeRange(typeNode, sourceFile)
+							});
+							continue;
+						}
+						if (typePart.flags === ts.TypeFlags.Unknown) {
+							context.report({
+								data: {
+									container: "intersection",
+									typeName
+								},
+								message: "overridden",
+								range: getTSNodeRange(typeNode, sourceFile)
+							});
+							continue;
+						}
+						for (const literalTypeFlag of literalTypeFlags) if (typePart.flags === literalTypeFlag) {
+							const primitiveFlag = literalToPrimitiveTypeFlags[literalTypeFlag];
+							if (primitiveFlag) {
+								const existing = seenLiteralTypes.get(primitiveFlag);
+								if (existing) existing.push(typeName);
+								else seenLiteralTypes.set(primitiveFlag, [typeName]);
+							}
+							break;
+						}
+						for (const primitiveTypeFlag of primitiveTypeFlags) if (typePart.flags === primitiveTypeFlag) {
+							const existing = seenPrimitiveTypes.get(primitiveTypeFlag);
+							if (existing) existing.push(typeNode);
+							else seenPrimitiveTypes.set(primitiveTypeFlag, [typeNode]);
+						}
+					}
+					if (typeParts.length >= 2) seenUnionTypes.set(typeNode, typeParts.map((typePart) => ({
+						typeFlags: typePart.flags,
+						typeName: describeLiteralType(typePart)
+					})));
+				}
+				if (seenUnionTypes.size) {
+					for (const [typeRef, typeValues] of seenUnionTypes) {
+						let primitiveFlag;
+						for (const { typeFlags } of typeValues) {
+							const mapped = literalToPrimitiveTypeFlags[typeFlags];
+							if (mapped && seenPrimitiveTypes.has(mapped)) primitiveFlag = mapped;
+							else {
+								primitiveFlag = void 0;
+								break;
+							}
+						}
+						if (primitiveFlag !== void 0) context.report({
+							data: {
+								literal: typeValues.map((v) => v.typeName).join(" | "),
+								primitive: primitiveTypeFlagNames[primitiveFlag] ?? ""
+							},
+							message: "primitiveOverridden",
+							range: getTSNodeRange(typeRef, sourceFile)
+						});
+					}
+					return;
+				}
+				for (const [primitiveTypeFlag, typeNodes] of seenPrimitiveTypes) {
+					const matchedLiteralTypes = seenLiteralTypes.get(primitiveTypeFlag);
+					if (matchedLiteralTypes) for (const typeNode of typeNodes) context.report({
+						data: {
+							literal: matchedLiteralTypes.join(" | "),
+							primitive: primitiveTypeFlagNames[primitiveTypeFlag] ?? ""
+						},
+						message: "primitiveOverridden",
+						range: getTSNodeRange(typeNode, sourceFile)
+					});
+				}
+			},
+			UnionType: (node, { sourceFile, typeChecker }) => {
+				const seenLiteralTypes = /* @__PURE__ */ new Map();
+				const seenPrimitiveTypes = /* @__PURE__ */ new Set();
+				for (const typeNode of node.types) {
+					const typeParts = unionTypePartsUnlessBoolean(typeChecker.getTypeAtLocation(typeNode));
+					for (const typePart of typeParts) {
+						const typeName = describeLiteralType(typePart);
+						if (typePart.flags === ts.TypeFlags.Any || typePart.flags === ts.TypeFlags.Unknown) {
+							context.report({
+								data: {
+									container: "union",
+									typeName
+								},
+								message: typePart.flags === ts.TypeFlags.Any && typeName !== "any" ? "errorTypeOverrides" : "overrides",
+								range: getTSNodeRange(typeNode, sourceFile)
+							});
+							continue;
+						}
+						if (typePart.flags === ts.TypeFlags.Never && !isNodeInsideReturnType(node)) {
+							context.report({
+								data: {
+									container: "union",
+									typeName: "never"
+								},
+								message: "overridden",
+								range: getTSNodeRange(typeNode, sourceFile)
+							});
+							continue;
+						}
+						for (const literalTypeFlag of literalTypeFlags) if (typePart.flags === literalTypeFlag) {
+							const primitiveFlag = literalToPrimitiveTypeFlags[literalTypeFlag];
+							if (primitiveFlag) {
+								const existing = seenLiteralTypes.get(primitiveFlag);
+								if (existing) existing.push({
+									literalValue: typeName,
+									typeNode
+								});
+								else seenLiteralTypes.set(primitiveFlag, [{
+									literalValue: typeName,
+									typeNode
+								}]);
+							}
+							break;
+						}
+						for (const primitiveTypeFlag of primitiveTypeFlags) if ((typePart.flags & primitiveTypeFlag) !== 0) seenPrimitiveTypes.add(primitiveTypeFlag);
+					}
+				}
+				const overriddenTypeNodes = /* @__PURE__ */ new Map();
+				for (const [primitiveTypeFlag, typeNodesWithText] of seenLiteralTypes) if (seenPrimitiveTypes.has(primitiveTypeFlag)) for (const { literalValue, typeNode } of typeNodesWithText) {
+					const existing = overriddenTypeNodes.get(typeNode);
+					if (existing) existing.push({
+						literalValue,
+						primitiveTypeFlag
+					});
+					else overriddenTypeNodes.set(typeNode, [{
+						literalValue,
+						primitiveTypeFlag
+					}]);
+				}
+				for (const [typeNode, typeFlagsWithText] of overriddenTypeNodes) {
+					const grouped = /* @__PURE__ */ new Map();
+					for (const { literalValue, primitiveTypeFlag } of typeFlagsWithText) {
+						const existing = grouped.get(primitiveTypeFlag);
+						if (existing) existing.push(literalValue);
+						else grouped.set(primitiveTypeFlag, [literalValue]);
+					}
+					for (const [primitiveTypeFlag, literals] of grouped) context.report({
+						data: {
+							literal: literals.join(" | "),
+							primitive: primitiveTypeFlagNames[primitiveTypeFlag] ?? ""
+						},
+						message: "literalOverridden",
+						range: getTSNodeRange(typeNode, sourceFile)
+					});
+				}
+			}
+		} };
+	}
+});
+//#endregion
+export { redundantTypeConstituents_default as default };
+
+//# sourceMappingURL=redundantTypeConstituents.js.map

package/lib/rules/regexAllGlobalFlags.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports `matchAll()` and `replaceAll()` calls with regex arguments missing the global flag.";
+    readonly id: "regexAllGlobalFlags";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "missingGlobalFlag", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexAllGlobalFlags.d.ts.map

package/lib/rules/regexAllGlobalFlags.js

@@ -0,0 +1,56 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+//#region src/rules/regexAllGlobalFlags.ts
+function getRegexFlags(node, sourceFile) {
+	switch (node.kind) {
+		case ts.SyntaxKind.CallExpression:
+		case ts.SyntaxKind.NewExpression:
+			if (ts.isIdentifier(node.expression) && node.expression.text === "RegExp" && node.arguments) {
+				if (node.arguments.length < 2) return "";
+				const flagsArg = node.arguments[1];
+				if (ts.isStringLiteral(flagsArg)) return flagsArg.text;
+			}
+			return;
+		case ts.SyntaxKind.RegularExpressionLiteral: {
+			const text = node.getText(sourceFile);
+			const lastSlash = text.lastIndexOf("/");
+			return lastSlash >= 0 ? text.slice(lastSlash + 1) : "";
+		}
+		default: return;
+	}
+}
+var regexAllGlobalFlags_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports `matchAll()` and `replaceAll()` calls with regex arguments missing the global flag.",
+		id: "regexAllGlobalFlags",
+		presets: ["logical"]
+	},
+	messages: { missingGlobalFlag: {
+		primary: "The regex argument to `{{ method }}()` requires the global (`g`) flag.",
+		secondary: ["String.prototype.{{ method }}() throws a TypeError at runtime if the regex argument lacks the global flag."],
+		suggestions: ["Add the global (g) flag to the regex."]
+	} },
+	setup(context) {
+		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
+			if (!ts.isPropertyAccessExpression(node.expression)) return;
+			const methodName = node.expression.name.text;
+			if (methodName !== "matchAll" && methodName !== "replaceAll") return;
+			const expectedArgCount = methodName === "matchAll" ? 1 : 2;
+			if (node.arguments.length < expectedArgCount) return;
+			const firstArg = node.arguments[0];
+			if (!(typeChecker.getTypeAtLocation(node.expression.expression).flags & ts.TypeFlags.StringLike)) return;
+			const flags = getRegexFlags(firstArg, sourceFile);
+			if (flags === void 0 || flags.includes("g")) return;
+			context.report({
+				data: { method: methodName },
+				message: "missingGlobalFlag",
+				range: getTSNodeRange(firstArg, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+export { regexAllGlobalFlags_default as default };
+
+//# sourceMappingURL=regexAllGlobalFlags.js.map

package/lib/rules/regexAmbiguousInvalidity.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports regex patterns that use ambiguous or invalid syntax from Annex B.";
+    readonly id: "regexAmbiguousInvalidity";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "incompleteBackreference" | "incompleteEscapeSequence" | "invalidControlEscape" | "invalidPropertyEscape" | "invalidRange" | "octalEscape" | "quantifiedAssertion" | "regexMessage" | "unescapedSourceCharacter" | "uselessEscape", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexAmbiguousInvalidity.d.ts.map