@flint.fyi/ts 0.20.0 → 0.22.0

package/lib/rules/octalNumbers.js

@@ -1,55 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import { nullThrows } from "@flint.fyi/utils";
-//#region src/rules/octalNumbers.ts
-var octalNumbers_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using legacy octal numeric literals.",
-		id: "octalNumbers",
-		presets: ["javascript"]
-	},
-	messages: { noOctalNumber: {
-		primary: "This legacy octal numeric literal evaluates to {{ raw }}. Did you mean that value, or to use a modern octal syntax such as {{ equivalent }}?",
-		secondary: [
-			"Legacy octal numeric literals (e.g., `077`, `0123`) are a deprecated feature in JavaScript that can lead to confusion and errors.",
-			"They are forbidden in strict mode and are less readable than their modern alternatives.",
-			"The digit `0` by itself is allowed as it represents zero, not an octal literal."
-		],
-		suggestions: ["Use the explicit octal syntax (e.g., `0o77`) introduced in ES6, which is clearer and works in both strict and non-strict modes.", "Remove the leading `0` if you intended to use the decimal value."]
-	} },
-	setup(context) {
-		return { visitors: { NumericLiteral: (node, { sourceFile }) => {
-			const text = node.getText(sourceFile);
-			if (text.length > 1 && text.startsWith("0") && nullThrows(text[1], "Second character is expected to be present by prior length check") >= "0" && nullThrows(text[1], "Second character is expected to be present by prior length check") <= "7" && !/^0[xobi]/i.test(text)) {
-				const range = {
-					begin: node.getStart(sourceFile),
-					end: node.getEnd()
-				};
-				const octalValue = parseInt(text, 8);
-				const modernOctalSyntax = `0o${text.slice(1)}`;
-				const decimalWithoutLeadingZero = text.slice(1);
-				context.report({
-					data: {
-						equivalent: modernOctalSyntax,
-						raw: octalValue.toString()
-					},
-					message: "noOctalNumber",
-					range,
-					suggestions: [{
-						id: "useModernOctalSyntax",
-						range,
-						text: modernOctalSyntax
-					}, {
-						id: "removeLeadingZero",
-						range,
-						text: decimalWithoutLeadingZero
-					}]
-				});
-			}
-		} } };
-	}
-});
-//#endregion
-export { octalNumbers_default as default };
-
-//# sourceMappingURL=octalNumbers.js.map

package/lib/rules/operatorAssignmentShorthand.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Prefer assignment operator shorthand where possible.";
-    readonly id: "operatorAssignmentShorthand";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferShorthand", undefined>;
-export default _default;
-//# sourceMappingURL=operatorAssignmentShorthand.d.ts.map

package/lib/rules/operatorAssignmentShorthand.js

@@ -1,77 +0,0 @@
-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

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

package/lib/rules/overloadSignaturesAdjacent.js

@@ -1,140 +0,0 @@
-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

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

package/lib/rules/parameterReassignments.js

@@ -1,45 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getScopeManager, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/parameterReassignments.ts
-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) {
-		function reportParameterReassignments(node, { sourceFile }) {
-			const scopeManager = getScopeManager(sourceFile);
-			const parameterVariables = new Set(node.parameters.flatMap((parameter) => scopeManager.getDeclaredVariables(parameter)));
-			for (const reference of scopeManager.getReferencesInScope(node)) {
-				if (!reference.isWrite || !reference.variable || !parameterVariables.has(reference.variable)) continue;
-				context.report({
-					message: "parameterReassignment",
-					range: getTSNodeRange(reference.identifier, sourceFile)
-				});
-			}
-		}
-		return { visitors: {
-			ArrowFunction: reportParameterReassignments,
-			Constructor: reportParameterReassignments,
-			FunctionDeclaration: reportParameterReassignments,
-			FunctionExpression: reportParameterReassignments,
-			GetAccessor: reportParameterReassignments,
-			MethodDeclaration: reportParameterReassignments,
-			SetAccessor: reportParameterReassignments
-		} };
-	}
-});
-//#endregion
-export { parameterReassignments_default as default };
-
-//# sourceMappingURL=parameterReassignments.js.map

package/lib/rules/parseIntRadixes.d.ts

@@ -1,10 +0,0 @@
-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: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "invalidRadix" | "missingRadix", undefined>;
-export default _default;
-//# sourceMappingURL=parseIntRadixes.d.ts.map

package/lib/rules/parseIntRadixes.js

@@ -1,62 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferDotNotation", {
-    allowIndexSignaturePropertyAccess: z.ZodDefault<z.ZodBoolean>;
-}>;
-export default _default;
-//# sourceMappingURL=propertyAccessNotation.d.ts.map

package/lib/rules/propertyAccessNotation.js

@@ -1,119 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "onlyUsedInRecursion", undefined>;
-export default _default;
-//# sourceMappingURL=recursionOnlyArguments.d.ts.map

package/lib/rules/recursionOnlyArguments.js

@@ -1,71 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "errorTypeOverrides" | "literalOverridden" | "overridden" | "overrides" | "primitiveOverridden", undefined>;
-export default _default;
-//# sourceMappingURL=redundantTypeConstituents.d.ts.map