@flint.fyi/ts 0.14.6 → 0.18.0

package/src/rules/unnecessaryBlocks.test.ts

@@ -1,148 +0,0 @@
-import { ruleTester } from "./ruleTester.js";
-import rule from "./unnecessaryBlocks.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-{
-    const x = 1;
-}
-`,
-			snapshot: `
-{
-~
-This standalone block statement is unnecessary and doesn't change any variable scopes.
-    const x = 1;
-}
-`,
-		},
-		{
-			code: `
-function test() {
-    {
-        const y = 2;
-    }
-}
-`,
-			snapshot: `
-function test() {
-    {
-    ~
-    This standalone block statement is unnecessary and doesn't change any variable scopes.
-        const y = 2;
-    }
-}
-`,
-		},
-		{
-			code: `
-if (condition) {
-    doSomething();
-    {
-        const nested = true;
-    }
-}
-`,
-			snapshot: `
-if (condition) {
-    doSomething();
-    {
-    ~
-    This standalone block statement is unnecessary and doesn't change any variable scopes.
-        const nested = true;
-    }
-}
-`,
-		},
-		{
-			code: `
-{
-    console.log("standalone");
-}
-`,
-			snapshot: `
-{
-~
-This standalone block statement is unnecessary and doesn't change any variable scopes.
-    console.log("standalone");
-}
-`,
-		},
-		{
-			code: `
-function outer() {
-    {
-        console.log("inner");
-    }
-    {
-        console.log("another");
-    }
-}
-`,
-			snapshot: `
-function outer() {
-    {
-    ~
-    This standalone block statement is unnecessary and doesn't change any variable scopes.
-        console.log("inner");
-    }
-    {
-    ~
-    This standalone block statement is unnecessary and doesn't change any variable scopes.
-        console.log("another");
-    }
-}
-`,
-		},
-	],
-	valid: [
-		`if (condition) { doSomething(); }`,
-		`for (let i = 0; i < 10; i++) { console.log(i); }`,
-		`while (condition) { doWork(); }`,
-		`do { doWork(); } while (condition);`,
-		`function test() { return 42; }`,
-		`const arrow = () => { return 1; };`,
-		`
-switch (value) {
-    case 1: {
-        const x = 1;
-        break;
-    }
-    case 2: {
-        const y = 2;
-        break;
-    }
-}
-`,
-		`
-try {
-    doSomething();
-} catch (error) {
-    handleError(error);
-}
-`,
-		`
-class MyClass {
-    method() {
-        return 1;
-    }
-}
-`,
-		`
-for (const item of items) {
-    processItem(item);
-}
-`,
-		`
-for (const key in object) {
-    processKey(key);
-}
-`,
-		`
-label: {
-    break label;
-}
-`,
-	],
-});

package/src/rules/unnecessaryBlocks.ts

@@ -1,89 +0,0 @@
-import * as ts from "typescript";
-
-import { typescriptLanguage } from "../language.js";
-
-export default typescriptLanguage.createRule({
-	about: {
-		description:
-			"Reports standalone block statements that don't create a meaningful scope.",
-		id: "unnecessaryBlocks",
-		preset: "stylistic",
-	},
-	messages: {
-		unnecessaryBlock: {
-			primary:
-				"This standalone block statement is unnecessary and doesn't change any variable scopes.",
-			secondary: [
-				"Standalone block statements that aren't part of control flow (if/else, loops, switch) or don't create a meaningful lexical scope can be confusing and should be avoided.",
-				"In modern JavaScript and TypeScript, blocks primarily serve to create lexical scope for `let` and `const` variables, but this is often better achieved through other means.",
-			],
-			suggestions: [
-				"Remove the block statement and move its contents to the parent scope.",
-				"If you need lexical scoping, consider using an IIFE (Immediately Invoked Function Expression) or extracting to a separate function.",
-			],
-		},
-	},
-	setup(context) {
-		function isValidBlock(node: ts.Block): boolean {
-			const parent = node.parent;
-
-			// Valid blocks: function bodies, arrow functions, class/interface bodies, etc.
-			if (
-				ts.isFunctionDeclaration(parent) ||
-				ts.isFunctionExpression(parent) ||
-				ts.isArrowFunction(parent) ||
-				ts.isMethodDeclaration(parent) ||
-				ts.isConstructorDeclaration(parent) ||
-				ts.isGetAccessorDeclaration(parent) ||
-				ts.isSetAccessorDeclaration(parent) ||
-				ts.isModuleBlock(parent)
-			) {
-				return true;
-			}
-
-			// Valid blocks: control flow statements
-			if (
-				ts.isIfStatement(parent) ||
-				ts.isForStatement(parent) ||
-				ts.isForInStatement(parent) ||
-				ts.isForOfStatement(parent) ||
-				ts.isWhileStatement(parent) ||
-				ts.isDoStatement(parent) ||
-				ts.isWithStatement(parent) ||
-				ts.isTryStatement(parent) ||
-				ts.isCatchClause(parent)
-			) {
-				return true;
-			}
-
-			// Valid block: switch case/default clause with block
-			// In ES6+, blocks in switch cases create scope for let/const
-			if (ts.isCaseClause(parent) || ts.isDefaultClause(parent)) {
-				return true;
-			}
-
-			// Valid block: labeled statement
-			if (ts.isLabeledStatement(parent)) {
-				return true;
-			}
-
-			return false;
-		}
-
-		return {
-			visitors: {
-				Block: (node) => {
-					if (!isValidBlock(node)) {
-						context.report({
-							message: "unnecessaryBlock",
-							range: {
-								begin: node.getStart(context.sourceFile),
-								end: node.getStart(context.sourceFile) + 1,
-							},
-						});
-					}
-				},
-			},
-		};
-	},
-});

package/src/rules/unnecessaryCatches.test.ts

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

@@ -1,84 +0,0 @@
-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/unnecessaryConcatenation.test.ts

@@ -1,88 +0,0 @@
-import { ruleTester } from "./ruleTester.js";
-import rule from "./unnecessaryConcatenation.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-const message = "Hello" + "World";
-`,
-			snapshot: `
-const message = "Hello" + "World";
-                        ~
-                        This string concatenation can be streamlined into a single string literal.
-`,
-		},
-		{
-			code: `
-const path = 'foo' + 'bar';
-`,
-			snapshot: `
-const path = 'foo' + 'bar';
-                   ~
-                   This string concatenation can be streamlined into a single string literal.
-`,
-		},
-		{
-			code: `
-const result = "abc" + "def" + "ghi";
-`,
-			snapshot: `
-const result = "abc" + "def" + "ghi";
-                     ~
-                     This string concatenation can be streamlined into a single string literal.
-`,
-		},
-		{
-			code: `
-const text = "first" + "second";
-`,
-			snapshot: `
-const text = "first" + "second";
-                     ~
-                     This string concatenation can be streamlined into a single string literal.
-`,
-		},
-		{
-			code: `
-const mixed = 'single' + "double";
-`,
-			snapshot: `
-const mixed = 'single' + "double";
-                       ~
-                       This string concatenation can be streamlined into a single string literal.
-`,
-		},
-		{
-			code: `
-const withSpace = "Hello " + "World";
-`,
-			snapshot: `
-const withSpace = "Hello " + "World";
-                           ~
-                           This string concatenation can be streamlined into a single string literal.
-`,
-		},
-		{
-			code: `
-const longString = "This is a very long string that " +
-    "continues on the next line";
-`,
-			snapshot: `
-const longString = "This is a very long string that " +
-                                                      ~
-                                                      This string concatenation can be streamlined into a single string literal.
-    "continues on the next line";
-`,
-		},
-	],
-	valid: [
-		`const message = "Hello" + variable;`,
-		`const message = variable + "World";`,
-		`const result = variable1 + variable2;`,
-		`const template = \`Hello\${name}World\`;`,
-		`const number = 1 + 2;`,
-		`const mixed = "Hello" + getName() + "World";`,
-		`const value = "prefix" + getValue();`,
-	],
-});

package/src/rules/unnecessaryConcatenation.ts

@@ -1,44 +0,0 @@
-import * as ts from "typescript";
-
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-
-export default typescriptLanguage.createRule({
-	about: {
-		description:
-			"Reports string concatenation using the + operator when both operands are string literals.",
-		id: "unnecessaryConcatenation",
-		preset: "stylistic",
-	},
-	messages: {
-		unnecessaryConcatenation: {
-			primary:
-				"This string concatenation can be streamlined into a single string literal.",
-			secondary: [
-				"Concatenating string literals with the + operator is unnecessary and reduces code readability.",
-				"String literals can be combined into a single literal, which is clearer and potentially more performant.",
-			],
-			suggestions: [
-				"Combine the string literals into a single string literal.",
-			],
-		},
-	},
-	setup(context) {
-		return {
-			visitors: {
-				BinaryExpression: (node) => {
-					if (
-						node.operatorToken.kind === ts.SyntaxKind.PlusToken &&
-						ts.isStringLiteral(node.left) &&
-						ts.isStringLiteral(node.right)
-					) {
-						context.report({
-							message: "unnecessaryConcatenation",
-							range: getTSNodeRange(node.operatorToken, context.sourceFile),
-						});
-					}
-				},
-			},
-		};
-	},
-});

package/src/rules/unsafeNegations.test.ts

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