@flint.fyi/ts 0.15.0 → 0.18.0

package/lib/rules/accessorPairGroups.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports getter and setter accessors for the same property that are not adjacent.";
+    readonly id: "accessorPairGroups";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "notGrouped", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=accessorPairGroups.d.ts.map

package/lib/rules/accessorPairGroups.js

@@ -0,0 +1,48 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { collectAccessorPairs } from "./utils/collectAccessorPairs.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+//#region src/rules/accessorPairGroups.ts
+var accessorPairGroups_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports getter and setter accessors for the same property that are not adjacent.",
+		id: "accessorPairGroups",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { notGrouped: {
+		primary: "Getter and setter for `{{ name }}` should be defined adjacent to each other.",
+		secondary: ["Grouping getters and setters together improves code readability.", "It makes it easier to understand how a property is accessed and modified."],
+		suggestions: ["Move the getter and setter to be adjacent to each other."]
+	} },
+	setup(context) {
+		function checkPairs(pairs, { sourceFile }) {
+			for (const [name, pair] of pairs) {
+				if (!pair.getter || !pair.setter) continue;
+				const getterIndex = pair.getter.index;
+				const setterIndex = pair.setter.index;
+				if (Math.abs(getterIndex - setterIndex) !== 1) {
+					const secondAccessor = getterIndex < setterIndex ? pair.setter.node : pair.getter.node;
+					context.report({
+						data: { name },
+						message: "notGrouped",
+						range: getTSNodeRange(secondAccessor.name, sourceFile)
+					});
+				}
+			}
+		}
+		function checkClassLike(node, services) {
+			checkPairs(collectAccessorPairs(node.members, services.sourceFile), services);
+		}
+		function checkObjectLiteral(node, services) {
+			checkPairs(collectAccessorPairs(node.properties, services.sourceFile), services);
+		}
+		return { visitors: {
+			ClassDeclaration: checkClassLike,
+			ClassExpression: checkClassLike,
+			ObjectLiteralExpression: checkObjectLiteral
+		} };
+	}
+});
+//#endregion
+export { accessorPairGroups_default as default };
+
+//# sourceMappingURL=accessorPairGroups.js.map

package/lib/rules/accessorPairTypes.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports mismatched types between getter and setter accessor pairs.";
+    readonly id: "accessorPairTypes";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "mismatchedTypes", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=accessorPairTypes.d.ts.map

package/lib/rules/accessorPairTypes.js

@@ -0,0 +1,72 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+//#region src/rules/accessorPairTypes.ts
+var accessorPairTypes_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports mismatched types between getter and setter accessor pairs.",
+		id: "accessorPairTypes",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { mismatchedTypes: {
+		primary: "A getter's return type should be assignable to its corresponding setter's parameter type.",
+		secondary: ["Getter and setter accessor pairs should have compatible types.", "Having mismatched types means assigning a property to itself would not work."],
+		suggestions: ["Ensure the getter return type is assignable to the setter parameter type."]
+	} },
+	setup(context) {
+		function getPropertyName(accessor, sourceFile) {
+			if (ts.isIdentifier(accessor.name) || ts.isStringLiteral(accessor.name) || ts.isNumericLiteral(accessor.name)) return accessor.name.text;
+			return accessor.name.getText(sourceFile);
+		}
+		function collectAccessorPairs(members, sourceFile) {
+			const pairs = /* @__PURE__ */ new Map();
+			for (const member of members) {
+				if (member.kind !== ts.SyntaxKind.GetAccessor && member.kind !== ts.SyntaxKind.SetAccessor) continue;
+				const name = getPropertyName(member, sourceFile);
+				let pair = pairs.get(name);
+				if (!pair) {
+					pair = {};
+					pairs.set(name, pair);
+				}
+				if (member.kind === ts.SyntaxKind.GetAccessor) pair.getter = member;
+				else pair.setter = member;
+			}
+			return pairs;
+		}
+		function checkPairs(pairs, { sourceFile, typeChecker }) {
+			for (const [, pair] of pairs) {
+				if (!pair.getter || pair.setter?.parameters.length !== 1) continue;
+				const setterParameter = pair.setter.parameters[0];
+				const getterReturnType = typeChecker.getTypeAtLocation(pair.getter);
+				const setterParameterType = typeChecker.getTypeAtLocation(setterParameter);
+				if (!typeChecker.isTypeAssignableTo(getterReturnType, setterParameterType)) context.report({
+					message: "mismatchedTypes",
+					range: {
+						begin: pair.getter.name.getStart(sourceFile),
+						end: pair.getter.name.getEnd()
+					}
+				});
+			}
+		}
+		function checkClassLike(node, services) {
+			checkPairs(collectAccessorPairs(node.members, services.sourceFile), services);
+		}
+		function checkObjectLiteral(node, services) {
+			checkPairs(collectAccessorPairs(node.properties, services.sourceFile), services);
+		}
+		function checkInterfaceOrTypeLiteral(node, services) {
+			checkPairs(collectAccessorPairs(node.members, services.sourceFile), services);
+		}
+		return { visitors: {
+			ClassDeclaration: checkClassLike,
+			ClassExpression: checkClassLike,
+			InterfaceDeclaration: checkInterfaceOrTypeLiteral,
+			ObjectLiteralExpression: checkObjectLiteral,
+			TypeLiteral: checkInterfaceOrTypeLiteral
+		} };
+	}
+});
+//#endregion
+export { accessorPairTypes_default as default };
+
+//# sourceMappingURL=accessorPairTypes.js.map

package/lib/rules/accessorThisRecursion.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports recursive access to this within getters and setters.";
+    readonly id: "accessorThisRecursion";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noGetterRecursion" | "noSetterRecursion", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=accessorThisRecursion.d.ts.map

package/lib/rules/accessorThisRecursion.js

@@ -0,0 +1,65 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+import * as tsutils from "ts-api-utils";
+//#region src/rules/accessorThisRecursion.ts
+function getPropertyName(accessor, sourceFile) {
+	return ts$1.isIdentifier(accessor.name) || ts$1.isStringLiteral(accessor.name) || ts$1.isNumericLiteral(accessor.name) ? accessor.name.text : accessor.name.getText(sourceFile);
+}
+var accessorThisRecursion_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports recursive access to this within getters and setters.",
+		id: "accessorThisRecursion",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: {
+		noGetterRecursion: {
+			primary: "This getter recursively accesses its own property via `this`, causing infinite recursion.",
+			secondary: ["Accessing `this.propertyName` inside a getter for `propertyName` triggers the getter again.", "This results in a stack overflow error at runtime."],
+			suggestions: ["Store the value in a private field and return that instead.", "Use a different backing property name."]
+		},
+		noSetterRecursion: {
+			primary: "This setter recursively assigns to its own property via `this`, causing infinite recursion.",
+			secondary: ["Assigning to `this.propertyName` inside a setter for `propertyName` triggers the setter again.", "This results in a stack overflow error at runtime."],
+			suggestions: ["Store the value in a private field instead.", "Use a different backing property name."]
+		}
+	},
+	setup(context) {
+		function checkAccessor(accessor, { sourceFile }) {
+			if (!accessor.body) return;
+			const propertyName = getPropertyName(accessor, sourceFile);
+			const isGetter = ts$1.isGetAccessorDeclaration(accessor);
+			function checkNode(node) {
+				if (tsutils.isFunctionScopeBoundary(node)) return;
+				if (ts$1.isPropertyAccessExpression(node)) checkPropertyAccessExpression(node);
+				ts$1.forEachChild(node, checkNode);
+			}
+			function checkPropertyAccessExpression(node) {
+				if (node.name.text !== propertyName || node.expression.kind !== ts$1.SyntaxKind.ThisKeyword) return;
+				if (isGetter) context.report({
+					message: "noGetterRecursion",
+					range: {
+						begin: node.getStart(sourceFile),
+						end: node.getEnd()
+					}
+				});
+				else if (ts$1.isBinaryExpression(node.parent) && node.parent.left === node && node.parent.operatorToken.kind === ts$1.SyntaxKind.EqualsToken) context.report({
+					message: "noSetterRecursion",
+					range: {
+						begin: node.getStart(sourceFile),
+						end: node.getEnd()
+					}
+				});
+			}
+			ts$1.forEachChild(accessor.body, checkNode);
+		}
+		return { visitors: {
+			GetAccessor: checkAccessor,
+			SetAccessor: checkAccessor
+		} };
+	}
+});
+//#endregion
+export { accessorThisRecursion_default as default };
+
+//# sourceMappingURL=accessorThisRecursion.js.map

package/lib/rules/anyArguments.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports calling a function with a value typed as `any` as an argument.";
+    readonly id: "anyArguments";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unsafeArgument" | "unsafeSpread" | "unsafeTupleSpread", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=anyArguments.d.ts.map

package/lib/rules/anyArguments.js

@@ -0,0 +1,234 @@
+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/anyArguments.ts
+var anyArguments_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports calling a function with a value typed as `any` as an argument.",
+		id: "anyArguments",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: {
+		unsafeArgument: {
+			primary: "Unsafe argument of type `{{ type }}` assigned to parameter of type `{{ paramType }}`.",
+			secondary: ["Passing a value of type `any` or a similar unsafe type as an argument defeats TypeScript's type safety guarantees.", "This can allow unexpected types to propagate through your codebase, potentially causing runtime errors."],
+			suggestions: ["Ensure the argument has a well-defined, specific type before passing it to the function."]
+		},
+		unsafeSpread: {
+			primary: "Unsafe spread of type `{{ type }}` in function call.",
+			secondary: ["Spreading an `any` or `any[]` typed value as function arguments bypasses type checking.", "This can allow unexpected types to propagate through your codebase, potentially causing runtime errors."],
+			suggestions: ["Ensure the spread value has a well-defined tuple or array type before spreading it."]
+		},
+		unsafeTupleSpread: {
+			primary: "Unsafe spread of tuple type. The argument is of type `{{ type }}` assigned to parameter of type `{{ paramType }}`.",
+			secondary: ["One or more elements in this tuple spread contains an `any` type that will be assigned to a typed parameter.", "This can allow unexpected types to propagate through your codebase, potentially causing runtime errors."],
+			suggestions: ["Ensure all tuple elements have well-defined types that match the expected parameter types."]
+		}
+	},
+	setup(context) {
+		function checkCallArguments(node, { program, sourceFile, typeChecker }) {
+			if (!node.arguments) return;
+			const signature = typeChecker.getResolvedSignature(node);
+			if (!signature) return;
+			const parameters = signature.getParameters();
+			let parameterIndex = 0;
+			for (const argument of node.arguments) {
+				const argumentType = typeChecker.getTypeAtLocation(argument);
+				if (ts$1.isSpreadElement(argument)) {
+					const spreadType = typeChecker.getTypeAtLocation(argument.expression);
+					const anyType = discriminateAnyType(spreadType, typeChecker, argument.expression);
+					if (anyType !== AnyType.Safe) {
+						const restParameter = parameters.at(-1);
+						if (restParameter) {
+							const restType = typeChecker.getTypeOfSymbol(restParameter);
+							if (tsutils.isTypeFlagSet(restType, ts$1.TypeFlags.Any | ts$1.TypeFlags.Unknown)) continue;
+							if (typeChecker.isArrayType(restType)) {
+								const elementType = typeChecker.getTypeArguments(restType)[0];
+								if (elementType && tsutils.isTypeFlagSet(elementType, ts$1.TypeFlags.Any | ts$1.TypeFlags.Unknown)) continue;
+							}
+						}
+						context.report({
+							data: { type: anyType },
+							message: "unsafeSpread",
+							range: {
+								begin: argument.getStart(sourceFile),
+								end: argument.getEnd()
+							}
+						});
+						continue;
+					}
+					if (typeChecker.isTupleType(spreadType)) {
+						const tupleResult = checkTupleSpread(spreadType, parameters, parameterIndex, typeChecker, program, argument.expression);
+						if (tupleResult) context.report({
+							data: {
+								paramType: formatReportedType(tupleResult.paramType, typeChecker),
+								type: tupleResult.type
+							},
+							message: "unsafeTupleSpread",
+							range: {
+								begin: argument.getStart(sourceFile),
+								end: argument.getEnd()
+							}
+						});
+						const tupleTypeArgs = typeChecker.getTypeArguments(spreadType);
+						parameterIndex += tupleTypeArgs.length;
+					}
+					continue;
+				}
+				const anyType = discriminateAnyType(argumentType, typeChecker, argument);
+				if (anyType === AnyType.Safe) {
+					const paramInfo = getParameterAtIndex(parameters, parameterIndex, typeChecker);
+					if (paramInfo) {
+						const unsafeResult = isUnsafeAssignment(argumentType, paramInfo.type, argument);
+						if (unsafeResult) context.report({
+							data: {
+								paramType: formatReportedType(unsafeResult.receiver, typeChecker),
+								type: formatReportedType(unsafeResult.sender, typeChecker)
+							},
+							message: "unsafeArgument",
+							range: {
+								begin: argument.getStart(sourceFile),
+								end: argument.getEnd()
+							}
+						});
+					}
+					parameterIndex++;
+					continue;
+				}
+				const parameterInfo = getParameterAtIndex(parameters, parameterIndex, typeChecker);
+				if (!parameters.length || !parameterInfo) {
+					parameterIndex++;
+					continue;
+				}
+				if (tsutils.isTypeFlagSet(parameterInfo.type, ts$1.TypeFlags.Any | ts$1.TypeFlags.Unknown)) {
+					parameterIndex++;
+					continue;
+				}
+				context.report({
+					data: {
+						paramType: formatReportedType(parameterInfo.type, typeChecker),
+						type: anyType
+					},
+					message: "unsafeArgument",
+					range: {
+						begin: argument.getStart(sourceFile),
+						end: argument.getEnd()
+					}
+				});
+				parameterIndex++;
+			}
+		}
+		return { visitors: {
+			CallExpression: checkCallArguments,
+			NewExpression: checkCallArguments,
+			TaggedTemplateExpression: (node, { sourceFile, typeChecker }) => {
+				const signature = typeChecker.getResolvedSignature(node);
+				if (!signature) return;
+				const parameters = signature.getParameters();
+				if (parameters.length <= 1) return;
+				const template = node.template;
+				if (!ts$1.isTemplateExpression(template)) return;
+				const expressions = template.templateSpans.map((span) => span.expression);
+				for (const [i, expression] of expressions.entries()) {
+					const expressionType = typeChecker.getTypeAtLocation(expression);
+					const anyType = discriminateAnyType(expressionType, typeChecker, expression);
+					if (anyType === AnyType.Safe) {
+						const parameter = parameters[i + 1];
+						if (parameter) {
+							const unsafeResult = isUnsafeAssignment(expressionType, typeChecker.getTypeOfSymbol(parameter), expression);
+							if (unsafeResult) context.report({
+								data: {
+									paramType: formatReportedType(unsafeResult.receiver, typeChecker),
+									type: formatReportedType(unsafeResult.sender, typeChecker)
+								},
+								message: "unsafeArgument",
+								range: {
+									begin: expression.getStart(sourceFile) - 2,
+									end: expression.getEnd() + 1
+								}
+							});
+						}
+						continue;
+					}
+					const parameter = parameters[i + 1];
+					if (!parameter) continue;
+					const parameterType = typeChecker.getTypeOfSymbol(parameter);
+					if (tsutils.isTypeFlagSet(parameterType, ts$1.TypeFlags.Any | ts$1.TypeFlags.Unknown)) continue;
+					context.report({
+						data: {
+							paramType: formatReportedType(parameterType, typeChecker),
+							type: anyType
+						},
+						message: "unsafeArgument",
+						range: {
+							begin: expression.getStart(sourceFile) - 2,
+							end: expression.getEnd() + 1
+						}
+					});
+				}
+			}
+		} };
+		function getParameterAtIndex(parameters, index, typeChecker) {
+			if (!parameters.length) return;
+			const lastParam = parameters.at(-1);
+			if (!lastParam) return;
+			const lastParamDeclaration = lastParam.declarations?.[0];
+			if (lastParamDeclaration && ts$1.isParameter(lastParamDeclaration) && lastParamDeclaration.dotDotDotToken) {
+				if (index < parameters.length - 1) {
+					const param = parameters[index];
+					if (!param) return;
+					return {
+						symbol: param,
+						type: typeChecker.getTypeOfSymbol(param)
+					};
+				}
+				const restType = typeChecker.getTypeOfSymbol(lastParam);
+				if (typeChecker.isTupleType(restType)) {
+					const tupleArgs = typeChecker.getTypeArguments(restType);
+					const tupleIndex = index - (parameters.length - 1);
+					const tupleType = tupleArgs[tupleIndex];
+					if (tupleType) return {
+						symbol: lastParam,
+						tupleIndex,
+						type: tupleType
+					};
+					return;
+				}
+				return {
+					symbol: lastParam,
+					type: restType
+				};
+			}
+			if (index >= parameters.length) return;
+			const param = parameters[index];
+			if (!param) return;
+			return {
+				symbol: param,
+				type: typeChecker.getTypeOfSymbol(param)
+			};
+		}
+		function checkTupleSpread(tupleType, parameters, startIndex, typeChecker, program, node) {
+			const tupleTypeArgs = typeChecker.getTypeArguments(tupleType);
+			for (const [i, elementType] of tupleTypeArgs.entries()) {
+				const anyType = discriminateAnyType(elementType, typeChecker, node);
+				if (anyType === AnyType.Safe) continue;
+				const paramInfo = getParameterAtIndex(parameters, startIndex + i, typeChecker);
+				if (!paramInfo) continue;
+				const parameterType = paramInfo.type;
+				if (tsutils.isTypeFlagSet(parameterType, ts$1.TypeFlags.Any | ts$1.TypeFlags.Unknown)) continue;
+				return {
+					paramType: parameterType,
+					type: anyType
+				};
+			}
+		}
+	}
+});
+//#endregion
+export { anyArguments_default as default };
+
+//# sourceMappingURL=anyArguments.js.map

package/lib/rules/anyAssignments.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports assigning a value with type `any` to variables and properties.";
+    readonly id: "anyAssignments";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unsafeArrayDestructure" | "unsafeArrayPatternFromTuple" | "unsafeArraySpread" | "unsafeAssignment" | "unsafeAssignmentToVariable" | "unsafeObjectPattern", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=anyAssignments.d.ts.map