@flint.fyi/ts 0.14.2 → 0.14.4

package/lib/rules/objectProto.test.js

@@ -0,0 +1,96 @@
+import rule from "./objectProto.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+const proto = obj.__proto__;
+`,
+            snapshot: `
+const proto = obj.__proto__;
+                  ~~~~~~~~~
+                  Use Object.getPrototypeOf or Object.setPrototypeOf instead of the deprecated __proto__ property.
+`,
+        },
+        {
+            code: `
+obj.__proto__ = prototype;
+`,
+            snapshot: `
+obj.__proto__ = prototype;
+    ~~~~~~~~~
+    Use Object.getPrototypeOf or Object.setPrototypeOf instead of the deprecated __proto__ property.
+`,
+        },
+        {
+            code: `
+const descriptor = Object.getOwnPropertyDescriptor(obj, "__proto__");
+const proto = obj.__proto__;
+`,
+            snapshot: `
+const descriptor = Object.getOwnPropertyDescriptor(obj, "__proto__");
+const proto = obj.__proto__;
+                  ~~~~~~~~~
+                  Use Object.getPrototypeOf or Object.setPrototypeOf instead of the deprecated __proto__ property.
+`,
+        },
+        {
+            code: `
+const value = obj["__proto__"];
+`,
+            snapshot: `
+const value = obj["__proto__"];
+                  ~~~~~~~~~~~
+                  Use Object.getPrototypeOf or Object.setPrototypeOf instead of the deprecated __proto__ property.
+`,
+        },
+        {
+            code: `
+obj["__proto__"] = prototype;
+`,
+            snapshot: `
+obj["__proto__"] = prototype;
+    ~~~~~~~~~~~
+    Use Object.getPrototypeOf or Object.setPrototypeOf instead of the deprecated __proto__ property.
+`,
+        },
+        {
+            code: `
+if (obj.__proto__ === null) {
+    console.log("No prototype");
+}
+`,
+            snapshot: `
+if (obj.__proto__ === null) {
+        ~~~~~~~~~
+        Use Object.getPrototypeOf or Object.setPrototypeOf instead of the deprecated __proto__ property.
+    console.log("No prototype");
+}
+`,
+        },
+        {
+            code: `
+function getProto(obj: object) {
+    return obj.__proto__;
+}
+`,
+            snapshot: `
+function getProto(obj: object) {
+    return obj.__proto__;
+               ~~~~~~~~~
+               Use Object.getPrototypeOf or Object.setPrototypeOf instead of the deprecated __proto__ property.
+}
+`,
+        },
+    ],
+    valid: [
+        `const proto = Object.getPrototypeOf(obj);`,
+        `Object.setPrototypeOf(obj, prototype);`,
+        `const obj = Object.create(prototype);`,
+        `const descriptor = Object.getOwnPropertyDescriptor(obj, "__proto__");`,
+        `const key = "__proto__";`,
+        `const string = "obj.__proto__";`,
+        `const obj = { "__proto__": null };`,
+        `const obj = { __proto__: null };`,
+    ],
+});

package/lib/rules/octalNumbers.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using legacy octal numeric literals.";
+    readonly id: "octalNumbers";
+    readonly preset: "untyped";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noOctalNumber", undefined>;
+export default _default;

package/lib/rules/octalNumbers.js

@@ -0,0 +1,68 @@
+import { typescriptLanguage } from "../language.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports using legacy octal numeric literals.",
+        id: "octalNumbers",
+        preset: "untyped",
+    },
+    messages: {
+        noOctalNumber: {
+            primary: "This legacy octal numeric literal evaluates to {{ raw }}. Did you mean that value, or to use a modern octal syntax such as {{ equivalent }}?",
+            secondary: [
+                "Legacy octal numeric literals (e.g., `077`, `0123`) are a deprecated feature in JavaScript that can lead to confusion and errors.",
+                "They are forbidden in strict mode and are less readable than their modern alternatives.",
+                "The digit `0` by itself is allowed as it represents zero, not an octal literal.",
+            ],
+            suggestions: [
+                "Use the explicit octal syntax (e.g., `0o77`) introduced in ES6, which is clearer and works in both strict and non-strict modes.",
+                "Remove the leading `0` if you intended to use the decimal value.",
+            ],
+        },
+    },
+    setup(context) {
+        return {
+            visitors: {
+                NumericLiteral: (node) => {
+                    const text = node.getText(context.sourceFile);
+                    // Check for legacy octal literal: starts with 0 followed by octal digits (0-7)
+                    // But not just "0" alone, and not modern formats like 0x, 0o, 0b
+                    // cspell:ignore xobi
+                    if (text.length > 1 &&
+                        text.startsWith("0") &&
+                        text[1] >= "0" &&
+                        text[1] <= "7" &&
+                        !/^0[xobi]/i.test(text)) {
+                        const range = {
+                            begin: node.getStart(context.sourceFile),
+                            end: node.getEnd(),
+                        };
+                        // Parse the octal value
+                        const octalValue = parseInt(text, 8);
+                        const modernOctalSyntax = `0o${text.slice(1)}`;
+                        const decimalWithoutLeadingZero = text.slice(1);
+                        context.report({
+                            data: {
+                                equivalent: modernOctalSyntax,
+                                raw: octalValue.toString(),
+                            },
+                            message: "noOctalNumber",
+                            range,
+                            suggestions: [
+                                {
+                                    id: "useModernOctalSyntax",
+                                    range,
+                                    text: modernOctalSyntax,
+                                },
+                                {
+                                    id: "removeLeadingZero",
+                                    range,
+                                    text: decimalWithoutLeadingZero,
+                                },
+                            ],
+                        });
+                    }
+                },
+            },
+        };
+    },
+});

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

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

package/lib/rules/octalNumbers.test.js

@@ -0,0 +1,245 @@
+import rule from "./octalNumbers.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+const value = 07;
+`,
+            snapshot: `
+const value = 07;
+              ~~
+              This legacy octal numeric literal evaluates to 7. Did you mean that value, or to use a modern octal syntax such as 0o7?
+`,
+            suggestions: [
+                {
+                    id: "useModernOctalSyntax",
+                    updated: `
+const value = 0o7;
+`,
+                },
+                {
+                    id: "removeLeadingZero",
+                    updated: `
+const value = 7;
+`,
+                },
+            ],
+        },
+        {
+            code: `
+const value = 077;
+`,
+            snapshot: `
+const value = 077;
+              ~~~
+              This legacy octal numeric literal evaluates to 63. Did you mean that value, or to use a modern octal syntax such as 0o77?
+`,
+            suggestions: [
+                {
+                    id: "useModernOctalSyntax",
+                    updated: `
+const value = 0o77;
+`,
+                },
+                {
+                    id: "removeLeadingZero",
+                    updated: `
+const value = 77;
+`,
+                },
+            ],
+        },
+        {
+            code: `
+const value = 0123;
+`,
+            snapshot: `
+const value = 0123;
+              ~~~~
+              This legacy octal numeric literal evaluates to 83. Did you mean that value, or to use a modern octal syntax such as 0o123?
+`,
+            suggestions: [
+                {
+                    id: "useModernOctalSyntax",
+                    updated: `
+const value = 0o123;
+`,
+                },
+                {
+                    id: "removeLeadingZero",
+                    updated: `
+const value = 123;
+`,
+                },
+            ],
+        },
+        {
+            code: `
+const value = 01234567;
+`,
+            snapshot: `
+const value = 01234567;
+              ~~~~~~~~
+              This legacy octal numeric literal evaluates to 342391. Did you mean that value, or to use a modern octal syntax such as 0o1234567?
+`,
+            suggestions: [
+                {
+                    id: "useModernOctalSyntax",
+                    updated: `
+const value = 0o1234567;
+`,
+                },
+                {
+                    id: "removeLeadingZero",
+                    updated: `
+const value = 1234567;
+`,
+                },
+            ],
+        },
+        {
+            code: `
+const values = [01, 02, 03];
+`,
+            snapshot: `
+const values = [01, 02, 03];
+                ~~
+                This legacy octal numeric literal evaluates to 1. Did you mean that value, or to use a modern octal syntax such as 0o1?
+                    ~~
+                    This legacy octal numeric literal evaluates to 2. Did you mean that value, or to use a modern octal syntax such as 0o2?
+                        ~~
+                        This legacy octal numeric literal evaluates to 3. Did you mean that value, or to use a modern octal syntax such as 0o3?
+`,
+            suggestions: [
+                {
+                    id: "useModernOctalSyntax",
+                    updated: `
+const values = [0o1, 02, 03];
+`,
+                },
+                {
+                    id: "removeLeadingZero",
+                    updated: `
+const values = [1, 02, 03];
+`,
+                },
+                {
+                    id: "useModernOctalSyntax",
+                    updated: `
+const values = [01, 0o2, 03];
+`,
+                },
+                {
+                    id: "removeLeadingZero",
+                    updated: `
+const values = [01, 2, 03];
+`,
+                },
+                {
+                    id: "useModernOctalSyntax",
+                    updated: `
+const values = [01, 02, 0o3];
+`,
+                },
+                {
+                    id: "removeLeadingZero",
+                    updated: `
+const values = [01, 02, 3];
+`,
+                },
+            ],
+        },
+        {
+            code: `
+function calculate() {
+	return 077;
+}
+`,
+            snapshot: `
+function calculate() {
+	return 077;
+        ~~~
+        This legacy octal numeric literal evaluates to 63. Did you mean that value, or to use a modern octal syntax such as 0o77?
+}
+`,
+            suggestions: [
+                {
+                    id: "useModernOctalSyntax",
+                    updated: `
+function calculate() {
+	return 0o77;
+}
+`,
+                },
+                {
+                    id: "removeLeadingZero",
+                    updated: `
+function calculate() {
+	return 77;
+}
+`,
+                },
+            ],
+        },
+        {
+            code: `
+const result = 010 + 020;
+`,
+            snapshot: `
+const result = 010 + 020;
+               ~~~
+               This legacy octal numeric literal evaluates to 8. Did you mean that value, or to use a modern octal syntax such as 0o10?
+                     ~~~
+                     This legacy octal numeric literal evaluates to 16. Did you mean that value, or to use a modern octal syntax such as 0o20?
+`,
+            suggestions: [
+                {
+                    id: "useModernOctalSyntax",
+                    updated: `
+const result = 0o10 + 020;
+`,
+                },
+                {
+                    id: "removeLeadingZero",
+                    updated: `
+const result = 10 + 020;
+`,
+                },
+                {
+                    id: "useModernOctalSyntax",
+                    updated: `
+const result = 010 + 0o20;
+`,
+                },
+                {
+                    id: "removeLeadingZero",
+                    updated: `
+const result = 010 + 20;
+`,
+                },
+            ],
+        },
+    ],
+    valid: [
+        `const value = 0;`,
+        `const value = 1;`,
+        `const value = 10;`,
+        `const value = 100;`,
+        `const value = 0x7F;`,
+        `const value = 0o77;`,
+        `const value = 0O77;`,
+        `const value = 0b111;`,
+        `const value = 0B111;`,
+        `const value = 0.8;`,
+        `const value = 8;`,
+        `const value = 9;`,
+        `const value = 123;`,
+        `const values = [0, 1, 10, 100];`,
+        `const hex = 0xFF;`,
+        `const binary = 0b1010;`,
+        `const octal = 0o755;`,
+        `const notOctal = 08;`,
+        `const alsoNotOctal = 09;`,
+    ],
+});

package/lib/rules/returnAssignments.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using assignment expressions in return statements.";
+    readonly id: "returnAssignments";
+    readonly preset: "stylistic";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noReturnAssign", undefined>;
+export default _default;

package/lib/rules/returnAssignments.js

@@ -0,0 +1,50 @@
+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";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports using assignment expressions in return statements.",
+        id: "returnAssignments",
+        preset: "stylistic",
+    },
+    messages: {
+        noReturnAssign: {
+            primary: "Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.",
+            secondary: [
+                "Using assignments in return statements can make code harder to read and can lead to confusion about whether the assignment or the returned value is the primary intent.",
+                "Assignment expressions return the assigned value, but mixing assignment with return makes the control flow less clear.",
+            ],
+            suggestions: [
+                "Perform the assignment on a separate line before the return statement.",
+            ],
+        },
+    },
+    setup(context) {
+        function checkForAssignment(node) {
+            const unwrapped = unwrapParenthesizedExpression(node);
+            if (ts.isBinaryExpression(unwrapped) &&
+                tsutils.isAssignmentKind(unwrapped.operatorToken.kind)) {
+                context.report({
+                    message: "noReturnAssign",
+                    range: getTSNodeRange(unwrapped.operatorToken, context.sourceFile),
+                });
+            }
+        }
+        return {
+            visitors: {
+                ArrowFunction: (node) => {
+                    if (!ts.isBlock(node.body)) {
+                        checkForAssignment(node.body);
+                    }
+                },
+                ReturnStatement: (node) => {
+                    if (node.expression) {
+                        checkForAssignment(node.expression);
+                    }
+                },
+            },
+        };
+    },
+});

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

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

package/lib/rules/returnAssignments.test.js

@@ -0,0 +1,185 @@
+import rule from "./returnAssignments.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+function getValue() {
+    let value;
+    return value = 1;
+}
+`,
+            snapshot: `
+function getValue() {
+    let value;
+    return value = 1;
+                 ~
+                 Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.
+}
+`,
+        },
+        {
+            code: `
+function process() {
+    let result;
+    return result = calculate();
+}
+`,
+            snapshot: `
+function process() {
+    let result;
+    return result = calculate();
+                  ~
+                  Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.
+}
+`,
+        },
+        {
+            code: `
+function update() {
+    let status;
+    return (status = "updated");
+}
+`,
+            snapshot: `
+function update() {
+    let status;
+    return (status = "updated");
+                   ~
+                   Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.
+}
+`,
+        },
+        {
+            code: `
+const arrow = () => {
+    let value;
+    return value = 42;
+};
+`,
+            snapshot: `
+const arrow = () => {
+    let value;
+    return value = 42;
+                 ~
+                 Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.
+};
+`,
+        },
+        {
+            code: `
+const arrowImplicit = () => (value = 100);
+`,
+            snapshot: `
+const arrowImplicit = () => (value = 100);
+                                   ~
+                                   Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.
+`,
+        },
+        {
+            code: `
+function multiply(factor: number) {
+    let result;
+    return result = factor * 2;
+}
+`,
+            snapshot: `
+function multiply(factor: number) {
+    let result;
+    return result = factor * 2;
+                  ~
+                  Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.
+}
+`,
+        },
+        {
+            code: `
+function compound() {
+    let count;
+    return count += 5;
+}
+`,
+            snapshot: `
+function compound() {
+    let count;
+    return count += 5;
+                 ~~
+                 Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.
+}
+`,
+        },
+        {
+            code: `
+function bitwise() {
+    let flags;
+    return flags |= 0x01;
+}
+`,
+            snapshot: `
+function bitwise() {
+    let flags;
+    return flags |= 0x01;
+                 ~~
+                 Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.
+}
+`,
+        },
+    ],
+    valid: [
+        `function getValue() { return 1; }`,
+        `function getValue() { let value = 1; return value; }`,
+        `function process() { const result = calculate(); return result; }`,
+        `const arrow = () => { let value = 42; return value; };`,
+        `const arrowImplicit = () => getValue();`,
+        `
+function update() {
+    let status = "updated";
+    return status;
+}
+`,
+        `
+function multiply(factor: number) {
+    let result = factor * 2;
+    return result;
+}
+`,
+        `
+function compound() {
+    let count = 0;
+    count += 5;
+    return count;
+}
+`,
+        `
+function calculate() {
+    const value = 10;
+    return value;
+}
+`,
+        `
+const process = (input: number) => {
+    const result = input * 2;
+    return result;
+};
+`,
+        `
+class MyClass {
+    method() {
+        const value = 42;
+        return value;
+    }
+}
+`,
+        `
+function compare(a: number, b: number) {
+    return a === b;
+}
+`,
+        `
+function arrowReturn() {
+    const fn = () => 42;
+    return fn;
+}
+`,
+    ],
+});

package/lib/rules/selfAssignments.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports self-assignments which have no effect and are likely errors.";
+    readonly id: "selfAssignments";
+    readonly preset: "logical";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "selfAssignment", undefined>;
+export default _default;