@flint.fyi/ts 0.14.1 → 0.14.3

package/lib/rules/debuggerStatements.test.js

@@ -0,0 +1,80 @@
+import rule from "./debuggerStatements.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+debugger;
+`,
+            snapshot: `
+debugger;
+~~~~~~~~~
+Debugger statements should not be used in production code.
+`,
+            suggestions: [
+                {
+                    id: "removeDebugger",
+                    updated: `
+
+`,
+                },
+            ],
+        },
+        {
+            code: `
+function test() {
+	debugger;
+}
+`,
+            snapshot: `
+function test() {
+	debugger;
+ ~~~~~~~~~
+ Debugger statements should not be used in production code.
+}
+`,
+            suggestions: [
+                {
+                    id: "removeDebugger",
+                    updated: `
+function test() {
+	
+}
+`,
+                },
+            ],
+        },
+        {
+            code: `
+if (condition) {
+	debugger;
+}
+`,
+            snapshot: `
+if (condition) {
+	debugger;
+ ~~~~~~~~~
+ Debugger statements should not be used in production code.
+}
+`,
+            suggestions: [
+                {
+                    id: "removeDebugger",
+                    updated: `
+if (condition) {
+	
+}
+`,
+                },
+            ],
+        },
+    ],
+    valid: [
+        `console.log("debugging");`,
+        `function test() { console.log("test"); }`,
+        `for (let i = 0; i < 10; i++) { break; }`,
+        `for (let i = 0; i < 10; i++) { continue; }`,
+        `function test() { return; }`,
+        `throw new Error("test");`,
+    ],
+});

package/lib/rules/defaultCaseLast.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports switch statements where the default clause is not last.";
+    readonly id: "defaultCaseLast";
+    readonly preset: "logical";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "defaultCaseShouldBeLast", undefined>;
+export default _default;

package/lib/rules/defaultCaseLast.js

@@ -0,0 +1,43 @@
+import * as ts from "typescript";
+import { typescriptLanguage } from "../language.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports switch statements where the default clause is not last.",
+        id: "defaultCaseLast",
+        preset: "logical",
+    },
+    messages: {
+        defaultCaseShouldBeLast: {
+            primary: "Default clauses in switch statements should be last.",
+            secondary: [
+                "Placing the default clause in a position other than last can lead to confusion and unexpected behavior.",
+                "While the default clause is executed when no case matches, having it in the middle of other cases makes the control flow harder to follow.",
+            ],
+            suggestions: [
+                "Move the default clause to the end of the switch statement to improve code clarity.",
+            ],
+        },
+    },
+    setup(context) {
+        return {
+            visitors: {
+                SwitchStatement: (node) => {
+                    const clauses = node.caseBlock.clauses;
+                    const defaultClauseIndex = clauses.findIndex((clause) => clause.kind === ts.SyntaxKind.DefaultClause);
+                    if (defaultClauseIndex === -1 ||
+                        defaultClauseIndex === clauses.length - 1) {
+                        return;
+                    }
+                    const defaultClause = clauses[defaultClauseIndex];
+                    context.report({
+                        message: "defaultCaseShouldBeLast",
+                        range: {
+                            begin: defaultClause.getStart(context.sourceFile),
+                            end: defaultClause.getStart(context.sourceFile) + "default".length,
+                        },
+                    });
+                },
+            },
+        };
+    },
+});

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

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

package/lib/rules/defaultCaseLast.test.js

@@ -0,0 +1,195 @@
+import rule from "./defaultCaseLast.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+switch (value) {
+    default:
+        break;
+    case 1:
+        break;
+}
+`,
+            snapshot: `
+switch (value) {
+    default:
+    ~~~~~~~
+    Default clauses in switch statements should be last.
+        break;
+    case 1:
+        break;
+}
+`,
+        },
+        {
+            code: `
+switch (value) {
+    case 1:
+        break;
+    default:
+        break;
+    case 2:
+        break;
+}
+`,
+            snapshot: `
+switch (value) {
+    case 1:
+        break;
+    default:
+    ~~~~~~~
+    Default clauses in switch statements should be last.
+        break;
+    case 2:
+        break;
+}
+`,
+        },
+        {
+            code: `
+switch (value) {
+    case 1:
+    case 2:
+        break;
+    default:
+        break;
+    case 3:
+        break;
+}
+`,
+            snapshot: `
+switch (value) {
+    case 1:
+    case 2:
+        break;
+    default:
+    ~~~~~~~
+    Default clauses in switch statements should be last.
+        break;
+    case 3:
+        break;
+}
+`,
+        },
+        {
+            code: `
+switch (value) {
+    default:
+        console.log("default");
+        break;
+    case 1:
+        console.log("one");
+        break;
+}
+`,
+            snapshot: `
+switch (value) {
+    default:
+    ~~~~~~~
+    Default clauses in switch statements should be last.
+        console.log("default");
+        break;
+    case 1:
+        console.log("one");
+        break;
+}
+`,
+        },
+        {
+            code: `
+const result = (value: number) => {
+    switch (value) {
+        case 1:
+            return "one";
+        default:
+            return "default";
+        case 2:
+            return "two";
+    }
+};
+`,
+            snapshot: `
+const result = (value: number) => {
+    switch (value) {
+        case 1:
+            return "one";
+        default:
+        ~~~~~~~
+        Default clauses in switch statements should be last.
+            return "default";
+        case 2:
+            return "two";
+    }
+};
+`,
+        },
+        {
+            code: `
+switch (value) {
+    default:
+    case 1:
+        break;
+}
+`,
+            snapshot: `
+switch (value) {
+    default:
+    ~~~~~~~
+    Default clauses in switch statements should be last.
+    case 1:
+        break;
+}
+`,
+        },
+    ],
+    valid: [
+        `switch (value) { case 1: break; default: break; }`,
+        `switch (value) { case 1: break; case 2: break; default: break; }`,
+        `switch (value) { case 1: break; case 2: break; }`,
+        `switch (value) { default: break; }`,
+        `switch (value) { case 1: case 2: break; default: break; }`,
+        `
+switch (value) {
+    case 1:
+        break;
+    default:
+        break;
+}
+`,
+        `
+switch (value) {
+    case 1:
+        console.log("one");
+        break;
+    case 2:
+        console.log("two");
+        break;
+    default:
+        console.log("default");
+        break;
+}
+`,
+        `
+const result = (value: number) => {
+    switch (value) {
+        case 1:
+            return "one";
+        case 2:
+            return "two";
+        default:
+            return "default";
+    }
+};
+`,
+        `
+switch (value) {
+    case 1:
+    case 2:
+        break;
+    default:
+        break;
+}
+`,
+    ],
+});

package/lib/rules/duplicateArguments.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports functions with duplicate parameter names in their signatures.";
+    readonly id: "duplicateArguments";
+    readonly preset: "untyped";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "duplicateParam", undefined>;
+export default _default;

package/lib/rules/duplicateArguments.js

@@ -0,0 +1,51 @@
+import * as ts from "typescript";
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports functions with duplicate parameter names in their signatures.",
+        id: "duplicateArguments",
+        preset: "untyped",
+    },
+    messages: {
+        duplicateParam: {
+            primary: "This parameter overrides the previous parameter of the same name.",
+            secondary: [
+                "Duplicate parameter names in functions can lead to unexpected behavior and make code harder to understand.",
+                "In strict mode, duplicate parameter names are a syntax error.",
+                "Even in non-strict mode, only the last parameter with a given name is accessible.",
+            ],
+            suggestions: ["Rename one of the duplicate parameters to a unique name."],
+        },
+    },
+    setup(context) {
+        function checkNode({ parameters }) {
+            const seenNames = new Set();
+            for (const parameter of parameters) {
+                if (!ts.isIdentifier(parameter.name)) {
+                    continue;
+                }
+                const parameterName = parameter.name.text;
+                const existingParameter = seenNames.has(parameterName);
+                if (existingParameter) {
+                    context.report({
+                        message: "duplicateParam",
+                        range: getTSNodeRange(parameter.name, context.sourceFile),
+                    });
+                }
+                else {
+                    seenNames.add(parameterName);
+                }
+            }
+        }
+        return {
+            visitors: {
+                ArrowFunction: checkNode,
+                Constructor: checkNode,
+                FunctionDeclaration: checkNode,
+                FunctionExpression: checkNode,
+                MethodDeclaration: checkNode,
+            },
+        };
+    },
+});

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

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

package/lib/rules/duplicateArguments.test.js

@@ -0,0 +1,139 @@
+import rule from "./duplicateArguments.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+function test(value, value) {
+    return value;
+}
+`,
+            snapshot: `
+function test(value, value) {
+                     ~~~~~
+                     This parameter overrides the previous parameter of the same name.
+    return value;
+}
+`,
+        },
+        {
+            code: `
+function test(first, second, first) {
+    return first + second;
+}
+`,
+            snapshot: `
+function test(first, second, first) {
+                             ~~~~~
+                             This parameter overrides the previous parameter of the same name.
+    return first + second;
+}
+`,
+        },
+        {
+            code: `
+const arrow = (value, value) => value;
+`,
+            snapshot: `
+const arrow = (value, value) => value;
+                      ~~~~~
+                      This parameter overrides the previous parameter of the same name.
+`,
+        },
+        {
+            code: `
+const func = function (value, value) {
+    return value;
+};
+`,
+            snapshot: `
+const func = function (value, value) {
+                              ~~~~~
+                              This parameter overrides the previous parameter of the same name.
+    return value;
+};
+`,
+        },
+        {
+            code: `
+class Example {
+    method(value, value) {
+        return value;
+    }
+}
+`,
+            snapshot: `
+class Example {
+    method(value, value) {
+                  ~~~~~
+                  This parameter overrides the previous parameter of the same name.
+        return value;
+    }
+}
+`,
+        },
+        {
+            code: `
+class Example {
+    constructor(value, value) {
+        this.value = value;
+    }
+}
+`,
+            snapshot: `
+class Example {
+    constructor(value, value) {
+                       ~~~~~
+                       This parameter overrides the previous parameter of the same name.
+        this.value = value;
+    }
+}
+`,
+        },
+        {
+            code: `
+function test(first, second, third, second) {
+    return first + second + third;
+}
+`,
+            snapshot: `
+function test(first, second, third, second) {
+                                    ~~~~~~
+                                    This parameter overrides the previous parameter of the same name.
+    return first + second + third;
+}
+`,
+        },
+        {
+            code: `
+function test(value, value, value) {
+    return value;
+}
+`,
+            snapshot: `
+function test(value, value, value) {
+                     ~~~~~
+                     This parameter overrides the previous parameter of the same name.
+                            ~~~~~
+                            This parameter overrides the previous parameter of the same name.
+    return value;
+}
+`,
+        },
+    ],
+    valid: [
+        `function test(value) { return value; }`,
+        `function test(first, second) { return first + second; }`,
+        `const arrow = (value) => value;`,
+        `const arrow = (first, second) => first + second;`,
+        `const func = function (value) { return value; };`,
+        `const func = function (first, second) { return first + second; };`,
+        `class Example { method(value) { return value; } }`,
+        `class Example { method(first, second) { return first + second; } }`,
+        `class Example { constructor(value) { this.value = value; } }`,
+        `class Example { constructor(first, second) { this.first = first; this.second = second; } }`,
+        `function test({ value }) { return value; }`,
+        `function test({ first, second }) { return first + second; }`,
+        `function test([first, second]) { return first + second; }`,
+    ],
+});

package/lib/rules/emptyDestructures.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using empty destructuring patterns that destructure no values.";
+    readonly id: "emptyDestructures";
+    readonly preset: "logical";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "emptyPattern", undefined>;
+export default _default;

package/lib/rules/emptyDestructures.js

@@ -0,0 +1,40 @@
+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) {
+            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/lib/rules/emptyDestructures.test.d.ts

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