@flint.fyi/ts 0.14.2 → 0.14.4

package/lib/rules/asyncPromiseExecutors.test.js

@@ -0,0 +1,71 @@
+import rule from "./asyncPromiseExecutors.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+new Promise(async (resolve, reject) => {
+    resolve(42);
+});
+`,
+            snapshot: `
+new Promise(async (resolve, reject) => {
+            ~~~~~
+            Async Promise executor functions are not able to properly catch thrown errors and often indicate unnecessarily complex logic.
+    resolve(42);
+});
+`,
+        },
+        {
+            code: `
+new Promise(async function(resolve, reject) {
+    resolve(42);
+});
+`,
+            snapshot: `
+new Promise(async function(resolve, reject) {
+            ~~~~~
+            Async Promise executor functions are not able to properly catch thrown errors and often indicate unnecessarily complex logic.
+    resolve(42);
+});
+`,
+        },
+        {
+            code: `
+const p = new Promise(async (resolve) => {
+    resolve();
+});
+`,
+            snapshot: `
+const p = new Promise(async (resolve) => {
+                      ~~~~~
+                      Async Promise executor functions are not able to properly catch thrown errors and often indicate unnecessarily complex logic.
+    resolve();
+});
+`,
+        },
+    ],
+    valid: [
+        `
+new Promise((resolve, reject) => {
+    resolve(42);
+});
+`,
+        `
+new Promise(function(resolve, reject) {
+    resolve(42);
+});
+`,
+        `
+const p = new Promise((resolve) => {
+    doSomething().then(resolve);
+});
+`,
+        `
+// Not a Promise constructor
+new SomethingElse(async (resolve) => {
+    resolve();
+});
+`,
+    ],
+});

package/lib/rules/caseDeclarations.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports lexical declarations in case clauses without wrapping them in blocks.";
+    readonly id: "caseDeclarations";
+    readonly preset: "untyped";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "unexpectedLexicalDeclaration", undefined>;
+export default _default;

package/lib/rules/caseDeclarations.js

@@ -0,0 +1,53 @@
+import * as tsutils from "ts-api-utils";
+import * as ts from "typescript";
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports lexical declarations in case clauses without wrapping them in blocks.",
+        id: "caseDeclarations",
+        preset: "untyped",
+    },
+    messages: {
+        unexpectedLexicalDeclaration: {
+            primary: "Variables declared in case clauses without braces leak into the surrounding scope.",
+            secondary: [
+                "Lexical declarations (let, const, function, class) are scoped to the entire switch statement, not just the case clause where they are declared.",
+                "This can lead to unexpected behavior when the same variable name is used in multiple case clauses, as they will conflict in the same scope.",
+            ],
+            suggestions: [
+                "Wrap the case clause contents in curly braces {} to create a block scope.",
+            ],
+        },
+    },
+    setup(context) {
+        function getLexicalDeclaration(statements) {
+            for (const statement of statements) {
+                if (ts.isVariableStatement(statement) &&
+                    tsutils.isNodeFlagSet(statement.declarationList, ts.NodeFlags.Let | ts.NodeFlags.Const)) {
+                    return statement.declarationList.getChildAt(0, context.sourceFile);
+                }
+                if (ts.isClassDeclaration(statement) ||
+                    ts.isFunctionDeclaration(statement)) {
+                    return statement.getChildAt(0, context.sourceFile);
+                }
+            }
+            return undefined;
+        }
+        function checkClause(node) {
+            const declarationNode = getLexicalDeclaration(node.statements);
+            if (declarationNode) {
+                context.report({
+                    message: "unexpectedLexicalDeclaration",
+                    range: getTSNodeRange(declarationNode, context.sourceFile),
+                });
+            }
+        }
+        return {
+            visitors: {
+                CaseClause: checkClause,
+                DefaultClause: checkClause,
+            },
+        };
+    },
+});

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

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

package/lib/rules/caseDeclarations.test.js

@@ -0,0 +1,227 @@
+import rule from "./caseDeclarations.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+switch (value) {
+    case 1:
+        let x = 1;
+        break;
+}
+`,
+            snapshot: `
+switch (value) {
+    case 1:
+        let x = 1;
+        ~~~
+        Variables declared in case clauses without braces leak into the surrounding scope.
+        break;
+}
+`,
+        },
+        {
+            code: `
+switch (value) {
+    case 1:
+        const x = 1;
+        break;
+}
+`,
+            snapshot: `
+switch (value) {
+    case 1:
+        const x = 1;
+        ~~~~~
+        Variables declared in case clauses without braces leak into the surrounding scope.
+        break;
+}
+`,
+        },
+        {
+            code: `
+switch (value) {
+    case 1:
+        function foo() {}
+        break;
+}
+`,
+            snapshot: `
+switch (value) {
+    case 1:
+        function foo() {}
+        ~~~~~~~~
+        Variables declared in case clauses without braces leak into the surrounding scope.
+        break;
+}
+`,
+        },
+        {
+            code: `
+switch (value) {
+    case 1:
+        class Foo {}
+        break;
+}
+`,
+            snapshot: `
+switch (value) {
+    case 1:
+        class Foo {}
+        ~~~~~
+        Variables declared in case clauses without braces leak into the surrounding scope.
+        break;
+}
+`,
+        },
+        {
+            code: `
+switch (value) {
+    default:
+        let x = 1;
+        break;
+}
+`,
+            snapshot: `
+switch (value) {
+    default:
+        let x = 1;
+        ~~~
+        Variables declared in case clauses without braces leak into the surrounding scope.
+        break;
+}
+`,
+        },
+        {
+            code: `
+switch (value) {
+    default:
+        const x = 1;
+        break;
+}
+`,
+            snapshot: `
+switch (value) {
+    default:
+        const x = 1;
+        ~~~~~
+        Variables declared in case clauses without braces leak into the surrounding scope.
+        break;
+}
+`,
+        },
+        {
+            code: `
+switch (value) {
+    case 1:
+        let x = 1;
+    case 2:
+        let y = 2;
+        break;
+}
+`,
+            snapshot: `
+switch (value) {
+    case 1:
+        let x = 1;
+        ~~~
+        Variables declared in case clauses without braces leak into the surrounding scope.
+    case 2:
+        let y = 2;
+        ~~~
+        Variables declared in case clauses without braces leak into the surrounding scope.
+        break;
+}
+`,
+        },
+        {
+            code: `
+switch (value) {
+    case 1:
+        const x = 1;
+        console.log(x);
+        break;
+}
+`,
+            snapshot: `
+switch (value) {
+    case 1:
+        const x = 1;
+        ~~~~~
+        Variables declared in case clauses without braces leak into the surrounding scope.
+        console.log(x);
+        break;
+}
+`,
+        },
+    ],
+    valid: [
+        `switch (value) { case 1: { let x = 1; break; } }`,
+        `switch (value) { case 1: { const x = 1; break; } }`,
+        `switch (value) { case 1: { function foo() {} break; } }`,
+        `switch (value) { case 1: { class Foo {} break; } }`,
+        `switch (value) { default: { let x = 1; break; } }`,
+        `switch (value) { default: { const x = 1; break; } }`,
+        `switch (value) { case 1: var x = 1; break; }`,
+        `switch (value) { case 1: break; }`,
+        `switch (value) { case 1: console.log("test"); break; }`,
+        `
+switch (value) {
+    case 1: {
+        let x = 1;
+        break;
+    }
+}
+`,
+        `
+switch (value) {
+    case 1: {
+        const x = 1;
+        break;
+    }
+}
+`,
+        `
+switch (value) {
+    case 1: {
+        function foo() {}
+        break;
+    }
+}
+`,
+        `
+switch (value) {
+    case 1: {
+        class Foo {}
+        break;
+    }
+}
+`,
+        `
+switch (value) {
+    case 1:
+        var x = 1;
+        break;
+}
+`,
+        `
+switch (value) {
+    case 1: {
+        let x = 1;
+    }
+    case 2: {
+        let y = 2;
+        break;
+    }
+}
+`,
+        `
+switch (value) {
+    default: {
+        let x = 1;
+        break;
+    }
+}
+`,
+    ],
+});

package/lib/rules/caseDuplicates.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports switch statements with duplicate case clause test expressions.";
+    readonly id: "caseDuplicates";
+    readonly preset: "logical";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "duplicateCase", undefined>;
+export default _default;

package/lib/rules/caseDuplicates.js

@@ -0,0 +1,49 @@
+import * as ts from "typescript";
+import { typescriptLanguage } from "../language.js";
+import { hasSameTokens } from "../utils/hasSameTokens.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports switch statements with duplicate case clause test expressions.",
+        id: "caseDuplicates",
+        preset: "logical",
+    },
+    messages: {
+        duplicateCase: {
+            primary: "This case duplicates a previous case, so it will never be reached.",
+            secondary: [
+                "Having duplicate case clauses in a switch statement is a logic error.",
+                "The second case clause will never be reached because the first matching case will always execute first.",
+            ],
+            suggestions: [
+                "Remove the duplicate case clause or modify its test expression to be unique.",
+            ],
+        },
+    },
+    setup(context) {
+        return {
+            visitors: {
+                SwitchStatement: (node) => {
+                    const seenCases = [];
+                    for (const clause of node.caseBlock.clauses) {
+                        if (!ts.isCaseClause(clause)) {
+                            continue;
+                        }
+                        const isDuplicate = seenCases.some((seenCase) => hasSameTokens(seenCase, clause.expression, context.sourceFile));
+                        if (isDuplicate) {
+                            context.report({
+                                message: "duplicateCase",
+                                range: {
+                                    begin: clause.getStart(context.sourceFile),
+                                    end: clause.expression.getEnd(),
+                                },
+                            });
+                        }
+                        else {
+                            seenCases.push(clause.expression);
+                        }
+                    }
+                },
+            },
+        };
+    },
+});

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

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