@flint.fyi/ts 0.14.2 → 0.14.3

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/chainedAssignments.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using chained assignment expressions (e.g., a = b = c).";
+    readonly id: "chainedAssignments";
+    readonly preset: "stylistic";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noChainedAssignment", undefined>;
+export default _default;

package/lib/rules/chainedAssignments.js

@@ -0,0 +1,48 @@
+import * as tsutils from "ts-api-utils";
+import * as ts from "typescript";
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+import { unwrapParenthesizedExpression } from "../utils/unwrapParenthesizedExpression.js";
+import { unwrapParenthesizedExpressionsParent } from "../utils/unwrapParentParenthesizedExpressions.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports using chained assignment expressions (e.g., a = b = c).",
+        id: "chainedAssignments",
+        preset: "stylistic",
+    },
+    messages: {
+        noChainedAssignment: {
+            primary: "Prefer separate assignment statements for readability instead of chaining assignments.",
+            secondary: [
+                "Chained assignments can be hard to read and can lead to unexpected behavior with variable scoping and type inference.",
+                "Each assignment creates a reference to the same value, which may cause confusion when dealing with mutable values.",
+            ],
+            suggestions: [
+                "Break the chained assignment into separate assignment statements, one for each variable.",
+            ],
+        },
+    },
+    setup(context) {
+        return {
+            visitors: {
+                BinaryExpression: (node) => {
+                    if (!tsutils.isAssignmentKind(node.operatorToken.kind)) {
+                        return;
+                    }
+                    const rightSide = unwrapParenthesizedExpression(node.right);
+                    if (!ts.isBinaryExpression(rightSide)) {
+                        return;
+                    }
+                    const parent = unwrapParenthesizedExpressionsParent(node);
+                    if (ts.isBinaryExpression(parent)) {
+                        return;
+                    }
+                    context.report({
+                        message: "noChainedAssignment",
+                        range: getTSNodeRange(node.operatorToken, context.sourceFile),
+                    });
+                },
+            },
+        };
+    },
+});

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

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

package/lib/rules/chainedAssignments.test.js

@@ -0,0 +1,238 @@
+import rule from "./chainedAssignments.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+let first;
+let second;
+first = second = 1;
+`,
+            snapshot: `
+let first;
+let second;
+first = second = 1;
+      ~
+      Prefer separate assignment statements for readability instead of chaining assignments.
+`,
+        },
+        {
+            code: `
+let first;
+let second;
+let third;
+first = second = third = 0;
+`,
+            snapshot: `
+let first;
+let second;
+let third;
+first = second = third = 0;
+      ~
+      Prefer separate assignment statements for readability instead of chaining assignments.
+`,
+        },
+        {
+            code: `
+let value;
+let another;
+value = another = getValue();
+`,
+            snapshot: `
+let value;
+let another;
+value = another = getValue();
+      ~
+      Prefer separate assignment statements for readability instead of chaining assignments.
+`,
+        },
+        {
+            code: `
+let first;
+let second;
+(first = second = 1);
+`,
+            snapshot: `
+let first;
+let second;
+(first = second = 1);
+       ~
+       Prefer separate assignment statements for readability instead of chaining assignments.
+`,
+        },
+        {
+            code: `
+const calculate = (value: number) => {
+    let first;
+    let second;
+    first = second = value;
+    return first + second;
+};
+`,
+            snapshot: `
+const calculate = (value: number) => {
+    let first;
+    let second;
+    first = second = value;
+          ~
+          Prefer separate assignment statements for readability instead of chaining assignments.
+    return first + second;
+};
+`,
+        },
+        {
+            code: `
+let first;
+let second;
+if (true) {
+    first = second = 10;
+}
+`,
+            snapshot: `
+let first;
+let second;
+if (true) {
+    first = second = 10;
+          ~
+          Prefer separate assignment statements for readability instead of chaining assignments.
+}
+`,
+        },
+        {
+            code: `
+class MyClass {
+    method() {
+        let first;
+        let second;
+        first = second = 0;
+    }
+}
+`,
+            snapshot: `
+class MyClass {
+    method() {
+        let first;
+        let second;
+        first = second = 0;
+              ~
+              Prefer separate assignment statements for readability instead of chaining assignments.
+    }
+}
+`,
+        },
+        {
+            code: `
+let first;
+let second;
+let third;
+first = (second = third = 5);
+`,
+            snapshot: `
+let first;
+let second;
+let third;
+first = (second = third = 5);
+      ~
+      Prefer separate assignment statements for readability instead of chaining assignments.
+`,
+        },
+        {
+            code: `
+let first;
+let second;
+first ||= second ||= 1;
+`,
+            snapshot: `
+let first;
+let second;
+first ||= second ||= 1;
+      ~~~
+      Prefer separate assignment statements for readability instead of chaining assignments.
+`,
+        },
+        {
+            code: `
+let first;
+let second;
+first ??= second ??= 0;
+`,
+            snapshot: `
+let first;
+let second;
+first ??= second ??= 0;
+      ~~~
+      Prefer separate assignment statements for readability instead of chaining assignments.
+`,
+        },
+        {
+            code: `
+let first;
+let second;
+first += second += 5;
+`,
+            snapshot: `
+let first;
+let second;
+first += second += 5;
+      ~~
+      Prefer separate assignment statements for readability instead of chaining assignments.
+`,
+        },
+        {
+            code: `
+let first;
+let second;
+first |= second |= 3;
+`,
+            snapshot: `
+let first;
+let second;
+first |= second |= 3;
+      ~~
+      Prefer separate assignment statements for readability instead of chaining assignments.
+`,
+        },
+    ],
+    valid: [
+        `let first = 1;`,
+        `let first = 1, second = 2;`,
+        `let first = 1; let second = 2;`,
+        `let first; let second; first = 1; second = 2;`,
+        `let first; let second; first = 1; second = first;`,
+        `const value = getValue();`,
+        `let first; first = 1;`,
+        `
+let first;
+let second;
+first = 1;
+second = 2;
+`,
+        `
+let first;
+let second;
+let third;
+first = 1;
+second = 2;
+third = 3;
+`,
+        `
+const calculate = (value: number) => {
+    let first;
+    let second;
+    first = value;
+    second = value;
+    return first + second;
+};
+`,
+        `
+class MyClass {
+    method() {
+        let first;
+        let second;
+        first = 0;
+        second = 0;
+    }
+}
+`,
+    ],
+});

package/lib/rules/classAssignments.d.ts

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

package/lib/rules/classAssignments.js

@@ -0,0 +1,42 @@
+import { typescriptLanguage } from "../language.js";
+import { getModifyingReferences } from "../utils/getModifyingReferences.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports reassigning class declarations.",
+        id: "classAssignments",
+        preset: "untyped",
+    },
+    messages: {
+        noClassAssign: {
+            primary: "Reassigning a class declaration is misleading and makes the class harder to use.",
+            secondary: [
+                "Reassigning a class declaration can lead to unexpected behavior and makes code harder to understand.",
+                "Class declarations are typically intended to be immutable references, and reassigning them can cause confusion about which class is being used.",
+            ],
+            suggestions: [
+                "Use a different variable name if you need to store a modified reference to a class.",
+            ],
+        },
+    },
+    setup(context) {
+        return {
+            visitors: {
+                ClassDeclaration: (node) => {
+                    if (!node.name) {
+                        return;
+                    }
+                    const modifyingReferences = getModifyingReferences(node.name, context.sourceFile, context.typeChecker);
+                    for (const reference of modifyingReferences) {
+                        context.report({
+                            message: "noClassAssign",
+                            range: {
+                                begin: reference.getStart(context.sourceFile),
+                                end: reference.getEnd(),
+                            },
+                        });
+                    }
+                },
+            },
+        };
+    },
+});

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

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