@flint.fyi/ts 0.20.0 → 0.22.0

package/lib/rules/accessorPairGroups.js

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

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

package/lib/rules/accessorPairTypes.js

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

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

package/lib/rules/accessorThisRecursion.js

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

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

package/lib/rules/anyArguments.js

@@ -1,234 +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/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

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