@flint.fyi/ts 0.15.0 → 0.18.1

package/lib/rules/anyAssignments.js

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

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

package/lib/rules/anyCalls.js

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

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

package/lib/rules/anyMemberAccess.js

@@ -0,0 +1,85 @@
+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,7 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports returning a value with type `any` from a function.";
     readonly id: "anyReturns";
-    readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "unsafeReturn" | "unsafeReturnAssignment" | "unsafeReturnThis", undefined>;
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unsafeReturn" | "unsafeReturnAssignment" | "unsafeReturnThis", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=anyReturns.d.ts.map