@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/builtinCoercions.js

@@ -0,0 +1,117 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/builtinCoercions.ts
+const nativeCoercionFunctions = new Set([
+	"BigInt",
+	"Boolean",
+	"Number",
+	"String",
+	"Symbol"
+]);
+const arrayMethodsWithBooleanCallback = new Set([
+	"every",
+	"filter",
+	"find",
+	"findIndex",
+	"findLast",
+	"findLastIndex",
+	"some"
+]);
+var builtinCoercions_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports functions that wrap native coercion functions like `String`, `Number`, `BigInt`, `Boolean`, or `Symbol`.",
+		id: "builtinCoercions",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { useBuiltin: {
+		primary: "Prefer using `{{ coercionFunction }}` directly instead of wrapping it in a function.",
+		secondary: ["Wrapping a native coercion function in another function adds unnecessary indirection.", "Using the built-in function directly is more concise and expresses intent more clearly."],
+		suggestions: ["Replace this function with `{{ coercionFunction }}`."]
+	} },
+	setup(context) {
+		function checkFunction(node, { sourceFile }) {
+			const problem = getFunctionProblem(node, sourceFile);
+			if (problem) context.report(problem);
+		}
+		return { visitors: {
+			ArrowFunction: checkFunction,
+			FunctionExpression: checkFunction
+		} };
+	}
+});
+function blockReturnsIdentifier(block, parameterName) {
+	if (block.statements.length !== 1) return false;
+	const statement = block.statements[0];
+	if (!statement || !ts$1.isReturnStatement(statement) || !statement.expression) return false;
+	return expressionMatchesName(statement.expression, parameterName);
+}
+function expressionMatchesName(expression, name) {
+	const unwrapped = ts$1.isParenthesizedExpression(expression) ? expression.expression : expression;
+	return ts$1.isIdentifier(unwrapped) && unwrapped.text === name;
+}
+function getCoercionCallName(expression, parameterName) {
+	if (!ts$1.isCallExpression(expression) || !ts$1.isIdentifier(expression.expression)) return;
+	const calleeName = expression.expression.text;
+	if (!nativeCoercionFunctions.has(calleeName) || expression.arguments.length !== 1) return;
+	const argument = expression.arguments[0];
+	if (!argument || !ts$1.isIdentifier(argument) || argument.text !== parameterName) return;
+	return calleeName;
+}
+function getCoercionWrapperProblem(node, parameterName, sourceFile) {
+	if (node.parameters.length !== 1) return;
+	const coercionFunction = getWrappedCoercionFunction(node, parameterName);
+	if (!coercionFunction) return;
+	const range = getTSNodeRange(node, sourceFile);
+	return {
+		data: { coercionFunction },
+		fix: {
+			range,
+			text: coercionFunction
+		},
+		message: "useBuiltin",
+		range
+	};
+}
+function getFunctionProblem(node, sourceFile) {
+	const soleParameterText = getSoleParameterText(node);
+	if (!soleParameterText) return;
+	return getIdentityCallbackProblem(node, soleParameterText, sourceFile) ?? getCoercionWrapperProblem(node, soleParameterText, sourceFile);
+}
+function getIdentityCallbackProblem(node, soleParameterText, sourceFile) {
+	if (!isIdentityFunction(node, soleParameterText) || !isArrayMethodCallback(node)) return;
+	const range = getTSNodeRange(node, sourceFile);
+	return {
+		data: { coercionFunction: "Boolean" },
+		fix: {
+			range,
+			text: "Boolean"
+		},
+		message: "useBuiltin",
+		range
+	};
+}
+function getSoleParameterText(node) {
+	if (node.parameters.length !== 1) return;
+	const parameter = node.parameters[0];
+	if (!parameter || !ts$1.isIdentifier(parameter.name)) return;
+	return parameter.name.text;
+}
+function getWrappedCoercionFunction(node, parameterName) {
+	if (node.kind === ts$1.SyntaxKind.ArrowFunction && !ts$1.isBlock(node.body)) return getCoercionCallName(node.body, parameterName);
+	if (!ts$1.isBlock(node.body) || node.body.statements.length !== 1) return;
+	const statement = node.body.statements[0];
+	if (!statement || !ts$1.isReturnStatement(statement) || !statement.expression) return;
+	return getCoercionCallName(statement.expression, parameterName);
+}
+function isArrayMethodCallback(node) {
+	return ts$1.isCallExpression(node.parent) && node.parent.arguments[0] === node && ts$1.isPropertyAccessExpression(node.parent.expression) && arrayMethodsWithBooleanCallback.has(node.parent.expression.name.text);
+}
+function isIdentityFunction(node, soleParameterText) {
+	if (node.kind === ts$1.SyntaxKind.ArrowFunction && !ts$1.isBlock(node.body)) return expressionMatchesName(node.body, soleParameterText);
+	return ts$1.isBlock(node.body) && blockReturnsIdentifier(node.body, soleParameterText);
+}
+//#endregion
+export { builtinCoercions_default as default };
+
+//# sourceMappingURL=builtinCoercions.js.map

package/lib/rules/builtinConstructorNews.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Enforces using new for constructors that require it, and disallows new for primitive coercion functions.";
+    readonly id: "builtinConstructorNews";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "disallowedNew" | "missingNew", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=builtinConstructorNews.d.ts.map

package/lib/rules/builtinConstructorNews.js

@@ -0,0 +1,89 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/builtinConstructorNews.ts
+const requiresNew = new Set([
+	"Array",
+	"ArrayBuffer",
+	"BigInt64Array",
+	"BigUint64Array",
+	"DataView",
+	"Date",
+	"Error",
+	"FinalizationRegistry",
+	"Float16Array",
+	"Float32Array",
+	"Float64Array",
+	"Function",
+	"Int8Array",
+	"Int16Array",
+	"Int32Array",
+	"Map",
+	"Object",
+	"Promise",
+	"Proxy",
+	"RegExp",
+	"Set",
+	"SharedArrayBuffer",
+	"Uint8Array",
+	"Uint8ClampedArray",
+	"Uint16Array",
+	"Uint32Array",
+	"WeakMap",
+	"WeakRef",
+	"WeakSet"
+]);
+const disallowsNew = new Set([
+	"BigInt",
+	"Boolean",
+	"Number",
+	"String",
+	"Symbol"
+]);
+var builtinConstructorNews_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Enforces using new for constructors that require it, and disallows new for primitive coercion functions.",
+		id: "builtinConstructorNews",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: {
+		disallowedNew: {
+			primary: "Use {{ name }}() without new to coerce values to primitives.",
+			secondary: ["Using `new` with `{{ name }}` creates an object wrapper around the primitive value.", "Object wrappers can cause unexpected behavior in comparisons and type checks."],
+			suggestions: ["Remove `new` to use {{ name }} as a coercion function."]
+		},
+		missingNew: {
+			primary: "Use new {{ name }}() to create instances.",
+			secondary: ["Built-in constructors like `{{ name }}` should be called with `new` for consistency.", "While some constructors work without `new`, using `new` makes the intent clearer."],
+			suggestions: ["Add `new` before {{ name }}()."]
+		}
+	},
+	setup(context) {
+		function checkNode(node, namesToReport, message, { sourceFile, typeChecker }) {
+			if (!ts$1.isIdentifier(node.expression)) return;
+			const name = node.expression.text;
+			if (!namesToReport.has(name)) return;
+			if (!isGlobalDeclarationOfName(node.expression, name, typeChecker)) return;
+			context.report({
+				data: { name },
+				message,
+				range: {
+					begin: node.getStart(sourceFile),
+					end: node.expression.getEnd()
+				}
+			});
+		}
+		return { visitors: {
+			CallExpression: (node, services) => {
+				checkNode(node, requiresNew, "missingNew", services);
+			},
+			NewExpression: (node, services) => {
+				checkNode(node, disallowsNew, "disallowedNew", services);
+			}
+		} };
+	}
+});
+//#endregion
+export { builtinConstructorNews_default as default };
+
+//# sourceMappingURL=builtinConstructorNews.js.map

package/lib/rules/caseDeclarations.d.ts

@@ -1,6 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports lexical declarations in case clauses without wrapping them in blocks.";
     readonly id: "caseDeclarations";
-    readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "unexpectedLexicalDeclaration", undefined>;
+    readonly presets: ["javascript"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unexpectedLexicalDeclaration", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
+//# sourceMappingURL=caseDeclarations.d.ts.map

package/lib/rules/caseDeclarations.js

@@ -1,53 +1,40 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts, { SyntaxKind } from "typescript";
 import * as tsutils from "ts-api-utils";
-import * as ts from "typescript";
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports lexical declarations in case clauses without wrapping them in blocks.",
-        id: "caseDeclarations",
-        preset: "untyped",
-    },
-    messages: {
-        unexpectedLexicalDeclaration: {
-            primary: "Variables declared in case clauses without braces leak into the surrounding scope.",
-            secondary: [
-                "Lexical declarations (let, const, function, class) are scoped to the entire switch statement, not just the case clause where they are declared.",
-                "This can lead to unexpected behavior when the same variable name is used in multiple case clauses, as they will conflict in the same scope.",
-            ],
-            suggestions: [
-                "Wrap the case clause contents in curly braces {} to create a block scope.",
-            ],
-        },
-    },
-    setup(context) {
-        function getLexicalDeclaration(statements) {
-            for (const statement of statements) {
-                if (ts.isVariableStatement(statement) &&
-                    tsutils.isNodeFlagSet(statement.declarationList, ts.NodeFlags.Let | ts.NodeFlags.Const)) {
-                    return statement.declarationList.getChildAt(0, context.sourceFile);
-                }
-                if (ts.isClassDeclaration(statement) ||
-                    ts.isFunctionDeclaration(statement)) {
-                    return statement.getChildAt(0, context.sourceFile);
-                }
-            }
-            return undefined;
-        }
-        function checkClause(node) {
-            const declarationNode = getLexicalDeclaration(node.statements);
-            if (declarationNode) {
-                context.report({
-                    message: "unexpectedLexicalDeclaration",
-                    range: getTSNodeRange(declarationNode, context.sourceFile),
-                });
-            }
-        }
-        return {
-            visitors: {
-                CaseClause: checkClause,
-                DefaultClause: checkClause,
-            },
-        };
-    },
+//#region src/rules/caseDeclarations.ts
+var caseDeclarations_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports lexical declarations in case clauses without wrapping them in blocks.",
+		id: "caseDeclarations",
+		presets: ["javascript"]
+	},
+	messages: { unexpectedLexicalDeclaration: {
+		primary: "Variables declared in case clauses without braces leak into the surrounding scope.",
+		secondary: ["Lexical declarations (let, const, function, class) are scoped to the entire switch statement, not just the case clause where they are declared.", "This can lead to unexpected behavior when the same variable name is used in multiple case clauses, as they will conflict in the same scope."],
+		suggestions: ["Wrap the case clause contents in curly braces {} to create a block scope."]
+	} },
+	setup(context) {
+		function getLexicalDeclaration(statements, sourceFile) {
+			for (const statement of statements) {
+				if (statement.kind === SyntaxKind.VariableStatement && tsutils.isNodeFlagSet(statement.declarationList, ts.NodeFlags.Let | ts.NodeFlags.Const)) return statement.declarationList.getChildAt(0, sourceFile);
+				if (statement.kind === SyntaxKind.ClassDeclaration || statement.kind === SyntaxKind.FunctionDeclaration) return statement.getChildAt(0, sourceFile);
+			}
+		}
+		function checkClause(node, { sourceFile }) {
+			const declarationNode = getLexicalDeclaration(node.statements, sourceFile);
+			if (declarationNode) context.report({
+				message: "unexpectedLexicalDeclaration",
+				range: getTSNodeRange(declarationNode, sourceFile)
+			});
+		}
+		return { visitors: {
+			CaseClause: checkClause,
+			DefaultClause: checkClause
+		} };
+	}
 });
+//#endregion
+export { caseDeclarations_default as default };
+
+//# sourceMappingURL=caseDeclarations.js.map

package/lib/rules/caseDuplicates.d.ts

@@ -1,6 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports switch statements with duplicate case clause test expressions.";
     readonly id: "caseDuplicates";
-    readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "duplicateCase", undefined>;
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "duplicateCase", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
+//# sourceMappingURL=caseDuplicates.d.ts.map

package/lib/rules/caseDuplicates.js

@@ -1,49 +1,36 @@
-import * as ts from "typescript";
-import { typescriptLanguage } from "../language.js";
-import { hasSameTokens } from "../utils/hasSameTokens.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports switch statements with duplicate case clause test expressions.",
-        id: "caseDuplicates",
-        preset: "logical",
-    },
-    messages: {
-        duplicateCase: {
-            primary: "This case duplicates a previous case, so it will never be reached.",
-            secondary: [
-                "Having duplicate case clauses in a switch statement is a logic error.",
-                "The second case clause will never be reached because the first matching case will always execute first.",
-            ],
-            suggestions: [
-                "Remove the duplicate case clause or modify its test expression to be unique.",
-            ],
-        },
-    },
-    setup(context) {
-        return {
-            visitors: {
-                SwitchStatement: (node) => {
-                    const seenCases = [];
-                    for (const clause of node.caseBlock.clauses) {
-                        if (!ts.isCaseClause(clause)) {
-                            continue;
-                        }
-                        const isDuplicate = seenCases.some((seenCase) => hasSameTokens(seenCase, clause.expression, context.sourceFile));
-                        if (isDuplicate) {
-                            context.report({
-                                message: "duplicateCase",
-                                range: {
-                                    begin: clause.getStart(context.sourceFile),
-                                    end: clause.expression.getEnd(),
-                                },
-                            });
-                        }
-                        else {
-                            seenCases.push(clause.expression);
-                        }
-                    }
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { hasSameTokens, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/caseDuplicates.ts
+var caseDuplicates_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports switch statements with duplicate case clause test expressions.",
+		id: "caseDuplicates",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { duplicateCase: {
+		primary: "This case duplicates a previous case, so it will never be reached.",
+		secondary: ["Having duplicate case clauses in a switch statement is a logic error.", "The second case clause will never be reached because the first matching case will always execute first."],
+		suggestions: ["Remove the duplicate case clause or modify its test expression to be unique."]
+	} },
+	setup(context) {
+		return { visitors: { SwitchStatement: (node, { sourceFile }) => {
+			const seenCases = [];
+			for (const clause of node.caseBlock.clauses) {
+				if (clause.kind !== SyntaxKind.CaseClause) continue;
+				if (seenCases.some((seenCase) => hasSameTokens(seenCase, clause.expression, sourceFile))) context.report({
+					message: "duplicateCase",
+					range: {
+						begin: clause.getStart(sourceFile),
+						end: clause.expression.getEnd()
+					}
+				});
+				else seenCases.push(clause.expression);
+			}
+		} } };
+	}
 });
+//#endregion
+export { caseDuplicates_default as default };
+
+//# sourceMappingURL=caseDuplicates.js.map

package/lib/rules/caseFallthroughs.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports switch case clauses that fall through unexpectedly.";
+    readonly id: "caseFallthroughs";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unexpectedFallthrough", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=caseFallthroughs.d.ts.map

package/lib/rules/caseFallthroughs.js

@@ -0,0 +1,76 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/caseFallthroughs.ts
+const fallthroughCommentPattern = /falls?\s*through/i;
+function endsWithTerminatingStatement(statements) {
+	return !!statements.length && isTerminatingStatement(statements.at(-1));
+}
+function hasFallthroughComment(clause, nextClause, sourceFile) {
+	const sourceText = sourceFile.getFullText();
+	const commentRanges = ts$1.getLeadingCommentRanges(sourceText, nextClause.getFullStart());
+	if (commentRanges) for (const range of commentRanges) {
+		const comment = sourceText.slice(range.pos, range.end);
+		if (fallthroughCommentPattern.test(comment)) return true;
+	}
+	const trailingRanges = ts$1.getTrailingCommentRanges(sourceText, clause.getEnd());
+	if (trailingRanges) for (const range of trailingRanges) {
+		const comment = sourceText.slice(range.pos, range.end);
+		if (fallthroughCommentPattern.test(comment)) return true;
+	}
+	return false;
+}
+function isTerminatingStatement(node) {
+	switch (node.kind) {
+		case ts$1.SyntaxKind.Block: return endsWithTerminatingStatement(node.statements);
+		case ts$1.SyntaxKind.BreakStatement:
+		case ts$1.SyntaxKind.ContinueStatement:
+		case ts$1.SyntaxKind.ReturnStatement:
+		case ts$1.SyntaxKind.ThrowStatement: return true;
+		case ts$1.SyntaxKind.IfStatement: return !!node.elseStatement && isTerminatingStatement(node.thenStatement) && isTerminatingStatement(node.elseStatement);
+		case ts$1.SyntaxKind.SwitchStatement: return node.caseBlock.clauses.some(ts$1.isDefaultClause) && node.caseBlock.clauses.every((clause) => !clause.statements.length || endsWithTerminatingStatement(clause.statements));
+		case ts$1.SyntaxKind.TryStatement:
+			if (node.finallyBlock) return endsWithTerminatingStatement(node.finallyBlock.statements);
+			if (!node.catchClause) return endsWithTerminatingStatement(node.tryBlock.statements);
+			return endsWithTerminatingStatement(node.tryBlock.statements) && endsWithTerminatingStatement(node.catchClause.block.statements);
+		default: return false;
+	}
+}
+var caseFallthroughs_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports switch case clauses that fall through unexpectedly.",
+		id: "caseFallthroughs",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { unexpectedFallthrough: {
+		primary: "This case falls through to the next case without a break, return, or throw statement.",
+		secondary: ["Fallthrough in switch statements is often unintentional and can lead to bugs.", "If fallthrough is intentional, add a comment containing 'falls through' to indicate this."],
+		suggestions: [
+			"Add a `break` statement at the end of this case.",
+			"Add a `return` or `throw` statement if appropriate.",
+			"If fallthrough is intentional, add a `// falls through` comment."
+		]
+	} },
+	setup(context) {
+		return { visitors: { SwitchStatement: (node, { sourceFile }) => {
+			for (let i = 0; i < node.caseBlock.clauses.length - 1; i++) {
+				const clause = node.caseBlock.clauses[i];
+				if (!clause) continue;
+				const nextClause = node.caseBlock.clauses[i + 1];
+				if (!clause.statements.length || endsWithTerminatingStatement(clause.statements) || hasFallthroughComment(clause, nextClause, sourceFile)) continue;
+				const caseKeyword = ts$1.isCaseClause(clause) ? "case" : "default";
+				context.report({
+					message: "unexpectedFallthrough",
+					range: {
+						begin: clause.getStart(sourceFile),
+						end: clause.getStart(sourceFile) + caseKeyword.length
+					}
+				});
+			}
+		} } };
+	}
+});
+//#endregion
+export { caseFallthroughs_default as default };
+
+//# sourceMappingURL=caseFallthroughs.js.map

package/lib/rules/catchCallbackTypes.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports `Promise` catch callback parameters that are not typed as unknown.";
+    readonly id: "catchCallbackTypes";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferUnknown", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=catchCallbackTypes.d.ts.map

package/lib/rules/catchCallbackTypes.js

@@ -0,0 +1,67 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
+import { declarationIncludesGlobal, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+import * as tsutils from "ts-api-utils";
+//#region src/rules/catchCallbackTypes.ts
+var catchCallbackTypes_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports `Promise` catch callback parameters that are not typed as unknown.",
+		id: "catchCallbackTypes",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { preferUnknown: {
+		primary: "The catch callback parameter should be typed as the safer `unknown` instead of `any`.",
+		secondary: [
+			"TypeScript's `useUnknownInCatchVariables` option only affects synchronous catch clauses, not Promise callbacks.",
+			"Promise rejection values can be anything, so using `unknown` forces proper type narrowing before use.",
+			"Using `any` in catch callbacks undermines type safety and can lead to runtime errors."
+		],
+		suggestions: ["Add an explicit `: unknown` type annotation to the callback parameter."]
+	} },
+	setup(context) {
+		function isGlobalPromiseType(type) {
+			const symbol = type.getSymbol();
+			if (symbol?.getName() !== "Promise") return false;
+			const declarations = symbol.getDeclarations();
+			if (!declarations) return false;
+			return declarations.some((declaration) => ts$1.isInterfaceDeclaration(declaration) && declaration.name.text === "Promise" && declarationIncludesGlobal(declaration));
+		}
+		function isCatchOrThenCallback(node, typeChecker) {
+			if (!ts$1.isPropertyAccessExpression(node.expression)) return;
+			const methodName = node.expression.name.text;
+			if (methodName !== "catch" && methodName !== "then") return;
+			if (!isGlobalPromiseType(getConstrainedTypeAtLocation(node.expression.expression, typeChecker))) return;
+			return methodName === "catch" ? "catch" : "then";
+		}
+		function checkCallbackParameter(callback, sourceFile, typeChecker) {
+			if (!ts$1.isFunctionLike(callback) || !callback.parameters.length) return;
+			const firstParameter = callback.parameters[0];
+			if (firstParameter.type) {
+				const paramType = typeChecker.getTypeFromTypeNode(firstParameter.type);
+				if (tsutils.isTypeFlagSet(paramType, ts$1.TypeFlags.Unknown) || !tsutils.isTypeFlagSet(paramType, ts$1.TypeFlags.Any)) return;
+			}
+			context.report({
+				message: "preferUnknown",
+				range: {
+					begin: firstParameter.name.getStart(sourceFile),
+					end: firstParameter.type ? firstParameter.type.getEnd() : firstParameter.name.getEnd()
+				}
+			});
+		}
+		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
+			switch (isCatchOrThenCallback(node, typeChecker)) {
+				case "catch":
+					if (node.arguments.length >= 1) checkCallbackParameter(node.arguments[0], sourceFile, typeChecker);
+					break;
+				case "then":
+					if (node.arguments.length >= 2) checkCallbackParameter(node.arguments[1], sourceFile, typeChecker);
+					break;
+			}
+		} } };
+	}
+});
+//#endregion
+export { catchCallbackTypes_default as default };
+
+//# sourceMappingURL=catchCallbackTypes.js.map

package/lib/rules/caughtVariableNames.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Enforces a consistent naming convention for catch clause error variables.";
+    readonly id: "caughtVariableNames";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferErrorName", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=caughtVariableNames.d.ts.map

package/lib/rules/caughtVariableNames.js

@@ -0,0 +1,40 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/caughtVariableNames.ts
+var caughtVariableNames_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Enforces a consistent naming convention for catch clause error variables.",
+		id: "caughtVariableNames",
+		presets: ["stylisticStrict"]
+	},
+	messages: { preferErrorName: {
+		primary: "Use `error` as the name for the catch clause parameter instead of `{{ name }}`.",
+		secondary: [
+			"Consistent naming of catch clause parameters improves code readability.",
+			"The name `error` clearly indicates the purpose of the variable.",
+			"Descriptive names ending in 'Error' are generally also acceptable."
+		],
+		suggestions: ["Rename `{{ name }}` to `error`.", "Rename `{{ name }}` to a name ending with `Error`."]
+	} },
+	setup(context) {
+		return { visitors: { CatchClause: (node, { sourceFile }) => {
+			const variable = node.variableDeclaration;
+			if (!variable || !ts$1.isIdentifier(variable.name)) return;
+			const name = variable.name.text;
+			if (name === "error" || name.endsWith("Error")) return;
+			context.report({
+				data: { name },
+				message: "preferErrorName",
+				range: {
+					begin: variable.name.getStart(sourceFile),
+					end: variable.name.getEnd()
+				}
+			});
+		} } };
+	}
+});
+//#endregion
+export { caughtVariableNames_default as default };
+
+//# sourceMappingURL=caughtVariableNames.js.map