@flint.fyi/ts 0.14.2 → 0.14.4

package/src/rules/anyReturns.ts

@@ -0,0 +1,263 @@
+import * as tsutils from "ts-api-utils";
+import * as ts from "typescript";
+
+import { typescriptLanguage } from "../language.js";
+import { AnyType, discriminateAnyType } from "./utils/discriminateAnyType.js";
+import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
+import { getThisExpression } from "./utils/getThisExpression.js";
+import { isUnsafeAssignment } from "./utils/isUnsafeAssignment.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description: "Reports returning a value with type `any` from a function.",
+		id: "anyReturns",
+		preset: "logical",
+	},
+	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) {
+		const isNoImplicitThis = tsutils.isStrictCompilerOptionEnabled(
+			context.program.getCompilerOptions(),
+			"noImplicitThis",
+		);
+
+		function checkReturn(returnNode: ts.Node, reportingNode: ts.Node): void {
+			const type = context.typeChecker.getTypeAtLocation(returnNode);
+
+			const anyType = discriminateAnyType(
+				type,
+				context.typeChecker,
+				context.program,
+				returnNode,
+			);
+			const functionNode = ts.findAncestor(
+				returnNode,
+				// TODO: I believe isFunctionLikeDeclaration was incorrectly marked
+				// as deprecated in https://github.com/JoshuaKGoldberg/ts-api-utils/pull/124
+				// It says "With TypeScript v5, in favor of typescript's `isFunctionLike`."
+				// However, isFunctionLike also checks for signature-like nodes,
+				// whereas isFunctionLikeDeclaration checks only for function-like nodes.
+				// eslint-disable-next-line @typescript-eslint/no-deprecated
+				tsutils.isFunctionLikeDeclaration,
+			);
+			if (!functionNode) {
+				return;
+			}
+
+			// function has an explicit return type, so ensure it's a safe return
+			const returnNodeType = getConstrainedTypeAtLocation(
+				returnNode,
+				context.typeChecker,
+			);
+
+			// function expressions will not have their return type modified based on receiver typing
+			// so we have to use the contextual typing in these cases, i.e.
+			// const foo1: () => Set<string> = () => new Set<any>();
+			// the return type of the arrow function is Set<any> even though the variable is typed as Set<string>
+			let functionType =
+				ts.isFunctionExpression(functionNode) ||
+				ts.isArrowFunction(functionNode)
+					? context.typeChecker.getContextualType(functionNode)
+					: context.typeChecker.getTypeAtLocation(functionNode);
+			functionType ??= context.typeChecker.getTypeAtLocation(functionNode);
+			const callSignatures = tsutils.getCallSignaturesOfType(functionType);
+			// If there is an explicit type annotation *and* that type matches the actual
+			// function return type, we shouldn't complain (it's intentional, even if unsafe)
+			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,
+							ts.SyntaxKind.AsyncKeyword,
+						)
+					) {
+						const awaitedSignatureReturnType =
+							context.typeChecker.getAwaitedType(signatureReturnType);
+
+						const awaitedReturnNodeType =
+							context.typeChecker.getAwaitedType(returnNodeType);
+						if (
+							awaitedReturnNodeType === awaitedSignatureReturnType ||
+							(awaitedSignatureReturnType &&
+								tsutils.isTypeFlagSet(
+									awaitedSignatureReturnType,
+									ts.TypeFlags.Any | ts.TypeFlags.Unknown,
+								))
+						) {
+							return;
+						}
+					}
+				}
+			}
+
+			if (anyType !== AnyType.Safe) {
+				// Allow cases when the declared return type of the function is either unknown or unknown[]
+				// and the function is returning any or any[].
+				for (const signature of callSignatures) {
+					const functionReturnType = signature.getReturnType();
+					if (
+						anyType === AnyType.Any &&
+						tsutils.isTypeFlagSet(functionReturnType, ts.TypeFlags.Unknown)
+					) {
+						return;
+					}
+					if (
+						anyType === AnyType.AnyArray &&
+						context.typeChecker.isArrayType(functionReturnType) &&
+						tsutils.isTypeFlagSet(
+							context.typeChecker.getTypeArguments(
+								functionReturnType as ts.TypeReference,
+							)[0],
+							ts.TypeFlags.Unknown,
+						)
+					) {
+						return;
+					}
+					const awaitedType =
+						context.typeChecker.getAwaitedType(functionReturnType);
+					if (
+						awaitedType &&
+						anyType === AnyType.PromiseAny &&
+						tsutils.isTypeFlagSet(awaitedType, ts.TypeFlags.Unknown)
+					) {
+						return;
+					}
+				}
+
+				if (
+					anyType === AnyType.PromiseAny &&
+					!tsutils.includesModifier(
+						functionNode.modifiers,
+						ts.SyntaxKind.AsyncKeyword,
+					)
+				) {
+					return;
+				}
+
+				let message: "unsafeReturn" | "unsafeReturnThis" = "unsafeReturn";
+				const isErrorType = tsutils.isIntrinsicErrorType(returnNodeType);
+
+				if (!isNoImplicitThis) {
+					// `return this`
+					const thisExpression = getThisExpression(returnNode);
+					if (
+						thisExpression &&
+						tsutils.isTypeFlagSet(
+							getConstrainedTypeAtLocation(thisExpression, context.typeChecker),
+							ts.TypeFlags.Any,
+						)
+					) {
+						message = "unsafeReturnThis";
+					}
+				}
+
+				// If the function return type was not unknown/unknown[], mark usage as unsafeReturn.
+				context.report({
+					data: {
+						type: isErrorType
+							? "error"
+							: anyType === AnyType.Any
+								? "`any`"
+								: anyType === AnyType.PromiseAny
+									? "`Promise<any>`"
+									: "`any[]`",
+					},
+					message,
+					range: {
+						begin: reportingNode.getStart(),
+						end: reportingNode.getEnd(),
+					},
+				});
+				return;
+			}
+
+			const signature = functionType.getCallSignatures().at(0);
+			if (signature) {
+				const functionReturnType = signature.getReturnType();
+				const result = isUnsafeAssignment(
+					returnNodeType,
+					functionReturnType,
+					context.typeChecker,
+					returnNode,
+				);
+				if (!result) {
+					return;
+				}
+
+				const { receiver, sender } = result;
+				context.report({
+					data: {
+						receiver: context.typeChecker.typeToString(receiver),
+						sender: context.typeChecker.typeToString(sender),
+					},
+					message: "unsafeReturnAssignment",
+					range: {
+						begin: reportingNode.getStart(),
+						end: reportingNode.getEnd(),
+					},
+				});
+				return;
+			}
+		}
+
+		return {
+			visitors: {
+				ArrowFunction: (node) => {
+					if (!ts.isBlock(node.body)) {
+						checkReturn(node.body, node.body);
+					}
+				},
+				ReturnStatement: (node) => {
+					if (node.expression != null) {
+						checkReturn(node.expression, node);
+					}
+				},
+			},
+		};
+	},
+});

package/src/rules/asyncPromiseExecutors.test.ts

@@ -0,0 +1,72 @@
+import rule from "./asyncPromiseExecutors.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+new Promise(async (resolve, reject) => {
+    resolve(42);
+});
+`,
+			snapshot: `
+new Promise(async (resolve, reject) => {
+            ~~~~~
+            Async Promise executor functions are not able to properly catch thrown errors and often indicate unnecessarily complex logic.
+    resolve(42);
+});
+`,
+		},
+		{
+			code: `
+new Promise(async function(resolve, reject) {
+    resolve(42);
+});
+`,
+			snapshot: `
+new Promise(async function(resolve, reject) {
+            ~~~~~
+            Async Promise executor functions are not able to properly catch thrown errors and often indicate unnecessarily complex logic.
+    resolve(42);
+});
+`,
+		},
+		{
+			code: `
+const p = new Promise(async (resolve) => {
+    resolve();
+});
+`,
+			snapshot: `
+const p = new Promise(async (resolve) => {
+                      ~~~~~
+                      Async Promise executor functions are not able to properly catch thrown errors and often indicate unnecessarily complex logic.
+    resolve();
+});
+`,
+		},
+	],
+	valid: [
+		`
+new Promise((resolve, reject) => {
+    resolve(42);
+});
+`,
+		`
+new Promise(function(resolve, reject) {
+    resolve(42);
+});
+`,
+		`
+const p = new Promise((resolve) => {
+    doSomething().then(resolve);
+});
+`,
+		`
+// Not a Promise constructor
+new SomethingElse(async (resolve) => {
+    resolve();
+});
+`,
+	],
+});

package/src/rules/asyncPromiseExecutors.ts

@@ -0,0 +1,61 @@
+import * as ts from "typescript";
+
+import { typescriptLanguage } from "../language.js";
+import { isGlobalDeclaration } from "../utils/isGlobalDeclaration.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description: "Reports using async functions as Promise executor functions.",
+		id: "asyncPromiseExecutors",
+		preset: "logical",
+	},
+	messages: {
+		asyncPromiseExecutor: {
+			primary:
+				"Async Promise executor functions are not able to properly catch thrown errors and often indicate unnecessarily complex logic.",
+			secondary: [
+				"The Promise executor function is called synchronously by the Promise constructor.",
+				"If an async function is used as a Promise executor, thrown errors will not be caught by the Promise and will instead result in unhandled rejections.",
+				"Additionally, if a Promise executor function is using `await`, there's probably no need to use the `new Promise` constructor.",
+			],
+			suggestions: [
+				"Remove the `async` keyword from the executor function.",
+				"If you need to use `await` inside the Promise, consider restructuring your code to avoid the Promise constructor.",
+			],
+		},
+	},
+	setup(context) {
+		return {
+			visitors: {
+				NewExpression: (node) => {
+					if (
+						!isGlobalDeclaration(node.expression, context.typeChecker) ||
+						!node.arguments?.length
+					) {
+						return;
+					}
+
+					const executor = node.arguments[0];
+					if (!ts.isFunctionLike(executor)) {
+						return;
+					}
+
+					const asyncModifier = executor.modifiers?.find(
+						(mod) => mod.kind === ts.SyntaxKind.AsyncKeyword,
+					);
+					if (!asyncModifier) {
+						return;
+					}
+
+					context.report({
+						message: "asyncPromiseExecutor",
+						range: {
+							begin: asyncModifier.getStart(context.sourceFile),
+							end: asyncModifier.getEnd(),
+						},
+					});
+				},
+			},
+		};
+	},
+});

package/src/rules/caseDeclarations.test.ts

@@ -0,0 +1,228 @@
+import rule from "./caseDeclarations.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+switch (value) {
+    case 1:
+        let x = 1;
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    case 1:
+        let x = 1;
+        ~~~
+        Variables declared in case clauses without braces leak into the surrounding scope.
+        break;
+}
+`,
+		},
+		{
+			code: `
+switch (value) {
+    case 1:
+        const x = 1;
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    case 1:
+        const x = 1;
+        ~~~~~
+        Variables declared in case clauses without braces leak into the surrounding scope.
+        break;
+}
+`,
+		},
+		{
+			code: `
+switch (value) {
+    case 1:
+        function foo() {}
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    case 1:
+        function foo() {}
+        ~~~~~~~~
+        Variables declared in case clauses without braces leak into the surrounding scope.
+        break;
+}
+`,
+		},
+		{
+			code: `
+switch (value) {
+    case 1:
+        class Foo {}
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    case 1:
+        class Foo {}
+        ~~~~~
+        Variables declared in case clauses without braces leak into the surrounding scope.
+        break;
+}
+`,
+		},
+		{
+			code: `
+switch (value) {
+    default:
+        let x = 1;
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    default:
+        let x = 1;
+        ~~~
+        Variables declared in case clauses without braces leak into the surrounding scope.
+        break;
+}
+`,
+		},
+		{
+			code: `
+switch (value) {
+    default:
+        const x = 1;
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    default:
+        const x = 1;
+        ~~~~~
+        Variables declared in case clauses without braces leak into the surrounding scope.
+        break;
+}
+`,
+		},
+		{
+			code: `
+switch (value) {
+    case 1:
+        let x = 1;
+    case 2:
+        let y = 2;
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    case 1:
+        let x = 1;
+        ~~~
+        Variables declared in case clauses without braces leak into the surrounding scope.
+    case 2:
+        let y = 2;
+        ~~~
+        Variables declared in case clauses without braces leak into the surrounding scope.
+        break;
+}
+`,
+		},
+		{
+			code: `
+switch (value) {
+    case 1:
+        const x = 1;
+        console.log(x);
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    case 1:
+        const x = 1;
+        ~~~~~
+        Variables declared in case clauses without braces leak into the surrounding scope.
+        console.log(x);
+        break;
+}
+`,
+		},
+	],
+	valid: [
+		`switch (value) { case 1: { let x = 1; break; } }`,
+		`switch (value) { case 1: { const x = 1; break; } }`,
+		`switch (value) { case 1: { function foo() {} break; } }`,
+		`switch (value) { case 1: { class Foo {} break; } }`,
+		`switch (value) { default: { let x = 1; break; } }`,
+		`switch (value) { default: { const x = 1; break; } }`,
+		`switch (value) { case 1: var x = 1; break; }`,
+		`switch (value) { case 1: break; }`,
+		`switch (value) { case 1: console.log("test"); break; }`,
+		`
+switch (value) {
+    case 1: {
+        let x = 1;
+        break;
+    }
+}
+`,
+		`
+switch (value) {
+    case 1: {
+        const x = 1;
+        break;
+    }
+}
+`,
+		`
+switch (value) {
+    case 1: {
+        function foo() {}
+        break;
+    }
+}
+`,
+		`
+switch (value) {
+    case 1: {
+        class Foo {}
+        break;
+    }
+}
+`,
+		`
+switch (value) {
+    case 1:
+        var x = 1;
+        break;
+}
+`,
+		`
+switch (value) {
+    case 1: {
+        let x = 1;
+    }
+    case 2: {
+        let y = 2;
+        break;
+    }
+}
+`,
+		`
+switch (value) {
+    default: {
+        let x = 1;
+        break;
+    }
+}
+`,
+	],
+});

package/src/rules/caseDeclarations.ts

@@ -0,0 +1,70 @@
+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: ts.NodeArray<ts.Statement>,
+		): ts.Node | undefined {
+			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: ts.CaseClause | ts.DefaultClause): void {
+			const declarationNode = getLexicalDeclaration(node.statements);
+			if (declarationNode) {
+				context.report({
+					message: "unexpectedLexicalDeclaration",
+					range: getTSNodeRange(declarationNode, context.sourceFile),
+				});
+			}
+		}
+
+		return {
+			visitors: {
+				CaseClause: checkClause,
+				DefaultClause: checkClause,
+			},
+		};
+	},
+});