@flint.fyi/ts 0.14.6 → 0.18.0

package/src/rules/anyReturns.ts

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

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

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

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

@@ -1,70 +0,0 @@
-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,
-			},
-		};
-	},
-});