@flint.fyi/ts 0.14.3 → 0.14.5

package/lib/rules/caseDuplicates.test.js

@@ -0,0 +1,307 @@
+import rule from "./caseDuplicates.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+switch (value) {
+    case 1:
+        break;
+    case 1:
+        break;
+}
+`,
+            snapshot: `
+switch (value) {
+    case 1:
+        break;
+    case 1:
+    ~~~~~~
+    This case duplicates a previous case, so it will never be reached.
+        break;
+}
+`,
+        },
+        {
+            code: `
+switch (value) {
+    case "a":
+        break;
+    case "b":
+        break;
+    case "a":
+        break;
+}
+`,
+            snapshot: `
+switch (value) {
+    case "a":
+        break;
+    case "b":
+        break;
+    case "a":
+    ~~~~~~~~
+    This case duplicates a previous case, so it will never be reached.
+        break;
+}
+`,
+        },
+        {
+            code: `
+switch (value) {
+    case x + 1:
+        break;
+    case x + 1:
+        break;
+}
+`,
+            snapshot: `
+switch (value) {
+    case x + 1:
+        break;
+    case x + 1:
+    ~~~~~~~~~~
+    This case duplicates a previous case, so it will never be reached.
+        break;
+}
+`,
+        },
+        {
+            code: `
+switch (value) {
+    case 1:
+        break;
+    case 2:
+        break;
+    case 1:
+        break;
+}
+`,
+            snapshot: `
+switch (value) {
+    case 1:
+        break;
+    case 2:
+        break;
+    case 1:
+    ~~~~~~
+    This case duplicates a previous case, so it will never be reached.
+        break;
+}
+`,
+        },
+        {
+            code: `
+switch (value) {
+    case true:
+        break;
+    case false:
+        break;
+    case true:
+        break;
+}
+`,
+            snapshot: `
+switch (value) {
+    case true:
+        break;
+    case false:
+        break;
+    case true:
+    ~~~~~~~~~
+    This case duplicates a previous case, so it will never be reached.
+        break;
+}
+`,
+        },
+        {
+            code: `
+switch (value) {
+    case obj.property:
+        break;
+    case obj.property:
+        break;
+}
+`,
+            snapshot: `
+switch (value) {
+    case obj.property:
+        break;
+    case obj.property:
+    ~~~~~~~~~~~~~~~~~
+    This case duplicates a previous case, so it will never be reached.
+        break;
+}
+`,
+        },
+        {
+            code: `
+const result = (input: number) => {
+    switch (input) {
+        case 1:
+            return "one";
+        case 2:
+            return "two";
+        case 1:
+            return "duplicate";
+    }
+};
+`,
+            snapshot: `
+const result = (input: number) => {
+    switch (input) {
+        case 1:
+            return "one";
+        case 2:
+            return "two";
+        case 1:
+        ~~~~~~
+        This case duplicates a previous case, so it will never be reached.
+            return "duplicate";
+    }
+};
+`,
+        },
+        {
+            code: `
+switch (value) {
+    case 1: case 1: break;
+}
+`,
+            snapshot: `
+switch (value) {
+    case 1: case 1: break;
+            ~~~~~~
+            This case duplicates a previous case, so it will never be reached.
+}
+`,
+        },
+        {
+            code: `
+const condition = true;
+switch (value) {
+    case condition ? "a" : "b":
+        break;
+    case condition ? "a" : "b":
+        break;
+}
+`,
+            snapshot: `
+const condition = true;
+switch (value) {
+    case condition ? "a" : "b":
+        break;
+    case condition ? "a" : "b":
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~
+    This case duplicates a previous case, so it will never be reached.
+        break;
+}
+`,
+        },
+        {
+            code: `
+switch (value) {
+    case /* comment */ 1:
+        break;
+    case 1:
+        break;
+}
+`,
+            snapshot: `
+switch (value) {
+    case /* comment */ 1:
+        break;
+    case 1:
+    ~~~~~~
+    This case duplicates a previous case, so it will never be reached.
+        break;
+}
+`,
+        },
+        {
+            code: `
+switch (value) {
+    case obj.property:
+        break;
+    case obj /* comment */ .property:
+        break;
+}
+`,
+            snapshot: `
+switch (value) {
+    case obj.property:
+        break;
+    case obj /* comment */ .property:
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    This case duplicates a previous case, so it will never be reached.
+        break;
+}
+`,
+        },
+    ],
+    valid: [
+        `switch (value) { case 1: break; case 2: break; }`,
+        `switch (value) { case 1: break; case 2: break; case 3: break; }`,
+        `switch (value) { case "a": break; case "b": break; }`,
+        `switch (value) { case true: break; case false: break; }`,
+        `switch (value) { case 1: case 2: break; }`,
+        `switch (value) { default: break; }`,
+        `
+switch (value) {
+    case 1:
+        break;
+    case 2:
+        break;
+}
+`,
+        `
+switch (value) {
+    case x:
+        break;
+    case y:
+        break;
+}
+`,
+        `
+switch (value) {
+    case obj.a:
+        break;
+    case obj.b:
+        break;
+}
+`,
+        `
+switch (value) {
+    case 1:
+        console.log("one");
+        break;
+    case 2:
+        console.log("two");
+        break;
+    default:
+        console.log("default");
+        break;
+}
+`,
+        `
+switch (value) {
+    case x + 1:
+        break;
+    case x + 2:
+        break;
+}
+`,
+        `
+const result = (input: number) => {
+    switch (input) {
+        case 1:
+            return "one";
+        case 2:
+            return "two";
+        default:
+            return "unknown";
+    }
+};
+`,
+    ],
+});

package/lib/rules/chainedAssignments.js

@@ -30,7 +30,8 @@ export default typescriptLanguage.createRule({
                         return;
                     }
                     const rightSide = unwrapParenthesizedExpression(node.right);
-                    if (!ts.isBinaryExpression(rightSide)) {
+                    if (!ts.isBinaryExpression(rightSide) ||
+                        !tsutils.isAssignmentKind(rightSide.operatorToken.kind)) {
                         return;
                     }
                     const parent = unwrapParenthesizedExpressionsParent(node);

package/lib/rules/chainedAssignments.test.js

@@ -233,6 +233,30 @@ class MyClass {
         second = 0;
     }
 }
+`,
+        `
+let result = "";
+result += "a" + "b";
+`,
+        `
+let result = 0;
+result += 1 + 2;
+`,
+        `
+let result = 0;
+result += 1 * 2;
+`,
+        `
+let result = 0;
+result += 1 - 2;
+`,
+        `
+let result = 0;
+result += 1 / 2;
+`,
+        `
+let result = 0;
+result += 1 ** 2;
 `,
     ],
 });

package/lib/rules/debuggerStatements.test.js

@@ -29,8 +29,8 @@ function test() {
             snapshot: `
 function test() {
 	debugger;
- ~~~~~~~~~
- Debugger statements should not be used in production code.
+	~~~~~~~~~
+	Debugger statements should not be used in production code.
 }
 `,
             suggestions: [
@@ -53,8 +53,8 @@ if (condition) {
             snapshot: `
 if (condition) {
 	debugger;
- ~~~~~~~~~
- Debugger statements should not be used in production code.
+	~~~~~~~~~
+	Debugger statements should not be used in production code.
 }
 `,
             suggestions: [

package/lib/rules/elseIfDuplicates.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports duplicate conditions in if-else-if chains that make code unreachable.";
+    readonly id: "elseIfDuplicates";
+    readonly preset: "logical";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "duplicateCondition", undefined>;
+export default _default;

package/lib/rules/elseIfDuplicates.js

@@ -0,0 +1,53 @@
+import * as ts from "typescript";
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+import { hasSameTokens } from "../utils/hasSameTokens.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports duplicate conditions in if-else-if chains that make code unreachable.",
+        id: "elseIfDuplicates",
+        preset: "logical",
+    },
+    messages: {
+        duplicateCondition: {
+            primary: "This condition is identical to a previous condition in the if-else-if chain.",
+            secondary: [
+                "When an if-else-if chain has duplicate conditions, the duplicate branch will never execute because the earlier identical condition will always be evaluated first.",
+                "This typically indicates a copy-paste error or logic mistake.",
+            ],
+            suggestions: [
+                "Verify the condition logic is correct and update to check for the intended condition.",
+            ],
+        },
+    },
+    setup(context) {
+        function checkIfStatement(node) {
+            const seen = [];
+            let current = node;
+            while (true) {
+                if (seen.some((previous) => hasSameTokens(previous, current.expression, context.sourceFile))) {
+                    context.report({
+                        message: "duplicateCondition",
+                        range: getTSNodeRange(current.expression, context.sourceFile),
+                    });
+                }
+                if (!current.elseStatement ||
+                    !ts.isIfStatement(current.elseStatement)) {
+                    break;
+                }
+                seen.push(current.expression);
+                current = current.elseStatement;
+            }
+        }
+        return {
+            visitors: {
+                IfStatement: (node) => {
+                    if (!ts.isIfStatement(node.parent) ||
+                        node.parent.elseStatement !== node) {
+                        checkIfStatement(node);
+                    }
+                },
+            },
+        };
+    },
+});

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

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

package/lib/rules/elseIfDuplicates.test.js

@@ -0,0 +1,176 @@
+import rule from "./elseIfDuplicates.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+if (isSomething(value)) {
+    doFirst();
+} else if (isSomething(value)) {
+    doSecond();
+}
+`,
+            snapshot: `
+if (isSomething(value)) {
+    doFirst();
+} else if (isSomething(value)) {
+           ~~~~~~~~~~~~~~~~~~
+           This condition is identical to a previous condition in the if-else-if chain.
+    doSecond();
+}
+`,
+        },
+        {
+            code: `
+if (isSomething /* ... */ (value)) {
+    doFirst();
+} else if (isSomething(value /* ... */)) {
+    doSecond();
+}
+`,
+            snapshot: `
+if (isSomething /* ... */ (value)) {
+    doFirst();
+} else if (isSomething(value /* ... */)) {
+           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+           This condition is identical to a previous condition in the if-else-if chain.
+    doSecond();
+}
+`,
+        },
+        {
+            code: `
+if (first) {
+    handleFirst();
+} else if (second) {
+    handleSecond();
+} else if (third && fourth) {
+    handleThird();
+} else if (third && fourth) {
+    handleFourth();
+}
+`,
+            snapshot: `
+if (first) {
+    handleFirst();
+} else if (second) {
+    handleSecond();
+} else if (third && fourth) {
+    handleThird();
+} else if (third && fourth) {
+           ~~~~~~~~~~~~~~~
+           This condition is identical to a previous condition in the if-else-if chain.
+    handleFourth();
+}
+`,
+        },
+        {
+            code: `
+if (count === 1) {
+    handleOne();
+} else if (count === 2) {
+    handleTwo();
+} else if (count === 3) {
+    handleThree();
+} else if (count === 2) {
+    handleFour();
+} else if (count === 5) {
+    handleFive();
+}
+`,
+            snapshot: `
+if (count === 1) {
+    handleOne();
+} else if (count === 2) {
+    handleTwo();
+} else if (count === 3) {
+    handleThree();
+} else if (count === 2) {
+           ~~~~~~~~~~~
+           This condition is identical to a previous condition in the if-else-if chain.
+    handleFour();
+} else if (count === 5) {
+    handleFive();
+}
+`,
+        },
+        {
+            code: `
+if (value === "first") {
+    process();
+} else if (value === "second") {
+    process();
+} else if (value === "first") {
+    process();
+}
+`,
+            snapshot: `
+if (value === "first") {
+    process();
+} else if (value === "second") {
+    process();
+} else if (value === "first") {
+           ~~~~~~~~~~~~~~~~~
+           This condition is identical to a previous condition in the if-else-if chain.
+    process();
+}
+`,
+        },
+        {
+            code: `
+if (isValid && isActive) {
+    execute();
+} else if (isPending) {
+    wait();
+} else if (isValid && isActive) {
+    execute();
+}
+`,
+            snapshot: `
+if (isValid && isActive) {
+    execute();
+} else if (isPending) {
+    wait();
+} else if (isValid && isActive) {
+           ~~~~~~~~~~~~~~~~~~~
+           This condition is identical to a previous condition in the if-else-if chain.
+    execute();
+}
+`,
+        },
+        {
+            code: `
+if (value) {
+    first();
+} else if (value) {
+    second();
+} else if (value) {
+    third();
+}
+`,
+            snapshot: `
+if (value) {
+    first();
+} else if (value) {
+           ~~~~~
+           This condition is identical to a previous condition in the if-else-if chain.
+    second();
+} else if (value) {
+           ~~~~~
+           This condition is identical to a previous condition in the if-else-if chain.
+    third();
+}
+`,
+        },
+    ],
+    valid: [
+        `if (isSomething(value)) { doFirst(); } else if (isSomethingElse(value)) { doSecond(); }`,
+        `if (first) { handleFirst(); } else if (second) { handleSecond(); } else if (third && fourth) { handleThird(); } else if (third && fifth) { handleFourth(); }`,
+        `if (count === 1) { handleOne(); } else if (count === 2) { handleTwo(); } else if (count === 3) { handleThree(); } else if (count === 4) { handleFour(); }`,
+        `if (value === "first") { process(); } else if (value === "second") { process(); } else if (value === "third") { process(); }`,
+        `if (isValid) { execute(); } else if (isPending) { wait(); } else if (isInvalid) { reject(); }`,
+        `if (value) { process(); }`,
+        `if (first) { doFirst(); } else { doSecond(); }`,
+        `if (first) { doFirst(); } else if (second) { doSecond(); } else { doDefault(); }`,
+    ],
+});

package/lib/rules/emptyBlocks.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports empty block statements that should contain code.";
+    readonly id: "emptyBlocks";
+    readonly preset: "stylistic";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "emptyBlock", undefined>;
+export default _default;

package/lib/rules/emptyBlocks.js

@@ -0,0 +1,66 @@
+import * as ts from "typescript";
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+const allowedParents = new Set([
+    ts.SyntaxKind.ArrowFunction,
+    ts.SyntaxKind.CatchClause,
+    ts.SyntaxKind.Constructor,
+    ts.SyntaxKind.FunctionDeclaration,
+    ts.SyntaxKind.FunctionExpression,
+    ts.SyntaxKind.GetAccessor,
+    ts.SyntaxKind.MethodDeclaration,
+    ts.SyntaxKind.SetAccessor,
+]);
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports empty block statements that should contain code.",
+        id: "emptyBlocks",
+        preset: "stylistic",
+    },
+    messages: {
+        emptyBlock: {
+            primary: "Empty block statements should be removed or contain code.",
+            secondary: [
+                "Empty blocks can indicate incomplete code or areas where logic was removed but the block structure was left behind.",
+                "They can also reduce code readability by cluttering the codebase with unnecessary braces.",
+            ],
+            suggestions: [
+                "Add a comment explaining why the block is intentionally empty, or remove the empty block entirely.",
+            ],
+        },
+    },
+    setup(context) {
+        function hasComments(block) {
+            const fullText = context.sourceFile.getFullText();
+            const openBrace = block.getStart(context.sourceFile);
+            const closeBrace = block.getEnd();
+            const innerText = fullText.substring(openBrace + 1, closeBrace - 1);
+            // Check if there are any non-whitespace characters (which would be comments)
+            // since we already know there are no statements
+            return /\S+/.test(innerText.trim());
+        }
+        function isEmptyBlock(block) {
+            return block.statements.length === 0 && !hasComments(block);
+        }
+        return {
+            visitors: {
+                Block: (node) => {
+                    if (!allowedParents.has(node.parent.kind) && isEmptyBlock(node)) {
+                        context.report({
+                            message: "emptyBlock",
+                            range: getTSNodeRange(node, context.sourceFile),
+                        });
+                    }
+                },
+                CaseBlock: (node) => {
+                    if (node.clauses.length === 0) {
+                        context.report({
+                            message: "emptyBlock",
+                            range: getTSNodeRange(node, context.sourceFile),
+                        });
+                    }
+                },
+            },
+        };
+    },
+});

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

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