@flint.fyi/ts 0.14.1 → 0.14.3

package/src/rules/emptyDestructures.test.ts

@@ -0,0 +1,187 @@
+import rule from "./emptyDestructures.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+const {} = object;
+`,
+			snapshot: `
+const {} = object;
+      ~~
+      Destructuring patterns that don't extract at least one value are unnecessary.
+`,
+		},
+		{
+			code: `
+const [] = array;
+`,
+			snapshot: `
+const [] = array;
+      ~~
+      Destructuring patterns that don't extract at least one value are unnecessary.
+`,
+		},
+		{
+			code: `
+function process({}) {
+    console.log("processed");
+}
+`,
+			snapshot: `
+function process({}) {
+                 ~~
+                 Destructuring patterns that don't extract at least one value are unnecessary.
+    console.log("processed");
+}
+`,
+		},
+		{
+			code: `
+function process([]) {
+    console.log("processed");
+}
+`,
+			snapshot: `
+function process([]) {
+                 ~~
+                 Destructuring patterns that don't extract at least one value are unnecessary.
+    console.log("processed");
+}
+`,
+		},
+		{
+			code: `
+const process = ({}) => {
+    console.log("processed");
+};
+`,
+			snapshot: `
+const process = ({}) => {
+                 ~~
+                 Destructuring patterns that don't extract at least one value are unnecessary.
+    console.log("processed");
+};
+`,
+		},
+		{
+			code: `
+const process = ([]) => {
+    console.log("processed");
+};
+`,
+			snapshot: `
+const process = ([]) => {
+                 ~~
+                 Destructuring patterns that don't extract at least one value are unnecessary.
+    console.log("processed");
+};
+`,
+		},
+		{
+			code: `
+const { prop: {} } = object;
+`,
+			snapshot: `
+const { prop: {} } = object;
+              ~~
+              Destructuring patterns that don't extract at least one value are unnecessary.
+`,
+		},
+		{
+			code: `
+const { prop: [] } = object;
+`,
+			snapshot: `
+const { prop: [] } = object;
+              ~~
+              Destructuring patterns that don't extract at least one value are unnecessary.
+`,
+		},
+		{
+			code: `
+for (const {} of objects) {
+    console.log("iterating");
+}
+`,
+			snapshot: `
+for (const {} of objects) {
+           ~~
+           Destructuring patterns that don't extract at least one value are unnecessary.
+    console.log("iterating");
+}
+`,
+		},
+		{
+			code: `
+for (const [] of arrays) {
+    console.log("iterating");
+}
+`,
+			snapshot: `
+for (const [] of arrays) {
+           ~~
+           Destructuring patterns that don't extract at least one value are unnecessary.
+    console.log("iterating");
+}
+`,
+		},
+		{
+			code: `
+try {
+    doSomething();
+} catch ({}) {
+    console.log("error");
+}
+`,
+			snapshot: `
+try {
+    doSomething();
+} catch ({}) {
+         ~~
+         Destructuring patterns that don't extract at least one value are unnecessary.
+    console.log("error");
+}
+`,
+		},
+		{
+			code: `
+try {
+    doSomething();
+} catch ([]) {
+    console.log("error");
+}
+`,
+			snapshot: `
+try {
+    doSomething();
+} catch ([]) {
+         ~~
+         Destructuring patterns that don't extract at least one value are unnecessary.
+    console.log("error");
+}
+`,
+		},
+	],
+	valid: [
+		`const { a } = object;`,
+		`const { a, b } = object;`,
+		`const [ a ] = array;`,
+		`const [ a, b ] = array;`,
+		`function process({ a }) { console.log(a); }`,
+		`function process([ a ]) { console.log(a); }`,
+		`const process = ({ a }) => console.log(a);`,
+		`const process = ([ a ]) => console.log(a);`,
+		`const { prop: { nested } } = object;`,
+		`const { prop: [ element ] } = object;`,
+		`for (const { value } of objects) { console.log(value); }`,
+		`for (const [ value ] of arrays) { console.log(value); }`,
+		`try { doSomething(); } catch ({ message }) { console.log(message); }`,
+		`try { doSomething(); } catch ([ first ]) { console.log(first); }`,
+		`const object = {};`,
+		`const array = [];`,
+		`function returnEmpty() { return {}; }`,
+		`function returnEmptyArray() { return []; }`,
+	],
+});

package/src/rules/emptyDestructures.ts

@@ -0,0 +1,48 @@
+import * as ts from "typescript";
+
+import { typescriptLanguage } from "../language.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description:
+			"Reports using empty destructuring patterns that destructure no values.",
+		id: "emptyDestructures",
+		preset: "logical",
+	},
+	messages: {
+		emptyPattern: {
+			primary:
+				"Destructuring patterns that don't extract at least one value are unnecessary.",
+			secondary: [
+				"Empty destructuring patterns like `{}` or `[]` don't extract any values and serve no practical purpose.",
+				"These patterns are likely mistakes or leftover code from refactoring.",
+			],
+			suggestions: [
+				"Remove the empty destructuring pattern if it's not needed.",
+				"Add bindings to extract values if you intended to destructure specific properties.",
+			],
+		},
+	},
+	setup(context) {
+		function checkBindingPattern(
+			node: ts.ArrayBindingPattern | ts.ObjectBindingPattern,
+		) {
+			if (node.elements.length === 0) {
+				context.report({
+					message: "emptyPattern",
+					range: {
+						begin: node.getStart(context.sourceFile),
+						end: node.getEnd(),
+					},
+				});
+			}
+		}
+
+		return {
+			visitors: {
+				ArrayBindingPattern: checkBindingPattern,
+				ObjectBindingPattern: checkBindingPattern,
+			},
+		};
+	},
+});

package/src/rules/emptyStaticBlocks.test.ts

@@ -0,0 +1,168 @@
+import rule from "./emptyStaticBlocks.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+class Example {
+    static {
+    }
+}
+`,
+			snapshot: `
+class Example {
+    static {
+    ~~~~~~~~
+    Empty static blocks serve no purpose and should be removed for cleaner code.
+    }
+}
+`,
+			suggestions: [
+				{
+					id: "removeEmptyStaticBlock",
+					updated: `
+class Example {
+    
+}
+`,
+				},
+			],
+		},
+		{
+			code: `
+class Example {
+    static {
+
+
+    }
+}
+`,
+			snapshot: `
+class Example {
+    static {
+    ~~~~~~~~
+    Empty static blocks serve no purpose and should be removed for cleaner code.
+
+
+    }
+}
+`,
+			suggestions: [
+				{
+					id: "removeEmptyStaticBlock",
+					updated: `
+class Example {
+    
+}
+`,
+				},
+			],
+		},
+		{
+			code: `
+class Multiple {
+    static property = 1;
+    
+    static {
+    }
+    
+    method() {}
+}
+`,
+			snapshot: `
+class Multiple {
+    static property = 1;
+    
+    static {
+    ~~~~~~~~
+    Empty static blocks serve no purpose and should be removed for cleaner code.
+    }
+    
+    method() {}
+}
+`,
+			suggestions: [
+				{
+					id: "removeEmptyStaticBlock",
+					updated: `
+class Multiple {
+    static property = 1;
+    
+    
+    
+    method() {}
+}
+`,
+				},
+			],
+		},
+		{
+			code: `
+class MultipleBlocks {
+    static {
+        console.log("first");
+    }
+    
+    static {
+    }
+}
+`,
+			snapshot: `
+class MultipleBlocks {
+    static {
+        console.log("first");
+    }
+    
+    static {
+    ~~~~~~~~
+    Empty static blocks serve no purpose and should be removed for cleaner code.
+    }
+}
+`,
+			suggestions: [
+				{
+					id: "removeEmptyStaticBlock",
+					updated: `
+class MultipleBlocks {
+    static {
+        console.log("first");
+    }
+    
+    
+}
+`,
+				},
+			],
+		},
+	],
+	valid: [
+		`class Example { static property = 1; }`,
+		`class Example { static method() {} }`,
+		`
+class Example {
+    static {
+        console.log("initialization");
+    }
+}
+`,
+		`
+class Example {
+    static {
+        this.property = 1;
+    }
+}
+`,
+		`
+class Multiple {
+    static {
+        console.log("first");
+    }
+    
+    static {
+        console.log("second");
+    }
+}
+`,
+	],
+});

package/src/rules/emptyStaticBlocks.ts

@@ -0,0 +1,60 @@
+import { typescriptLanguage } from "../language.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description:
+			"Reports empty static initialization blocks within class declarations.",
+		id: "emptyStaticBlocks",
+		preset: "stylistic",
+	},
+	messages: {
+		emptyStaticBlock: {
+			primary:
+				"Empty static blocks serve no purpose and should be removed for cleaner code.",
+			secondary: [
+				"Static blocks are used to initialize static class properties or perform other one-time setup when a class is loaded.",
+				"An empty static block has no statements and therefore serves no purpose.",
+			],
+			suggestions: [
+				"Remove the empty static block, or add initialization logic if needed.",
+			],
+		},
+	},
+	setup(context) {
+		return {
+			visitors: {
+				ClassStaticBlockDeclaration: (node) => {
+					const statements = node.body.statements;
+					if (statements.length) {
+						return;
+					}
+
+					const openBrace = node.body.getFirstToken(context.sourceFile);
+					if (!openBrace) {
+						return;
+					}
+
+					const range = {
+						begin: node.getStart(context.sourceFile),
+						end: openBrace.getEnd(),
+					};
+
+					context.report({
+						message: "emptyStaticBlock",
+						range,
+						suggestions: [
+							{
+								id: "removeEmptyStaticBlock",
+								range: {
+									begin: node.getStart(context.sourceFile),
+									end: node.getEnd(),
+								},
+								text: "",
+							},
+						],
+					});
+				},
+			},
+		};
+	},
+});

package/src/rules/exceptionAssignments.test.ts

@@ -0,0 +1,265 @@
+import rule from "./exceptionAssignments.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+try {
+    doSomething();
+} catch (error) {
+    error = new Error("Different error");
+}
+`,
+			snapshot: `
+try {
+    doSomething();
+} catch (error) {
+    error = new Error("Different error");
+    ~~~~~
+    Exception parameters in catch clauses should not be reassigned.
+}
+`,
+		},
+		{
+			code: `
+try {
+    doSomething();
+} catch (exception) {
+    exception = null;
+}
+`,
+			snapshot: `
+try {
+    doSomething();
+} catch (exception) {
+    exception = null;
+    ~~~~~~~~~
+    Exception parameters in catch clauses should not be reassigned.
+}
+`,
+		},
+		{
+			code: `
+try {
+    doSomething();
+} catch (error) {
+    error++;
+}
+`,
+			snapshot: `
+try {
+    doSomething();
+} catch (error) {
+    error++;
+    ~~~~~
+    Exception parameters in catch clauses should not be reassigned.
+}
+`,
+		},
+		{
+			code: `
+try {
+    doSomething();
+} catch (error) {
+    ++error;
+}
+`,
+			snapshot: `
+try {
+    doSomething();
+} catch (error) {
+    ++error;
+      ~~~~~
+      Exception parameters in catch clauses should not be reassigned.
+}
+`,
+		},
+		{
+			code: `
+try {
+    doSomething();
+} catch (error) {
+    error += "additional info";
+}
+`,
+			snapshot: `
+try {
+    doSomething();
+} catch (error) {
+    error += "additional info";
+    ~~~~~
+    Exception parameters in catch clauses should not be reassigned.
+}
+`,
+		},
+		{
+			code: `
+try {
+    doSomething();
+} catch (error) {
+    error ??= new Error("default error");
+}
+`,
+			snapshot: `
+try {
+    doSomething();
+} catch (error) {
+    error ??= new Error("default error");
+    ~~~~~
+    Exception parameters in catch clauses should not be reassigned.
+}
+`,
+		},
+		{
+			code: `
+try {
+    doSomething();
+} catch (error) {
+    error &&= false;
+}
+`,
+			snapshot: `
+try {
+    doSomething();
+} catch (error) {
+    error &&= false;
+    ~~~~~
+    Exception parameters in catch clauses should not be reassigned.
+}
+`,
+		},
+		{
+			code: `
+try {
+    doSomething();
+} catch (error) {
+    error ||= new Error("fallback");
+}
+`,
+			snapshot: `
+try {
+    doSomething();
+} catch (error) {
+    error ||= new Error("fallback");
+    ~~~~~
+    Exception parameters in catch clauses should not be reassigned.
+}
+`,
+		},
+		{
+			code: `
+try {
+    doSomething();
+} catch (error) {
+    function inner() {
+        error = "reassigned in nested function";
+    }
+}
+`,
+			snapshot: `
+try {
+    doSomething();
+} catch (error) {
+    function inner() {
+        error = "reassigned in nested function";
+        ~~~~~
+        Exception parameters in catch clauses should not be reassigned.
+    }
+}
+`,
+		},
+		{
+			code: `
+try {
+    doSomething();
+} catch ({ message }) {
+    message = "reassigned destructured parameter";
+}
+`,
+			snapshot: `
+try {
+    doSomething();
+} catch ({ message }) {
+    message = "reassigned destructured parameter";
+    ~~~~~~~
+    Exception parameters in catch clauses should not be reassigned.
+}
+`,
+		},
+		{
+			code: `
+try {
+    doSomething();
+} catch ({ message, code }) {
+    code = 500;
+}
+`,
+			snapshot: `
+try {
+    doSomething();
+} catch ({ message, code }) {
+    code = 500;
+    ~~~~
+    Exception parameters in catch clauses should not be reassigned.
+}
+`,
+		},
+		{
+			code: `
+try {
+    doSomething();
+} catch ([first, second]) {
+    first = "reassigned array destructured parameter";
+}
+`,
+			snapshot: `
+try {
+    doSomething();
+} catch ([first, second]) {
+    first = "reassigned array destructured parameter";
+    ~~~~~
+    Exception parameters in catch clauses should not be reassigned.
+}
+`,
+		},
+	],
+	valid: [
+		`try { doSomething(); } catch (error) { console.log(error); }`,
+		`try { doSomething(); } catch (error) { throw error; }`,
+		`try { doSomething(); } catch (error) { const message = error.message; }`,
+		`try { doSomething(); } catch (error) { if (error instanceof TypeError) { handle(); } }`,
+		`try { doSomething(); } catch { handleError(); }`,
+		`const error = new Error("test");`,
+		`
+try {
+    doSomething();
+} catch (error) {
+    const error = "shadowed variable";
+    console.log(error);
+}
+`,
+		`
+try {
+    doSomething();
+} catch (error) {
+    function inner() {
+        const error = "shadowed in function";
+        error = "reassigning shadowed variable is ok";
+    }
+}
+`,
+		`
+let error = "outer";
+try {
+    doSomething();
+} catch (error) {
+    console.log(error);
+}
+error = "reassigning outer is ok";
+`,
+		`try { doSomething(); } catch ({ message }) { console.log(message); }`,
+		`try { doSomething(); } catch ({ message, code }) { if (code === 404) { handle(); } }`,
+		`try { doSomething(); } catch ([first]) { console.log(first); }`,
+	],
+});