@flint.fyi/ts 0.15.0 → 0.18.1

package/lib/rules/operatorAssignmentShorthand.js

@@ -0,0 +1,77 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, hasSameTokens, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+//#region src/rules/operatorAssignmentShorthand.ts
+const operatorTexts = new Map([
+	[ts.SyntaxKind.AmpersandToken, "&"],
+	[ts.SyntaxKind.AsteriskAsteriskToken, "**"],
+	[ts.SyntaxKind.AsteriskToken, "*"],
+	[ts.SyntaxKind.BarToken, "|"],
+	[ts.SyntaxKind.CaretToken, "^"],
+	[ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken, ">>>"],
+	[ts.SyntaxKind.GreaterThanGreaterThanToken, ">>"],
+	[ts.SyntaxKind.LessThanLessThanToken, "<<"],
+	[ts.SyntaxKind.MinusToken, "-"],
+	[ts.SyntaxKind.PercentToken, "%"],
+	[ts.SyntaxKind.PlusToken, "+"],
+	[ts.SyntaxKind.SlashToken, "/"]
+]);
+const commutativeOperatorsWithShorthand = new Set([
+	"&",
+	"*",
+	"^",
+	"|"
+]);
+const nonCommutativeOperatorsWithShorthand = new Set([
+	"%",
+	"**",
+	"+",
+	"-",
+	"/",
+	"<<",
+	">>",
+	">>>"
+]);
+var operatorAssignmentShorthand_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Prefer assignment operator shorthand where possible.",
+		id: "operatorAssignmentShorthand",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { preferShorthand: {
+		primary: "This `=` assignment can be replaced with an `{{ operator }}=` operator assignment.",
+		secondary: ["The shorthand operator assignment accomplishes the same operation with less code."],
+		suggestions: ["Switch the `=` assignment with an `{{ operator }}` operator assignment."]
+	} },
+	setup(context) {
+		function report(operator, node, right, sourceFile) {
+			const range = getTSNodeRange(node, sourceFile);
+			context.report({
+				data: { operator },
+				fix: {
+					range,
+					text: [
+						node.left.getText(sourceFile),
+						`${operator}=`,
+						right.getText(sourceFile)
+					].join(" ")
+				},
+				message: "preferShorthand",
+				range
+			});
+		}
+		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
+			if (node.operatorToken.kind !== ts.SyntaxKind.EqualsToken || !ts.isBinaryExpression(node.right)) return;
+			const operator = operatorTexts.get(node.right.operatorToken.kind);
+			if (!operator) return;
+			const isCommutative = commutativeOperatorsWithShorthand.has(operator);
+			if (!isCommutative && !nonCommutativeOperatorsWithShorthand.has(operator)) return;
+			if (hasSameTokens(node.left, node.right.left, sourceFile)) report(operator, node, node.right.right, sourceFile);
+			else if (isCommutative && hasSameTokens(node.left, node.right.right, sourceFile)) report(operator, node, node.right.left, sourceFile);
+		} } };
+	}
+});
+//#endregion
+export { operatorAssignmentShorthand_default as default };
+
+//# sourceMappingURL=operatorAssignmentShorthand.js.map

package/lib/rules/overloadSignaturesAdjacent.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Require that function overload signatures be consecutive.";
+    readonly id: "overloadSignaturesAdjacent";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "overloadSignatureSeparated", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=overloadSignaturesAdjacent.d.ts.map

package/lib/rules/overloadSignaturesAdjacent.js

@@ -0,0 +1,140 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts, { SyntaxKind } from "typescript";
+//#region src/rules/overloadSignaturesAdjacent.ts
+function getMemberMethod(member) {
+	switch (member.kind) {
+		case SyntaxKind.CallSignature: return {
+			callSignature: true,
+			name: "call",
+			static: false,
+			type: "normal"
+		};
+		case SyntaxKind.Constructor: return {
+			callSignature: false,
+			name: "constructor",
+			static: false,
+			type: "normal"
+		};
+		case SyntaxKind.ConstructSignature: return {
+			callSignature: false,
+			name: "new",
+			static: false,
+			type: "normal"
+		};
+		case SyntaxKind.ExportAssignment:
+		case SyntaxKind.ExportDeclaration: return;
+		case SyntaxKind.FunctionDeclaration: {
+			const name = member.name?.text;
+			if (name == null) return;
+			return {
+				callSignature: false,
+				name,
+				static: false,
+				type: "normal"
+			};
+		}
+		case SyntaxKind.MethodDeclaration:
+		case SyntaxKind.MethodSignature: {
+			const nameInfo = getNameFromPropertyName(member.name);
+			if (!nameInfo) return;
+			return {
+				callSignature: false,
+				name: nameInfo.name,
+				static: isStatic(member),
+				type: nameInfo.type
+			};
+		}
+	}
+	if (ts.isExportDeclaration(member) || ts.isImportDeclaration(member) || ts.isTypeAliasDeclaration(member) || ts.isInterfaceDeclaration(member) || ts.isClassDeclaration(member) || ts.isEnumDeclaration(member) || ts.isModuleDeclaration(member)) return;
+}
+function getMembers(node) {
+	switch (node.kind) {
+		case SyntaxKind.Block:
+		case SyntaxKind.ModuleBlock:
+		case SyntaxKind.SourceFile: return node.statements;
+		case SyntaxKind.ClassDeclaration:
+		case SyntaxKind.ClassExpression: return node.members;
+		case SyntaxKind.InterfaceDeclaration: return node.members;
+		case SyntaxKind.TypeLiteral: return node.members;
+	}
+}
+function getMethodDisplayName(method) {
+	if (method.static) return `static ${method.name}`;
+	if (method.type === "quoted") return `"${method.name}"`;
+	return method.name;
+}
+function getNameFromPropertyName(name) {
+	switch (name.kind) {
+		case SyntaxKind.ComputedPropertyName:
+			if (ts.isStringLiteral(name.expression)) return {
+				name: name.expression.text,
+				type: "quoted"
+			};
+			return;
+		case SyntaxKind.Identifier:
+		case SyntaxKind.NumericLiteral:
+		case SyntaxKind.PrivateIdentifier: return {
+			name: name.text,
+			type: "normal"
+		};
+		case SyntaxKind.StringLiteral: return {
+			name: name.text,
+			type: "quoted"
+		};
+		default: return;
+	}
+}
+function isSameMethod(method1, method2) {
+	return !!method2 && method1.name === method2.name && method1.static === method2.static && method1.callSignature === method2.callSignature && method1.type === method2.type;
+}
+function isStatic(node) {
+	return ts.canHaveModifiers(node) && !!node.modifiers?.some((mod) => mod.kind === SyntaxKind.StaticKeyword);
+}
+var overloadSignaturesAdjacent_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Require that function overload signatures be consecutive.",
+		id: "overloadSignaturesAdjacent",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { overloadSignatureSeparated: {
+		primary: "All {{ name }} signatures should be adjacent.",
+		secondary: ["Separating overload signatures makes code harder to read and maintain.", "Grouping all overloads for a function together makes it easier to read and understand that function."],
+		suggestions: ["Group all overload signatures for this function together."]
+	} },
+	setup(context) {
+		function checkNode(node, { sourceFile }) {
+			const members = getMembers(node);
+			let lastMethod;
+			const seenMethods = [];
+			for (const member of members) {
+				const method = getMemberMethod(member);
+				if (method == null) {
+					lastMethod = void 0;
+					continue;
+				}
+				const indexOfSameMethod = seenMethods.findIndex((seenMethod) => isSameMethod(method, seenMethod));
+				if (indexOfSameMethod > -1 && !isSameMethod(method, lastMethod)) context.report({
+					data: { name: getMethodDisplayName(method) },
+					message: "overloadSignatureSeparated",
+					range: getTSNodeRange(member, sourceFile)
+				});
+				else if (indexOfSameMethod === -1) seenMethods.push(method);
+				lastMethod = method;
+			}
+		}
+		return { visitors: {
+			Block: checkNode,
+			ClassDeclaration: checkNode,
+			ClassExpression: checkNode,
+			InterfaceDeclaration: checkNode,
+			ModuleBlock: checkNode,
+			SourceFile: checkNode,
+			TypeLiteral: checkNode
+		} };
+	}
+});
+//#endregion
+export { overloadSignaturesAdjacent_default as default };
+
+//# sourceMappingURL=overloadSignaturesAdjacent.js.map

package/lib/rules/parameterReassignments.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Disallow reassignment of function parameters.";
+    readonly id: "parameterReassignments";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "parameterReassignment", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=parameterReassignments.d.ts.map

package/lib/rules/parameterReassignments.js

@@ -0,0 +1,76 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+//#region src/rules/parameterReassignments.ts
+function collectParameterNames(parameters) {
+	const names = /* @__PURE__ */ new Set();
+	const collectNames = (node) => {
+		if (node.kind === ts.SyntaxKind.Identifier) names.add(node.text);
+		else if (ts.isObjectBindingPattern(node)) {
+			for (const element of node.elements) if (!ts.isOmittedExpression(element)) collectNames(element.name);
+		} else if (ts.isArrayBindingPattern(node)) {
+			for (const element of node.elements) if (!ts.isOmittedExpression(element)) collectNames(element.name);
+		}
+	};
+	for (const parameter of parameters) collectNames(parameter.name);
+	return names;
+}
+var parameterReassignments_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Disallow reassignment of function parameters.",
+		id: "parameterReassignments",
+		presets: ["logical"]
+	},
+	messages: { parameterReassignment: {
+		primary: "Reassigning function parameters can make them more difficult to reason about.",
+		secondary: [
+			"Most code treats function parameters as constants.",
+			"Reassigning them inside the function removes that reference to the original value.",
+			"It's generally more understandable to write code that does not modify parameters."
+		],
+		suggestions: ["Use a new variable if you need to modify the value.", "Use a different pattern such as a helper function."]
+	} },
+	setup(context) {
+		const scopes = /* @__PURE__ */ new Map();
+		const checkParameterAssignment = (name, node, sourceFile) => {
+			let currentNode = node;
+			while (currentNode !== void 0) {
+				if (ts.isFunctionDeclaration(currentNode) || ts.isFunctionExpression(currentNode) || ts.isArrowFunction(currentNode)) {
+					if (scopes.get(currentNode)?.has(name)) context.report({
+						message: "parameterReassignment",
+						range: getTSNodeRange(node, sourceFile)
+					});
+					return;
+				}
+				currentNode = currentNode.parent;
+			}
+		};
+		const handleUnaryExpression = (node, { sourceFile }) => {
+			if ((node.operator === ts.SyntaxKind.PlusPlusToken || node.operator === ts.SyntaxKind.MinusMinusToken) && ts.isIdentifier(node.operand)) checkParameterAssignment(node.operand.text, node.operand, sourceFile);
+		};
+		return { visitors: {
+			ArrowFunction: (node) => {
+				scopes.set(node, collectParameterNames(node.parameters));
+			},
+			BinaryExpression: (node, { sourceFile }) => {
+				if (!(node.operatorToken.kind === ts.SyntaxKind.EqualsToken || node.operatorToken.kind === ts.SyntaxKind.PlusEqualsToken || node.operatorToken.kind === ts.SyntaxKind.MinusEqualsToken || node.operatorToken.kind === ts.SyntaxKind.AsteriskEqualsToken || node.operatorToken.kind === ts.SyntaxKind.SlashEqualsToken) || !ts.isIdentifier(node.left)) return;
+				checkParameterAssignment(node.left.text, node.left, sourceFile);
+			},
+			FunctionDeclaration: (node) => {
+				scopes.set(node, collectParameterNames(node.parameters));
+			},
+			FunctionExpression: (node) => {
+				scopes.set(node, collectParameterNames(node.parameters));
+			},
+			PostfixUnaryExpression: handleUnaryExpression,
+			PrefixUnaryExpression: handleUnaryExpression,
+			Program: () => {
+				scopes.clear();
+			}
+		} };
+	}
+});
+//#endregion
+export { parameterReassignments_default as default };
+
+//# sourceMappingURL=parameterReassignments.js.map

package/lib/rules/parseIntRadixes.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports parseInt calls that are missing or have an invalid radix parameter.";
+    readonly id: "parseIntRadixes";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "invalidRadix" | "missingRadix", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=parseIntRadixes.d.ts.map

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