@flint.fyi/ts 0.14.3 → 0.14.5

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/caseDuplicates.test.ts

@@ -0,0 +1,308 @@
+import rule from "./caseDuplicates.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+switch (value) {
+    case 1:
+        break;
+    case 1:
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    case 1:
+        break;
+    case 1:
+    ~~~~~~
+    This case duplicates a previous case, so it will never be reached.
+        break;
+}
+`,
+		},
+		{
+			code: `
+switch (value) {
+    case "a":
+        break;
+    case "b":
+        break;
+    case "a":
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    case "a":
+        break;
+    case "b":
+        break;
+    case "a":
+    ~~~~~~~~
+    This case duplicates a previous case, so it will never be reached.
+        break;
+}
+`,
+		},
+		{
+			code: `
+switch (value) {
+    case x + 1:
+        break;
+    case x + 1:
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    case x + 1:
+        break;
+    case x + 1:
+    ~~~~~~~~~~
+    This case duplicates a previous case, so it will never be reached.
+        break;
+}
+`,
+		},
+		{
+			code: `
+switch (value) {
+    case 1:
+        break;
+    case 2:
+        break;
+    case 1:
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    case 1:
+        break;
+    case 2:
+        break;
+    case 1:
+    ~~~~~~
+    This case duplicates a previous case, so it will never be reached.
+        break;
+}
+`,
+		},
+		{
+			code: `
+switch (value) {
+    case true:
+        break;
+    case false:
+        break;
+    case true:
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    case true:
+        break;
+    case false:
+        break;
+    case true:
+    ~~~~~~~~~
+    This case duplicates a previous case, so it will never be reached.
+        break;
+}
+`,
+		},
+		{
+			code: `
+switch (value) {
+    case obj.property:
+        break;
+    case obj.property:
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    case obj.property:
+        break;
+    case obj.property:
+    ~~~~~~~~~~~~~~~~~
+    This case duplicates a previous case, so it will never be reached.
+        break;
+}
+`,
+		},
+		{
+			code: `
+const result = (input: number) => {
+    switch (input) {
+        case 1:
+            return "one";
+        case 2:
+            return "two";
+        case 1:
+            return "duplicate";
+    }
+};
+`,
+			snapshot: `
+const result = (input: number) => {
+    switch (input) {
+        case 1:
+            return "one";
+        case 2:
+            return "two";
+        case 1:
+        ~~~~~~
+        This case duplicates a previous case, so it will never be reached.
+            return "duplicate";
+    }
+};
+`,
+		},
+		{
+			code: `
+switch (value) {
+    case 1: case 1: break;
+}
+`,
+			snapshot: `
+switch (value) {
+    case 1: case 1: break;
+            ~~~~~~
+            This case duplicates a previous case, so it will never be reached.
+}
+`,
+		},
+		{
+			code: `
+const condition = true;
+switch (value) {
+    case condition ? "a" : "b":
+        break;
+    case condition ? "a" : "b":
+        break;
+}
+`,
+			snapshot: `
+const condition = true;
+switch (value) {
+    case condition ? "a" : "b":
+        break;
+    case condition ? "a" : "b":
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~
+    This case duplicates a previous case, so it will never be reached.
+        break;
+}
+`,
+		},
+		{
+			code: `
+switch (value) {
+    case /* comment */ 1:
+        break;
+    case 1:
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    case /* comment */ 1:
+        break;
+    case 1:
+    ~~~~~~
+    This case duplicates a previous case, so it will never be reached.
+        break;
+}
+`,
+		},
+		{
+			code: `
+switch (value) {
+    case obj.property:
+        break;
+    case obj /* comment */ .property:
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    case obj.property:
+        break;
+    case obj /* comment */ .property:
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    This case duplicates a previous case, so it will never be reached.
+        break;
+}
+`,
+		},
+	],
+	valid: [
+		`switch (value) { case 1: break; case 2: break; }`,
+		`switch (value) { case 1: break; case 2: break; case 3: break; }`,
+		`switch (value) { case "a": break; case "b": break; }`,
+		`switch (value) { case true: break; case false: break; }`,
+		`switch (value) { case 1: case 2: break; }`,
+		`switch (value) { default: break; }`,
+		`
+switch (value) {
+    case 1:
+        break;
+    case 2:
+        break;
+}
+`,
+		`
+switch (value) {
+    case x:
+        break;
+    case y:
+        break;
+}
+`,
+		`
+switch (value) {
+    case obj.a:
+        break;
+    case obj.b:
+        break;
+}
+`,
+		`
+switch (value) {
+    case 1:
+        console.log("one");
+        break;
+    case 2:
+        console.log("two");
+        break;
+    default:
+        console.log("default");
+        break;
+}
+`,
+		`
+switch (value) {
+    case x + 1:
+        break;
+    case x + 2:
+        break;
+}
+`,
+		`
+const result = (input: number) => {
+    switch (input) {
+        case 1:
+            return "one";
+        case 2:
+            return "two";
+        default:
+            return "unknown";
+    }
+};
+`,
+	],
+});

package/src/rules/caseDuplicates.ts

@@ -0,0 +1,57 @@
+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: ts.Expression[] = [];
+
+					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);
+						}
+					}
+				},
+			},
+		};
+	},
+});

package/src/rules/chainedAssignments.test.ts

@@ -234,6 +234,30 @@ class MyClass {
         second = 0;
     }
 }
+`,
+		`
+let result = "";
+result += "a" + "b";
+`,
+		`
+let result = 0;
+result += 1 + 2;
+`,
+		`
+let result = 0;
+result += 1 * 2;
+`,
+		`
+let result = 0;
+result += 1 - 2;
+`,
+		`
+let result = 0;
+result += 1 / 2;
+`,
+		`
+let result = 0;
+result += 1 ** 2;
 `,
 	],
 });

package/src/rules/chainedAssignments.ts

@@ -35,7 +35,10 @@ export default typescriptLanguage.createRule({
 					}
 
 					const rightSide = unwrapParenthesizedExpression(node.right);
-					if (!ts.isBinaryExpression(rightSide)) {
+					if (
+						!ts.isBinaryExpression(rightSide) ||
+						!tsutils.isAssignmentKind(rightSide.operatorToken.kind)
+					) {
 						return;
 					}
 

package/src/rules/debuggerStatements.test.ts

@@ -30,8 +30,8 @@ function test() {
 			snapshot: `
 function test() {
 	debugger;
- ~~~~~~~~~
- Debugger statements should not be used in production code.
+	~~~~~~~~~
+	Debugger statements should not be used in production code.
 }
 `,
 			suggestions: [
@@ -54,8 +54,8 @@ if (condition) {
 			snapshot: `
 if (condition) {
 	debugger;
- ~~~~~~~~~
- Debugger statements should not be used in production code.
+	~~~~~~~~~
+	Debugger statements should not be used in production code.
 }
 `,
 			suggestions: [