@flint.fyi/ts 0.14.2 → 0.14.4

package/lib/rules/exceptionAssignments.test.js

@@ -0,0 +1,264 @@
+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); }`,
+    ],
+});

package/lib/rules/forDirections.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports for loops with counter variables that move in the wrong direction.";
+    readonly id: "forDirections";
+    readonly preset: "stylistic";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "wrongDirection", undefined>;
+export default _default;

package/lib/rules/forDirections.js

@@ -0,0 +1,124 @@
+import * as ts from "typescript";
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+function getConditionDirection(condition, counterName) {
+    if (!ts.isBinaryExpression(condition)) {
+        return undefined;
+    }
+    const leftName = getCounterName(condition.left);
+    const rightName = getCounterName(condition.right);
+    const isCounterLeft = leftName === counterName;
+    const isCounterRight = rightName === counterName;
+    if (!isCounterLeft && !isCounterRight) {
+        return undefined;
+    }
+    const { operatorToken } = condition;
+    if (isCounterLeft) {
+        if (operatorToken.kind === ts.SyntaxKind.LessThanToken ||
+            operatorToken.kind === ts.SyntaxKind.LessThanEqualsToken) {
+            return 1;
+        }
+        if (operatorToken.kind === ts.SyntaxKind.GreaterThanToken ||
+            operatorToken.kind === ts.SyntaxKind.GreaterThanEqualsToken) {
+            return -1;
+        }
+    }
+    else {
+        if (operatorToken.kind === ts.SyntaxKind.LessThanToken ||
+            operatorToken.kind === ts.SyntaxKind.LessThanEqualsToken) {
+            return -1;
+        }
+        if (operatorToken.kind === ts.SyntaxKind.GreaterThanToken ||
+            operatorToken.kind === ts.SyntaxKind.GreaterThanEqualsToken) {
+            return 1;
+        }
+    }
+    return undefined;
+}
+function getCounterName(node) {
+    return ts.isIdentifier(node) ? node.text : undefined;
+}
+function getUpdateDirection(update) {
+    if (ts.isPostfixUnaryExpression(update) ||
+        ts.isPrefixUnaryExpression(update)) {
+        switch (update.operator) {
+            case ts.SyntaxKind.MinusMinusToken:
+                return -1;
+            case ts.SyntaxKind.PlusPlusToken:
+                return 1;
+            default:
+                return undefined;
+        }
+    }
+    if (ts.isBinaryExpression(update)) {
+        const { operatorToken, right } = update;
+        if (operatorToken.kind === ts.SyntaxKind.PlusEqualsToken ||
+            operatorToken.kind === ts.SyntaxKind.MinusEqualsToken) {
+            if (ts.isNumericLiteral(right)) {
+                const value = Number(right.text);
+                if (operatorToken.kind === ts.SyntaxKind.PlusEqualsToken) {
+                    return value > 0 ? 1 : value < 0 ? -1 : 0;
+                }
+                return value > 0 ? -1 : value < 0 ? 1 : 0;
+            }
+            if (ts.isPrefixUnaryExpression(right) &&
+                right.operator === ts.SyntaxKind.MinusToken &&
+                ts.isNumericLiteral(right.operand)) {
+                const value = Number(right.operand.text);
+                if (operatorToken.kind === ts.SyntaxKind.PlusEqualsToken) {
+                    return value > 0 ? -1 : 1;
+                }
+                return value > 0 ? 1 : -1;
+            }
+        }
+    }
+    return undefined;
+}
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports for loops with counter variables that move in the wrong direction.",
+        id: "forDirections",
+        preset: "stylistic",
+    },
+    messages: {
+        wrongDirection: {
+            primary: "The update moves the counter in the wrong direction for this loop condition.",
+            secondary: [
+                "A for loop with a counter that moves in the wrong direction relative to its stop condition will run infinitely or never execute.",
+                "When the counter increases but the condition expects it to decrease (or vice versa), the loop logic is incorrect.",
+            ],
+            suggestions: [
+                "Verify the loop counter update direction matches the condition.",
+            ],
+        },
+    },
+    setup(context) {
+        return {
+            visitors: {
+                ForStatement: (node) => {
+                    if (!node.condition ||
+                        !node.incrementor ||
+                        !node.initializer ||
+                        !ts.isVariableDeclarationList(node.initializer)) {
+                        return;
+                    }
+                    const declaration = node.initializer.declarations.at(0);
+                    if (!declaration || !ts.isIdentifier(declaration.name)) {
+                        return;
+                    }
+                    const updateDirection = getUpdateDirection(node.incrementor);
+                    if (!updateDirection) {
+                        return;
+                    }
+                    const conditionDirection = getConditionDirection(node.condition, declaration.name.text);
+                    if (updateDirection !== conditionDirection) {
+                        context.report({
+                            message: "wrongDirection",
+                            range: getTSNodeRange(node.incrementor, context.sourceFile),
+                        });
+                    }
+                },
+            },
+        };
+    },
+});

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

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

package/lib/rules/forDirections.test.js

@@ -0,0 +1,99 @@
+import rule from "./forDirections.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+for (let i = 0; i < 10; i--) {}
+`,
+            snapshot: `
+for (let i = 0; i < 10; i--) {}
+                        ~~~
+                        The update moves the counter in the wrong direction for this loop condition.
+`,
+        },
+        {
+            code: `
+for (let index = 0; index < 10; index--) {}
+`,
+            snapshot: `
+for (let index = 0; index < 10; index--) {}
+                                ~~~~~~~
+                                The update moves the counter in the wrong direction for this loop condition.
+`,
+        },
+        {
+            code: `
+for (let index = 10; index >= 0; index++) {}
+`,
+            snapshot: `
+for (let index = 10; index >= 0; index++) {}
+                                 ~~~~~~~
+                                 The update moves the counter in the wrong direction for this loop condition.
+`,
+        },
+        {
+            code: `
+for (let index = 0; index > 10; index++) {}
+`,
+            snapshot: `
+for (let index = 0; index > 10; index++) {}
+                                ~~~~~~~
+                                The update moves the counter in the wrong direction for this loop condition.
+`,
+        },
+        {
+            code: `
+for (let index = 0; 10 > index; index--) {}
+`,
+            snapshot: `
+for (let index = 0; 10 > index; index--) {}
+                                ~~~~~~~
+                                The update moves the counter in the wrong direction for this loop condition.
+`,
+        },
+        {
+            code: `
+for (let index = 0; index < 10; index -= 1) {}
+`,
+            snapshot: `
+for (let index = 0; index < 10; index -= 1) {}
+                                ~~~~~~~~~~
+                                The update moves the counter in the wrong direction for this loop condition.
+`,
+        },
+        {
+            code: `
+for (let index = 10; index > 0; index += 1) {}
+`,
+            snapshot: `
+for (let index = 10; index > 0; index += 1) {}
+                                ~~~~~~~~~~
+                                The update moves the counter in the wrong direction for this loop condition.
+`,
+        },
+        {
+            code: `
+for (let index = 0; index < 10; index += -1) {}
+`,
+            snapshot: `
+for (let index = 0; index < 10; index += -1) {}
+                                ~~~~~~~~~~~
+                                The update moves the counter in the wrong direction for this loop condition.
+`,
+        },
+    ],
+    valid: [
+        `for (let i = 0; i < 10; i++) { }`,
+        `for (let index = 0; index < 10; index++) { }`,
+        `for (let index = 10; index >= 0; index--) { }`,
+        `for (let index = 0; 10 > index; index++) { }`,
+        `for (let index = 10; 0 < index; index--) { }`,
+        `for (let index = 10; index >= 0; index += step) { }`,
+        `for (let index = 0; index <= 10; index -= 0) { }`,
+        `for (let index = 0; index < 10; index += 1) { }`,
+        `for (let index = 10; index > 0; index -= 1) { }`,
+        `for (let index = 0; index < 10; index += 2) { }`,
+        `for (let index = 10; index > 0; index -= 2) { }`,
+    ],
+});

package/lib/rules/functionAssignments.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports reassigning variables declared with function declarations.";
+    readonly id: "functionAssignments";
+    readonly preset: "untyped";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noFunctionAssignment", undefined>;
+export default _default;

package/lib/rules/functionAssignments.js

@@ -0,0 +1,42 @@
+import { typescriptLanguage } from "../language.js";
+import { getModifyingReferences } from "../utils/getModifyingReferences.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports reassigning variables declared with function declarations.",
+        id: "functionAssignments",
+        preset: "untyped",
+    },
+    messages: {
+        noFunctionAssignment: {
+            primary: "Variables declared with function declarations should not be reassigned.",
+            secondary: [
+                "Reassigning a function declaration can make code harder to understand and maintain.",
+                "Function declarations are hoisted to the top of their scope, and reassigning them can lead to unexpected behavior.",
+            ],
+            suggestions: [
+                "Use a function expression or const variable instead if you need to reassign the function.",
+            ],
+        },
+    },
+    setup(context) {
+        return {
+            visitors: {
+                FunctionDeclaration: (node) => {
+                    if (!node.name) {
+                        return;
+                    }
+                    const modifyingReferences = getModifyingReferences(node.name, context.sourceFile, context.typeChecker);
+                    for (const reference of modifyingReferences) {
+                        context.report({
+                            message: "noFunctionAssignment",
+                            range: {
+                                begin: reference.getStart(context.sourceFile),
+                                end: reference.getEnd(),
+                            },
+                        });
+                    }
+                },
+            },
+        };
+    },
+});

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

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