@flint.fyi/ts 0.14.2 → 0.14.4

package/src/rules/unnecessaryCatches.test.ts

@@ -0,0 +1,211 @@
+import { ruleTester } from "./ruleTester.js";
+import rule from "./unnecessaryCatches.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+try {
+    doSomething();
+} catch (error) {
+    throw error;
+}
+`,
+			output: `
+try {
+    doSomething();
+}
+`,
+			snapshot: `
+try {
+    doSomething();
+} catch (error) {
+  ~~~~~
+  This catch clause is unnecessary, as it only rethrows the exception without modification.
+    throw error;
+}
+`,
+		},
+		{
+			code: `
+async function fetchData() {
+    try {
+        return await fetch("/api/data");
+    } catch (error) {
+        throw error;
+    }
+}
+`,
+			output: `
+async function fetchData() {
+    try {
+        return await fetch("/api/data");
+    }
+}
+`,
+			snapshot: `
+async function fetchData() {
+    try {
+        return await fetch("/api/data");
+    } catch (error) {
+      ~~~~~
+      This catch clause is unnecessary, as it only rethrows the exception without modification.
+        throw error;
+    }
+}
+`,
+		},
+		{
+			code: `
+try {
+    processData();
+} catch (exception) {
+    throw exception;
+}
+`,
+			output: `
+try {
+    processData();
+}
+`,
+			snapshot: `
+try {
+    processData();
+} catch (exception) {
+  ~~~~~
+  This catch clause is unnecessary, as it only rethrows the exception without modification.
+    throw exception;
+}
+`,
+		},
+		{
+			code: `
+function handleRequest() {
+    try {
+        const result = performOperation();
+        return result;
+    } catch (err) {
+        throw err;
+    }
+}
+`,
+			output: `
+function handleRequest() {
+    try {
+        const result = performOperation();
+        return result;
+    }
+}
+`,
+			snapshot: `
+function handleRequest() {
+    try {
+        const result = performOperation();
+        return result;
+    } catch (err) {
+      ~~~~~
+      This catch clause is unnecessary, as it only rethrows the exception without modification.
+        throw err;
+    }
+}
+`,
+		},
+		{
+			code: `
+try {
+    doSomething();
+} catch (error) {
+    throw error;
+} finally {
+    cleanup();
+}
+`,
+			output: `
+try {
+    doSomething();
+} finally {
+    cleanup();
+}
+`,
+			snapshot: `
+try {
+    doSomething();
+} catch (error) {
+  ~~~~~
+  This catch clause is unnecessary, as it only rethrows the exception without modification.
+    throw error;
+} finally {
+    cleanup();
+}
+`,
+		},
+	],
+	valid: [
+		`try { doSomething(); } catch (error) { console.error(error); throw error; }`,
+		`try { doSomething(); } catch (error) { throw new Error("Failed"); }`,
+		`try { doSomething(); } catch (error) { logError(error); throw error; }`,
+		`try { doSomething(); } catch { throw new Error("Something went wrong"); }`,
+		`
+try {
+    doSomething();
+} catch (error) {
+    console.error("An error occurred:", error);
+    throw error;
+}
+`,
+		`
+try {
+    doSomething();
+} catch (error) {
+    throw new Error("Operation failed: " + error.message);
+}
+`,
+		`
+try {
+    doSomething();
+} catch (error) {
+    cleanup();
+    throw error;
+}
+`,
+		`
+try {
+    doSomething();
+} catch (error) {
+    throw error.originalError;
+}
+`,
+		`
+async function fetchData() {
+    try {
+        return await fetch("/api/data");
+    } catch (error) {
+        await logError(error);
+        throw error;
+    }
+}
+`,
+		`
+try {
+    doSomething();
+} catch ({ message }) {
+    throw message;
+}
+`,
+		`
+try {
+    doSomething();
+} catch (error) {
+}
+`,
+		`
+try {
+    doSomething();
+} catch (error) {
+    console.log("error");
+    cleanup();
+    throw error;
+}
+`,
+	],
+});

package/src/rules/unnecessaryCatches.ts

@@ -0,0 +1,84 @@
+import * as ts from "typescript";
+
+import { typescriptLanguage } from "../language.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description:
+			"Reports catch clauses that only rethrow the caught error without modification.",
+		id: "unnecessaryCatches",
+		preset: "logical",
+	},
+	messages: {
+		unnecessaryCatch: {
+			primary:
+				"This catch clause is unnecessary, as it only rethrows the exception without modification.",
+			secondary: [
+				"A catch clause that only rethrows the caught error adds no value and creates unnecessary code complexity.",
+				"Removing such catch clauses allows errors to propagate naturally without the overhead of an unnecessary try-catch block.",
+			],
+			suggestions: [
+				"Remove the try-catch block if the catch clause only rethrows the error, or add meaningful error handling logic to the catch clause.",
+			],
+		},
+	},
+	setup(context) {
+		return {
+			visitors: {
+				CatchClause: (node) => {
+					if (!node.variableDeclaration || !ts.isBlock(node.block)) {
+						return;
+					}
+
+					const statements = node.block.statements;
+
+					if (statements.length !== 1) {
+						return;
+					}
+
+					const statement = statements[0];
+
+					if (!ts.isThrowStatement(statement)) {
+						return;
+					}
+
+					const catchVariable = node.variableDeclaration.name;
+					const thrownExpression = statement.expression;
+
+					if (
+						!ts.isIdentifier(catchVariable) ||
+						!ts.isIdentifier(thrownExpression)
+					) {
+						return;
+					}
+
+					if (catchVariable.text !== thrownExpression.text) {
+						return;
+					}
+
+					const tryStatement = node.parent;
+					if (!ts.isTryStatement(tryStatement)) {
+						return;
+					}
+
+					const range = {
+						begin: node.getStart(context.sourceFile),
+						end: node.getStart(context.sourceFile) + "catch".length,
+					};
+
+					context.report({
+						fix: {
+							range: {
+								begin: tryStatement.tryBlock.getEnd(),
+								end: node.getEnd(),
+							},
+							text: "",
+						},
+						message: "unnecessaryCatch",
+						range,
+					});
+				},
+			},
+		};
+	},
+});

package/src/rules/unsafeNegations.test.ts

@@ -0,0 +1,64 @@
+import { ruleTester } from "./ruleTester.js";
+import rule from "./unsafeNegations.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+!key in object;
+`,
+			snapshot: `
+!key in object;
+~
+This negation applies before the \`in\` operator.
+`,
+		},
+		{
+			code: `
+!object instanceof Constructor;
+`,
+			snapshot: `
+!object instanceof Constructor;
+~
+This negation applies before the \`instanceof\` operator.
+`,
+		},
+		{
+			code: `
+(!key) in object;
+`,
+			snapshot: `
+(!key) in object;
+ ~
+ This negation applies before the \`in\` operator.
+`,
+		},
+		{
+			code: `
+(!object) instanceof Constructor;
+`,
+			snapshot: `
+(!object) instanceof Constructor;
+ ~
+ This negation applies before the \`instanceof\` operator.
+`,
+		},
+		{
+			code: `
+const exists = !key in object;
+`,
+			snapshot: `
+const exists = !key in object;
+               ~
+               This negation applies before the \`in\` operator.
+`,
+		},
+	],
+	valid: [
+		`!(key in object);`,
+		`!(object instanceof Constructor);`,
+		`key in object;`,
+		`object instanceof Constructor;`,
+		`!flag && key in object;`,
+	],
+});

package/src/rules/unsafeNegations.ts

@@ -0,0 +1,59 @@
+import * as ts from "typescript";
+
+import { typescriptLanguage } from "../language.js";
+import { unwrapParenthesizedExpression } from "../utils/unwrapParenthesizedExpression.js";
+
+const operatorStrings = new Map([
+	[ts.SyntaxKind.InKeyword, "in"],
+	[ts.SyntaxKind.InstanceOfKeyword, "instanceof"],
+]);
+
+export default typescriptLanguage.createRule({
+	about: {
+		description:
+			"Reports negating the left operand of `in` or `instanceof` relations.",
+		id: "unsafeNegations",
+		preset: "untyped",
+	},
+	messages: {
+		preferNegatingRelation: {
+			primary: "This negation applies before the `{{ operator }}` operator.",
+			secondary: [
+				"The logical not operator (!) has higher precedence than `in` and `instanceof`.",
+				"Write `!(left in right)` or `!(left instanceof Right)` to negate the relation as intended.",
+			],
+			suggestions: ["Wrap the relation in parentheses and negate it."],
+		},
+	},
+	setup(context) {
+		return {
+			visitors: {
+				BinaryExpression: (node) => {
+					const operator = operatorStrings.get(node.operatorToken.kind);
+					if (!operator) {
+						return;
+					}
+
+					const left = unwrapParenthesizedExpression(node.left);
+					if (
+						!ts.isPrefixUnaryExpression(left) ||
+						left.operator !== ts.SyntaxKind.ExclamationToken
+					) {
+						return;
+					}
+
+					const begin = left.getStart(context.sourceFile);
+
+					context.report({
+						data: { operator },
+						message: "preferNegatingRelation",
+						range: {
+							begin,
+							end: begin + 1,
+						},
+					});
+				},
+			},
+		};
+	},
+});

package/src/rules/utils/discriminateAnyType.ts

@@ -0,0 +1,66 @@
+import * as tsutils from "ts-api-utils";
+import * as ts from "typescript";
+
+export enum AnyType {
+	Any,
+	PromiseAny,
+	AnyArray,
+	Safe,
+}
+
+/**
+ * @returns `AnyType.Any` if the type is `any`, `AnyType.AnyArray` if the type is `any[]` or `readonly any[]`, `AnyType.PromiseAny` if the type is `Promise<any>`,
+ * otherwise it returns `AnyType.Safe`.
+ */
+export function discriminateAnyType(
+	type: ts.Type,
+	checker: ts.TypeChecker,
+	program: ts.Program,
+	tsNode: ts.Node,
+): AnyType {
+	return discriminateAnyTypeWorker(type, checker, program, tsNode, new Set());
+}
+
+function discriminateAnyTypeWorker(
+	type: ts.Type,
+	checker: ts.TypeChecker,
+	program: ts.Program,
+	tsNode: ts.Node,
+	visited: Set<ts.Type>,
+) {
+	if (visited.has(type)) {
+		return AnyType.Safe;
+	}
+	visited.add(type);
+	if (tsutils.isTypeFlagSet(type, ts.TypeFlags.Any)) {
+		return AnyType.Any;
+	}
+	if (
+		checker.isArrayType(type) &&
+		tsutils.isTypeFlagSet(
+			checker.getTypeArguments(type as ts.TypeReference)[0],
+			ts.TypeFlags.Any,
+		)
+	) {
+		return AnyType.AnyArray;
+	}
+	for (const part of tsutils.typeConstituents(type)) {
+		if (tsutils.isThenableType(checker, tsNode, part)) {
+			const awaitedType = checker.getAwaitedType(part);
+			if (awaitedType) {
+				const awaitedAnyType = discriminateAnyTypeWorker(
+					awaitedType,
+					checker,
+					program,
+					tsNode,
+					visited,
+				);
+				if (awaitedAnyType === AnyType.Any) {
+					return AnyType.PromiseAny;
+				}
+			}
+		}
+	}
+
+	return AnyType.Safe;
+}

package/src/rules/utils/getThisExpression.ts

@@ -0,0 +1,24 @@
+import * as tsutils from "ts-api-utils";
+import * as ts from "typescript";
+
+export function getThisExpression(node: ts.Node): null | ts.ThisExpression {
+	while (true) {
+		node = skipParentheses(node);
+		if (ts.isCallExpression(node) || tsutils.isAccessExpression(node)) {
+			node = node.expression;
+		} else if (tsutils.isThisExpression(node)) {
+			return node;
+		} else {
+			break;
+		}
+	}
+
+	return null;
+}
+
+function skipParentheses(node: ts.Node): ts.Node {
+	while (ts.isParenthesizedExpression(node)) {
+		node = node.expression;
+	}
+	return node;
+}

package/src/rules/utils/isUnsafeAssignment.ts

@@ -0,0 +1,113 @@
+import * as tsutils from "ts-api-utils";
+import * as ts from "typescript";
+
+/**
+ * Does a simple check to see if there is an any being assigned to a non-any type.
+ *
+ * This also checks generic positions to ensure there's no unsafe sub-assignments.
+ * Note: in the case of generic positions, it makes the assumption that the two types are the same.
+ * @example See tests for examples
+ * @returns false if it's safe, or an object with the two types if it's unsafe
+ */
+export function isUnsafeAssignment(
+	type: ts.Type,
+	receiver: ts.Type,
+	checker: ts.TypeChecker,
+	senderNode: null | ts.Node,
+): false | { receiver: ts.Type; sender: ts.Type } {
+	return isUnsafeAssignmentWorker(
+		type,
+		receiver,
+		checker,
+		senderNode,
+		new Map(),
+	);
+}
+
+function isUnsafeAssignmentWorker(
+	type: ts.Type,
+	receiver: ts.Type,
+	checker: ts.TypeChecker,
+	senderNode: null | ts.Node,
+	visited: Map<ts.Type, Set<ts.Type>>,
+): false | { receiver: ts.Type; sender: ts.Type } {
+	if (tsutils.isTypeFlagSet(type, ts.TypeFlags.Any)) {
+		// Allow assignment of any ==> unknown.
+		if (tsutils.isTypeFlagSet(receiver, ts.TypeFlags.Unknown)) {
+			return false;
+		}
+
+		if (!tsutils.isTypeFlagSet(receiver, ts.TypeFlags.Any)) {
+			return { receiver, sender: type };
+		}
+	}
+
+	const typeAlreadyVisited = visited.get(type);
+
+	if (typeAlreadyVisited) {
+		if (typeAlreadyVisited.has(receiver)) {
+			return false;
+		}
+		typeAlreadyVisited.add(receiver);
+	} else {
+		visited.set(type, new Set([receiver]));
+	}
+
+	if (tsutils.isTypeReference(type) && tsutils.isTypeReference(receiver)) {
+		// TODO - figure out how to handle cases like this,
+		// where the types are assignable, but not the same type
+		/*
+    function foo(): ReadonlySet<number> { return new Set<any>(); }
+
+    // and
+
+    type Test<T> = { prop: T }
+    type Test2 = { prop: string }
+    declare const a: Test<any>;
+    const b: Test2 = a;
+    */
+
+		if (type.target !== receiver.target) {
+			// if the type references are different, assume safe, as we won't know how to compare the two types
+			// the generic positions might not be equivalent for both types
+			return false;
+		}
+
+		if (
+			senderNode != null &&
+			ts.isNewExpression(senderNode) &&
+			ts.isIdentifier(senderNode.expression) &&
+			senderNode.expression.text === "Map" &&
+			(senderNode.arguments == null || senderNode.arguments.length === 0) &&
+			senderNode.typeArguments == null
+		) {
+			// special case to handle `new Map()`
+			// unfortunately Map's default empty constructor is typed to return `Map<any, any>` :(
+			// https://github.com/typescript-eslint/typescript-eslint/issues/2109#issuecomment-634144396
+			return false;
+		}
+
+		const typeArguments = type.typeArguments ?? [];
+		const receiverTypeArguments = receiver.typeArguments ?? [];
+
+		for (let i = 0; i < typeArguments.length; i += 1) {
+			const arg = typeArguments[i];
+			const receiverArg = receiverTypeArguments[i];
+
+			const unsafe = isUnsafeAssignmentWorker(
+				arg,
+				receiverArg,
+				checker,
+				senderNode,
+				visited,
+			);
+			if (unsafe) {
+				return { receiver, sender: type };
+			}
+		}
+
+		return false;
+	}
+
+	return false;
+}

package/src/rules/utils/operators.ts

@@ -0,0 +1,39 @@
+import * as ts from "typescript";
+
+export function isComparisonOperator(token: ts.BinaryOperatorToken) {
+	switch (token.kind) {
+		case ts.SyntaxKind.EqualsEqualsEqualsToken:
+		case ts.SyntaxKind.EqualsEqualsToken:
+		case ts.SyntaxKind.ExclamationEqualsEqualsToken:
+		case ts.SyntaxKind.ExclamationEqualsToken:
+		case ts.SyntaxKind.GreaterThanEqualsToken:
+		case ts.SyntaxKind.GreaterThanToken:
+		case ts.SyntaxKind.LessThanEqualsToken:
+		case ts.SyntaxKind.LessThanToken:
+			return true;
+		default:
+			return false;
+	}
+}
+
+export function isEqualityOperator(token: ts.BinaryOperatorToken) {
+	switch (token.kind) {
+		case ts.SyntaxKind.EqualsEqualsEqualsToken:
+		case ts.SyntaxKind.EqualsEqualsToken:
+		case ts.SyntaxKind.ExclamationEqualsEqualsToken:
+		case ts.SyntaxKind.ExclamationEqualsToken:
+			return true;
+		default:
+			return false;
+	}
+}
+
+export function isNegatedEqualityOperator(token: ts.BinaryOperatorToken) {
+	switch (token.kind) {
+		case ts.SyntaxKind.ExclamationEqualsEqualsToken:
+		case ts.SyntaxKind.ExclamationEqualsToken:
+			return true;
+		default:
+			return false;
+	}
+}