@flint.fyi/ts 0.14.2 → 0.14.4

package/lib/rules/emptyDestructures.test.js

@@ -0,0 +1,186 @@
+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/lib/rules/emptyStaticBlocks.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports empty static initialization blocks within class declarations.";
+    readonly id: "emptyStaticBlocks";
+    readonly preset: "stylistic";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "emptyStaticBlock", undefined>;
+export default _default;

package/lib/rules/emptyStaticBlocks.js

@@ -0,0 +1,54 @@
+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/lib/rules/emptyStaticBlocks.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/rules/emptyStaticBlocks.test.js

@@ -0,0 +1,167 @@
+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/lib/rules/exceptionAssignments.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports reassigning exception parameters in catch clauses.";
+    readonly id: "exceptionAssignments";
+    readonly preset: "logical";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noExAssign", undefined>;
+export default _default;

package/lib/rules/exceptionAssignments.js

@@ -0,0 +1,61 @@
+import * as ts from "typescript";
+import { typescriptLanguage } from "../language.js";
+import { getModifyingReferences } from "../utils/getModifyingReferences.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports reassigning exception parameters in catch clauses.",
+        id: "exceptionAssignments",
+        preset: "logical",
+    },
+    messages: {
+        noExAssign: {
+            primary: "Exception parameters in catch clauses should not be reassigned.",
+            secondary: [
+                "Reassigning an exception parameter can make debugging more difficult by obscuring the original error.",
+                "The exception parameter contains important information about what went wrong, and reassigning it can make it harder to understand the root cause of an error.",
+            ],
+            suggestions: [
+                "Use a different variable name for the new value instead of reassigning the exception parameter.",
+            ],
+        },
+    },
+    setup(context) {
+        function collectBindingElements(name) {
+            const identifiers = [];
+            if (ts.isIdentifier(name)) {
+                identifiers.push(name);
+            }
+            else if (ts.isObjectBindingPattern(name) ||
+                ts.isArrayBindingPattern(name)) {
+                for (const element of name.elements) {
+                    if (ts.isBindingElement(element)) {
+                        identifiers.push(...collectBindingElements(element.name));
+                    }
+                }
+            }
+            return identifiers;
+        }
+        return {
+            visitors: {
+                CatchClause: (node) => {
+                    if (!node.variableDeclaration?.name) {
+                        return;
+                    }
+                    const identifiers = collectBindingElements(node.variableDeclaration.name);
+                    for (const identifier of identifiers) {
+                        const modifyingReferences = getModifyingReferences(identifier, context.sourceFile, context.typeChecker);
+                        for (const reference of modifyingReferences) {
+                            context.report({
+                                message: "noExAssign",
+                                range: {
+                                    begin: reference.getStart(context.sourceFile),
+                                    end: reference.getEnd(),
+                                },
+                            });
+                        }
+                    }
+                },
+            },
+        };
+    },
+});

package/lib/rules/exceptionAssignments.test.d.ts

@@ -0,0 +1 @@
+export {};