@flint.fyi/ts 0.20.0 → 0.22.0

package/lib/rules/anyAssignments.js

@@ -1,265 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { AnyType, discriminateAnyType } from "./utils/discriminateAnyType.js";
-import { formatReportedType } from "./utils/formatReportedType.js";
-import { isUnsafeAssignment } from "./utils/isUnsafeAssignment.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/anyAssignments.ts
-function isTypeAny(type) {
-	return tsutils.isTypeFlagSet(type, ts$1.TypeFlags.Any) && !tsutils.isIntrinsicErrorType(type);
-}
-function isTypeAnyArray(type, checker) {
-	if (!checker.isArrayType(type)) return false;
-	const elementType = checker.getTypeArguments(type)[0];
-	return elementType !== void 0 && isTypeAny(elementType);
-}
-function isTypeAnyOrUnknown(type) {
-	return tsutils.isTypeFlagSet(type, ts$1.TypeFlags.Any | ts$1.TypeFlags.Unknown);
-}
-var anyAssignments_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports assigning a value with type `any` to variables and properties.",
-		id: "anyAssignments",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: {
-		unsafeArrayDestructure: {
-			primary: "Unsafe array destructuring of a value of type {{ type }}.",
-			secondary: ["Destructuring an `any[]` array defeats TypeScript's type safety guarantees.", "This can allow unexpected types to propagate through your codebase, potentially causing runtime errors."],
-			suggestions: ["Ensure the array has a well-defined, specific element type."]
-		},
-		unsafeArrayPatternFromTuple: {
-			primary: "Unsafe array destructuring of a tuple element with type {{ type }}.",
-			secondary: ["Destructuring a tuple with `any` elements defeats TypeScript's type safety guarantees.", "This can allow unexpected types to propagate through your codebase, potentially causing runtime errors."],
-			suggestions: ["Ensure the tuple has well-defined, specific element types."]
-		},
-		unsafeArraySpread: {
-			primary: "Unsafe spread of type `{{ sender }}` into array of type `{{ receiver }}`.",
-			secondary: ["Spreading an `any[]` into a typed array defeats TypeScript's type safety guarantees.", "This can allow unexpected types to propagate through your codebase, potentially causing runtime errors."],
-			suggestions: ["Ensure the spread array has compatible element types."]
-		},
-		unsafeAssignment: {
-			primary: "Unsafe assignment of a value of type `{{ type }}`.",
-			secondary: ["Assigning a value of type `any` or a similar unsafe type defeats TypeScript's type safety guarantees.", "This can allow unexpected types to propagate through your codebase, potentially causing runtime errors."],
-			suggestions: ["Ensure the assigned value has a well-defined, specific type."]
-		},
-		unsafeAssignmentToVariable: {
-			primary: "Unsafe assignment of type `{{ sender }}` to variable of type `{{ receiver }}`.",
-			secondary: ["The variable's declared type does not safely accept the value being assigned.", "This can allow unexpected types to propagate through your codebase, potentially causing runtime errors."],
-			suggestions: ["Adjust the type of the variable to match the assigned value, if appropriate.", "Otherwise, refine the assigned value to ensure it matches the expected type."]
-		},
-		unsafeObjectPattern: {
-			primary: "Unsafe object destructuring of a property with type {{ type }}.",
-			secondary: ["Destructuring an object with `any` properties defeats TypeScript's type safety guarantees.", "This can allow unexpected types to propagate through your codebase, potentially causing runtime errors."],
-			suggestions: ["Ensure the object has well-defined, specific property types."]
-		}
-	},
-	setup(context) {
-		function checkArrayDestructureWorker(pattern, senderType, sourceFile, typeChecker) {
-			if (isTypeAnyArray(senderType, typeChecker)) {
-				context.report({
-					data: { type: "`any[]`" },
-					message: "unsafeArrayDestructure",
-					range: {
-						begin: pattern.getStart(sourceFile),
-						end: pattern.getEnd()
-					}
-				});
-				return true;
-			}
-			if (!typeChecker.isTupleType(senderType)) return false;
-			const tupleElements = typeChecker.getTypeArguments(senderType);
-			let didReport = false;
-			for (let i = 0; i < pattern.elements.length; i++) {
-				const element = pattern.elements[i];
-				if (!element || ts$1.isOmittedExpression(element)) continue;
-				if (element.dotDotDotToken) continue;
-				const elementType = tupleElements[i];
-				if (!elementType) continue;
-				const name = element.name;
-				if (isTypeAny(elementType)) {
-					context.report({
-						data: { type: "`any`" },
-						message: "unsafeArrayPatternFromTuple",
-						range: {
-							begin: name.getStart(sourceFile),
-							end: name.getEnd()
-						}
-					});
-					didReport = true;
-				} else if (ts$1.isArrayBindingPattern(name)) didReport = checkArrayDestructureWorker(name, elementType, sourceFile, typeChecker) || didReport;
-				else if (ts$1.isObjectBindingPattern(name)) didReport = checkObjectDestructureWorker(name, elementType, sourceFile, typeChecker) || didReport;
-			}
-			return didReport;
-		}
-		function checkObjectDestructureWorker(pattern, senderType, sourceFile, typeChecker) {
-			let didReport = false;
-			for (const element of pattern.elements) {
-				if (element.dotDotDotToken) continue;
-				let key;
-				const propertyName = element.propertyName ?? element.name;
-				if (ts$1.isIdentifier(propertyName) || ts$1.isStringLiteral(propertyName) || ts$1.isNumericLiteral(propertyName)) key = propertyName.text;
-				else if (ts$1.isComputedPropertyName(propertyName)) {
-					const expression = propertyName.expression;
-					if (ts$1.isStringLiteral(expression) || ts$1.isNoSubstitutionTemplateLiteral(expression)) key = expression.text;
-				}
-				if (key === void 0) continue;
-				const propertySymbol = senderType.getProperty(key);
-				if (!propertySymbol) continue;
-				const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, pattern);
-				const name = element.name;
-				if (isTypeAny(propertyType)) {
-					context.report({
-						data: { type: "`any`" },
-						message: "unsafeObjectPattern",
-						range: {
-							begin: name.getStart(sourceFile),
-							end: name.getEnd()
-						}
-					});
-					didReport = true;
-				} else if (ts$1.isArrayBindingPattern(name)) didReport = checkArrayDestructureWorker(name, propertyType, sourceFile, typeChecker) || didReport;
-				else if (ts$1.isObjectBindingPattern(name)) didReport = checkObjectDestructureWorker(name, propertyType, sourceFile, typeChecker) || didReport;
-			}
-			return didReport;
-		}
-		function checkArrayDestructure(pattern, senderType, sourceFile, typeChecker) {
-			return checkArrayDestructureWorker(pattern, senderType, sourceFile, typeChecker);
-		}
-		function checkObjectDestructure(pattern, senderType, sourceFile, typeChecker) {
-			return checkObjectDestructureWorker(pattern, senderType, sourceFile, typeChecker);
-		}
-		function checkAssignment(initializerType, declaredType, initializer, reportNode, sourceFile, typeChecker) {
-			if (tsutils.isIntrinsicErrorType(initializerType)) return false;
-			const anyType = discriminateAnyType(initializerType, typeChecker, initializer);
-			if (declaredType === void 0) {
-				if (anyType !== AnyType.Safe) {
-					context.report({
-						data: { type: anyType },
-						message: "unsafeAssignment",
-						range: {
-							begin: reportNode.getStart(sourceFile),
-							end: reportNode.getEnd()
-						}
-					});
-					return true;
-				}
-				return false;
-			}
-			if (isTypeAnyOrUnknown(declaredType)) return false;
-			const result = isUnsafeAssignment(initializerType, declaredType, initializer);
-			if (!result) return false;
-			context.report({
-				data: {
-					receiver: formatReportedType(result.receiver, typeChecker),
-					sender: formatReportedType(result.sender, typeChecker)
-				},
-				message: "unsafeAssignmentToVariable",
-				range: {
-					begin: reportNode.getStart(sourceFile),
-					end: reportNode.getEnd()
-				}
-			});
-			return true;
-		}
-		return { visitors: {
-			ArrayLiteralExpression: (node, { sourceFile, typeChecker }) => {
-				for (const element of node.elements) {
-					if (!ts$1.isSpreadElement(element)) continue;
-					const spreadType = typeChecker.getTypeAtLocation(element.expression);
-					if (!typeChecker.isArrayType(spreadType)) continue;
-					const spreadElementType = typeChecker.getTypeArguments(spreadType)[0];
-					if (!spreadElementType || !isTypeAny(spreadElementType)) continue;
-					const parentType = typeChecker.getContextualType(node);
-					if (!parentType || !typeChecker.isArrayType(parentType)) continue;
-					const parentElementType = typeChecker.getTypeArguments(parentType)[0];
-					if (!parentElementType || isTypeAnyOrUnknown(parentElementType)) continue;
-					context.report({
-						data: {
-							receiver: typeChecker.typeToString(parentType),
-							sender: typeChecker.typeToString(spreadType)
-						},
-						message: "unsafeArraySpread",
-						range: {
-							begin: element.getStart(sourceFile),
-							end: element.getEnd()
-						}
-					});
-				}
-			},
-			Parameter: (node, { sourceFile, typeChecker }) => {
-				if (!node.initializer) return;
-				const initializerType = typeChecker.getTypeAtLocation(node.initializer);
-				if (ts$1.isArrayBindingPattern(node.name)) {
-					checkArrayDestructure(node.name, initializerType, sourceFile, typeChecker);
-					return;
-				}
-				if (ts$1.isObjectBindingPattern(node.name)) {
-					checkObjectDestructure(node.name, initializerType, sourceFile, typeChecker);
-					return;
-				}
-				checkAssignment(initializerType, node.type ? typeChecker.getTypeAtLocation(node.name) : void 0, node.initializer, node, sourceFile, typeChecker);
-			},
-			PropertyAssignment: (node, { sourceFile, typeChecker }) => {
-				if (!isTypeAny(typeChecker.getTypeAtLocation(node.initializer))) return;
-				if (!ts$1.isObjectLiteralExpression(node.parent)) return;
-				const contextualType = typeChecker.getContextualType(node.parent);
-				if (!contextualType) return;
-				let key;
-				if (ts$1.isIdentifier(node.name) || ts$1.isStringLiteral(node.name) || ts$1.isNumericLiteral(node.name)) key = node.name.text;
-				if (key === void 0) return;
-				const propertySymbol = contextualType.getProperty(key);
-				if (!propertySymbol) return;
-				if (isTypeAnyOrUnknown(typeChecker.getTypeOfSymbolAtLocation(propertySymbol, node))) return;
-				context.report({
-					data: { type: "any" },
-					message: "unsafeAssignment",
-					range: {
-						begin: node.getStart(sourceFile),
-						end: node.getEnd()
-					}
-				});
-			},
-			PropertyDeclaration: (node, { sourceFile, typeChecker }) => {
-				if (!node.initializer) return;
-				checkAssignment(typeChecker.getTypeAtLocation(node.initializer), node.type ? typeChecker.getTypeAtLocation(node.name) : void 0, node.initializer, node, sourceFile, typeChecker);
-			},
-			ShorthandPropertyAssignment: (node, { sourceFile, typeChecker }) => {
-				if (!isTypeAny(typeChecker.getTypeAtLocation(node.name))) return;
-				const parent = node.parent;
-				if (!ts$1.isObjectLiteralExpression(parent)) return;
-				const contextualType = typeChecker.getContextualType(parent);
-				if (!contextualType) return;
-				const propertySymbol = contextualType.getProperty(node.name.text);
-				if (!propertySymbol) return;
-				if (isTypeAnyOrUnknown(typeChecker.getTypeOfSymbolAtLocation(propertySymbol, node))) return;
-				context.report({
-					data: { type: "any" },
-					message: "unsafeAssignment",
-					range: {
-						begin: node.getStart(sourceFile),
-						end: node.getEnd()
-					}
-				});
-			},
-			VariableDeclaration: (node, { sourceFile, typeChecker }) => {
-				if (!node.initializer) return;
-				const initializerType = typeChecker.getTypeAtLocation(node.initializer);
-				if (ts$1.isArrayBindingPattern(node.name)) {
-					checkArrayDestructure(node.name, initializerType, sourceFile, typeChecker);
-					return;
-				}
-				if (ts$1.isObjectBindingPattern(node.name)) {
-					checkObjectDestructure(node.name, initializerType, sourceFile, typeChecker);
-					return;
-				}
-				checkAssignment(initializerType, node.type ? typeChecker.getTypeAtLocation(node.name) : void 0, node.initializer, node, sourceFile, typeChecker);
-			}
-		} };
-	}
-});
-//#endregion
-export { anyAssignments_default as default };
-
-//# sourceMappingURL=anyAssignments.js.map

package/lib/rules/anyCalls.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports calling a value with type `any`.";
-    readonly id: "anyCalls";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unsafeCall" | "unsafeNew" | "unsafeTemplateTag", undefined>;
-export default _default;
-//# sourceMappingURL=anyCalls.d.ts.map

package/lib/rules/anyCalls.js

@@ -1,68 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
-import { isBuiltinSymbolLike } from "./utils/isBuiltinSymbolLike.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/anyCalls.ts
-var anyCalls_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports calling a value with type `any`.",
-		id: "anyCalls",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: {
-		unsafeCall: {
-			primary: "Unsafe call of {{ type }} typed value.",
-			secondary: ["Calling a value typed as `any` or `Function` bypasses TypeScript's type checking.", "TypeScript cannot verify that the value is actually a function, what parameters it expects, or what it returns."],
-			suggestions: ["Ensure the called value has a well-defined function type."]
-		},
-		unsafeNew: {
-			primary: "Unsafe construction of {{ type }} typed value.",
-			secondary: ["Constructing a value typed as `any` or `Function` bypasses TypeScript's type checking.", "TypeScript cannot verify that the value is actually a constructor, what parameters it expects, or what it returns."],
-			suggestions: ["Ensure the constructed value has a well-defined constructor type."]
-		},
-		unsafeTemplateTag: {
-			primary: "Unsafe use of {{ type }} typed template tag.",
-			secondary: ["Using a value typed as `any` or `Function` as a template tag bypasses TypeScript's type checking.", "TypeScript cannot verify that the value is a valid template tag function."],
-			suggestions: ["Ensure the template tag has a well-defined function type."]
-		}
-	},
-	setup(context) {
-		function checkNode(node, { program, sourceFile, typeChecker }, message, allowVoid) {
-			const type = getConstrainedTypeAtLocation(node, typeChecker);
-			if (tsutils.isTypeFlagSet(type, ts$1.TypeFlags.Any)) {
-				if (tsutils.isIntrinsicErrorType(type)) return;
-				context.report({
-					data: { type: "`any`" },
-					message,
-					range: getTSNodeRange(node, sourceFile)
-				});
-				return;
-			}
-			if (!isBuiltinSymbolLike(program, type, "Function") || type.getConstructSignatures().length) return;
-			const callSignatures = type.getCallSignatures();
-			if (callSignatures.length && (!allowVoid || callSignatures.some((signature) => !tsutils.isIntrinsicVoidType(signature.getReturnType())))) return;
-			context.report({
-				data: { type: "`Function`" },
-				message,
-				range: getTSNodeRange(node, sourceFile)
-			});
-		}
-		return { visitors: {
-			CallExpression: (node, services) => {
-				if (node.expression.kind !== ts$1.SyntaxKind.ImportKeyword) checkNode(node.expression, services, "unsafeCall");
-			},
-			NewExpression: (node, services) => {
-				checkNode(node.expression, services, "unsafeNew", true);
-			},
-			TaggedTemplateExpression: (node, services) => {
-				checkNode(node.tag, services, "unsafeTemplateTag");
-			}
-		} };
-	}
-});
-//#endregion
-export { anyCalls_default as default };
-
-//# sourceMappingURL=anyCalls.js.map

package/lib/rules/anyMemberAccess.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports member access on a value with type `any`.";
-    readonly id: "anyMemberAccess";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unsafeComputedMemberAccess" | "unsafeMemberAccess", undefined>;
-export default _default;
-//# sourceMappingURL=anyMemberAccess.d.ts.map

package/lib/rules/anyMemberAccess.js

@@ -1,85 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.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/anyMemberAccess.ts
-var anyMemberAccess_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports member access on a value with type `any`.",
-		id: "anyMemberAccess",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: {
-		unsafeComputedMemberAccess: {
-			primary: "Computed key is {{ type }} typed.",
-			secondary: ["Using a value typed as `any` as a computed property key bypasses TypeScript's type checking.", "TypeScript cannot verify that the key is valid for the object being accessed."],
-			suggestions: ["Ensure the computed key has a well-defined type."]
-		},
-		unsafeMemberAccess: {
-			primary: "Unsafe member access on {{ type }} typed value.",
-			secondary: ["Accessing a member of a value typed as `any` bypasses TypeScript's type checking.", "TypeScript cannot verify that the member exists or what type it has."],
-			suggestions: ["Ensure the accessed value has a well-defined type with known properties."]
-		}
-	},
-	setup(context) {
-		const reportedChains = /* @__PURE__ */ new WeakSet();
-		function isInHeritageClause(node) {
-			let current = node.parent;
-			while (current) {
-				if (ts$1.isHeritageClause(current)) return true;
-				current = current.parent;
-			}
-			return false;
-		}
-		function findRootAnyAccess(node, typeChecker) {
-			const objectType = getConstrainedTypeAtLocation(node.expression, typeChecker);
-			if (!tsutils.isTypeFlagSet(objectType, ts$1.TypeFlags.Any)) return;
-			if (ts$1.isPropertyAccessExpression(node.expression) || ts$1.isElementAccessExpression(node.expression)) {
-				const deeper = findRootAnyAccess(node.expression, typeChecker);
-				if (deeper) return deeper;
-			}
-			return node;
-		}
-		function markChainAsReported(node) {
-			reportedChains.add(node);
-			if (ts$1.isPropertyAccessExpression(node.expression) || ts$1.isElementAccessExpression(node.expression)) markChainAsReported(node.expression);
-		}
-		function checkMemberExpression(node, sourceFile, typeChecker) {
-			if (reportedChains.has(node) || isInHeritageClause(node)) return;
-			const rootAccess = findRootAnyAccess(node, typeChecker);
-			if (!rootAccess) return;
-			markChainAsReported(node);
-			const objectType = getConstrainedTypeAtLocation(rootAccess.expression, typeChecker);
-			const reportNode = rootAccess.kind === ts$1.SyntaxKind.PropertyAccessExpression ? rootAccess.name : rootAccess.argumentExpression;
-			context.report({
-				data: { type: tsutils.isIntrinsicErrorType(objectType) ? "`error`" : "`any`" },
-				message: "unsafeMemberAccess",
-				range: getTSNodeRange(reportNode, sourceFile)
-			});
-		}
-		function checkComputedKey(node, sourceFile, typeChecker) {
-			const keyNode = node.argumentExpression;
-			if (ts$1.isStringLiteral(keyNode) || ts$1.isNumericLiteral(keyNode) || ts$1.isNoSubstitutionTemplateLiteral(keyNode)) return;
-			const keyType = getConstrainedTypeAtLocation(keyNode, typeChecker);
-			if (tsutils.isTypeFlagSet(keyType, ts$1.TypeFlags.Any)) context.report({
-				data: { type: tsutils.isIntrinsicErrorType(keyType) ? "`error`" : "`any`" },
-				message: "unsafeComputedMemberAccess",
-				range: getTSNodeRange(keyNode, sourceFile)
-			});
-		}
-		return { visitors: {
-			ElementAccessExpression: (node, { sourceFile, typeChecker }) => {
-				checkMemberExpression(node, sourceFile, typeChecker);
-				checkComputedKey(node, sourceFile, typeChecker);
-			},
-			PropertyAccessExpression: (node, { sourceFile, typeChecker }) => {
-				checkMemberExpression(node, sourceFile, typeChecker);
-			}
-		} };
-	}
-});
-//#endregion
-export { anyMemberAccess_default as default };
-
-//# sourceMappingURL=anyMemberAccess.js.map

package/lib/rules/anyReturns.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports returning a value with type `any` from a function.";
-    readonly id: "anyReturns";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unsafeReturn" | "unsafeReturnAssignment" | "unsafeReturnThis", undefined>;
-export default _default;
-//# sourceMappingURL=anyReturns.d.ts.map

package/lib/rules/anyReturns.js

@@ -1,102 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { AnyType, discriminateAnyType } from "./utils/discriminateAnyType.js";
-import { isUnsafeAssignment } from "./utils/isUnsafeAssignment.js";
-import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
-import { getThisExpression } from "./utils/getThisExpression.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts, { SyntaxKind } from "typescript";
-import * as tsutils from "ts-api-utils";
-import { nullThrows } from "@flint.fyi/utils";
-//#region src/rules/anyReturns.ts
-var anyReturns_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports returning a value with type `any` from a function.",
-		id: "anyReturns",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: {
-		unsafeReturn: {
-			primary: "Unsafe return of a value of type `{{ type }}`.",
-			secondary: ["Returning a value of type `any` or a similar unsafe type defeats TypeScript's type safety guarantees.", "This can allow unexpected types to propagate through your codebase, potentially causing runtime errors."],
-			suggestions: ["Ensure the returned value has a well-defined, specific type."]
-		},
-		unsafeReturnAssignment: {
-			primary: "Unsafe return of type `{{ sender }}` from function with return type `{{ receiver }}`.",
-			secondary: ["The function's declared return type does not safely accept the value being returned.", "This can allow unexpected types to propagate through your codebase, potentially causing runtime errors."],
-			suggestions: ["Adjust the return type of the function to match the returned value, if appropriate.", "Otherwise, refine the returned value to ensure it matches the expected return type."]
-		},
-		unsafeReturnThis: {
-			primary: "Unsafe return of a value of type `{{ type }}`. `this` is typed as `any`.",
-			secondary: ["Returning `this` when it is implicitly typed as `any` introduces type-unsafe behavior.", "This can allow unexpected types to propagate through your codebase, potentially causing runtime errors."],
-			suggestions: ["Enable the `noImplicitThis` compiler option to enforce explicit `this` types.", "Add an explicit `this` parameter to the function to clarify its type."]
-		}
-	},
-	setup(context) {
-		function checkReturn(returnNode, reportingNode, { program, sourceFile, typeChecker }) {
-			const type = typeChecker.getTypeAtLocation(returnNode);
-			const functionNode = ts.findAncestor(returnNode, tsutils.isFunctionLikeDeclaration);
-			if (!functionNode) return;
-			const returnNodeType = getConstrainedTypeAtLocation(returnNode, typeChecker);
-			const anyType = tsutils.isIntrinsicErrorType(returnNodeType) ? AnyType.Error : discriminateAnyType(type, typeChecker, returnNode);
-			let functionType = functionNode.kind === SyntaxKind.FunctionExpression || functionNode.kind === SyntaxKind.ArrowFunction ? typeChecker.getContextualType(functionNode) : typeChecker.getTypeAtLocation(functionNode);
-			functionType ??= typeChecker.getTypeAtLocation(functionNode);
-			const callSignatures = tsutils.getCallSignaturesOfType(functionType);
-			if (functionNode.type) for (const signature of callSignatures) {
-				const signatureReturnType = signature.getReturnType();
-				if (returnNodeType === signatureReturnType || tsutils.isTypeFlagSet(signatureReturnType, ts.TypeFlags.Any | ts.TypeFlags.Unknown)) return;
-				if (tsutils.includesModifier(functionNode.modifiers, SyntaxKind.AsyncKeyword)) {
-					const awaitedSignatureReturnType = typeChecker.getAwaitedType(signatureReturnType);
-					if (typeChecker.getAwaitedType(returnNodeType) === awaitedSignatureReturnType || awaitedSignatureReturnType && tsutils.isTypeFlagSet(awaitedSignatureReturnType, ts.TypeFlags.Any | ts.TypeFlags.Unknown)) return;
-				}
-			}
-			if (anyType !== AnyType.Safe) {
-				for (const signature of callSignatures) {
-					const functionReturnType = signature.getReturnType();
-					if ((anyType === AnyType.Any || anyType === AnyType.Error) && tsutils.isTypeFlagSet(functionReturnType, ts.TypeFlags.Unknown)) return;
-					if (anyType === AnyType.AnyArray && typeChecker.isArrayType(functionReturnType) && tsutils.isTypeFlagSet(nullThrows(typeChecker.getTypeArguments(functionReturnType)[0], "Array type should have at least one type argument"), ts.TypeFlags.Unknown)) return;
-					const awaitedType = typeChecker.getAwaitedType(functionReturnType);
-					if (awaitedType && anyType === AnyType.PromiseAny && tsutils.isTypeFlagSet(awaitedType, ts.TypeFlags.Unknown)) return;
-				}
-				if (anyType === AnyType.PromiseAny && !tsutils.includesModifier(functionNode.modifiers, SyntaxKind.AsyncKeyword)) return;
-				let message = "unsafeReturn";
-				if (!tsutils.isStrictCompilerOptionEnabled(program.getCompilerOptions(), "noImplicitThis")) {
-					const thisExpression = getThisExpression(returnNode);
-					if (thisExpression && tsutils.isTypeFlagSet(getConstrainedTypeAtLocation(thisExpression, typeChecker), ts.TypeFlags.Any)) message = "unsafeReturnThis";
-				}
-				context.report({
-					data: { type: anyType },
-					message,
-					range: getTSNodeRange(reportingNode, sourceFile)
-				});
-				return;
-			}
-			const signature = functionType.getCallSignatures().at(0);
-			if (signature) {
-				const result = isUnsafeAssignment(returnNodeType, signature.getReturnType(), returnNode);
-				if (!result) return;
-				const { receiver, sender } = result;
-				context.report({
-					data: {
-						receiver: typeChecker.typeToString(receiver),
-						sender: typeChecker.typeToString(sender)
-					},
-					message: "unsafeReturnAssignment",
-					range: getTSNodeRange(reportingNode, sourceFile)
-				});
-				return;
-			}
-		}
-		return { visitors: {
-			ArrowFunction: (node, fileService) => {
-				if (node.body.kind !== SyntaxKind.Block) checkReturn(node.body, node.body, fileService);
-			},
-			ReturnStatement: (node, fileService) => {
-				if (node.expression != null) checkReturn(node.expression, node, fileService);
-			}
-		} };
-	}
-});
-//#endregion
-export { anyReturns_default as default };
-
-//# sourceMappingURL=anyReturns.js.map

package/lib/rules/arguments.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports using the arguments object instead of rest parameters.";
-    readonly id: "arguments";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferRestParameters", undefined>;
-export default _default;
-//# sourceMappingURL=arguments.d.ts.map

package/lib/rules/arguments.js

@@ -1,38 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/arguments.ts
-function isNonArrowFunctionBoundary(node) {
-	if (ts$1.isArrowFunction(node)) return "quit";
-	return ts$1.isFunctionDeclaration(node) || ts$1.isFunctionExpression(node) || ts$1.isMethodDeclaration(node) || ts$1.isGetAccessorDeclaration(node) || ts$1.isSetAccessorDeclaration(node) || ts$1.isConstructorDeclaration(node);
-}
-var arguments_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports using the arguments object instead of rest parameters.",
-		id: "arguments",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { preferRestParameters: {
-		primary: "Use rest parameters instead of the `arguments` object.",
-		secondary: ["The `arguments` object is an array-like object that doesn't have Array methods like `map`, `filter`, or `forEach`.", "Rest parameters provide a real Array, making it easier to work with variadic functions."],
-		suggestions: ["Replace usage of `arguments` with a rest parameter like `...args`."]
-	} },
-	setup(context) {
-		return { visitors: { Identifier: (node, { sourceFile, typeChecker }) => {
-			if (node.text !== "arguments") return;
-			const { parent } = node;
-			if ((ts$1.isPropertyAccessExpression(parent) || ts$1.isPropertyAssignment(parent) || ts$1.isShorthandPropertyAssignment(parent) || ts$1.isParameter(parent) || ts$1.isVariableDeclaration(parent) || ts$1.isPropertyDeclaration(parent) || ts$1.isBindingElement(parent) || ts$1.isPropertySignature(parent)) && parent.name === node) return;
-			if (!ts$1.findAncestor(node, isNonArrowFunctionBoundary)) return;
-			const symbol = typeChecker.getSymbolAtLocation(node);
-			if (!symbol || symbol.getDeclarations()?.some((declaration) => ts$1.isParameter(declaration) || ts$1.isVariableDeclaration(declaration) || ts$1.isPropertyDeclaration(declaration) || ts$1.isBindingElement(declaration))) return;
-			context.report({
-				message: "preferRestParameters",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { arguments_default as default };
-
-//# sourceMappingURL=arguments.js.map

package/lib/rules/arrayCallbackReturns.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports missing return statements in callbacks of array methods.";
-    readonly id: "arrayCallbackReturns";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "missingReturn", undefined>;
-export default _default;
-//# sourceMappingURL=arrayCallbackReturns.d.ts.map