@flint.fyi/ts 0.14.2 → 0.14.3

package/lib/rules/newNativeNonConstructors.test.js

@@ -0,0 +1,94 @@
+import rule from "./newNativeNonConstructors.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+new Symbol("description");
+`,
+            output: `
+Symbol("description");
+`,
+            snapshot: `
+new Symbol("description");
+~~~
+Symbol cannot be called with \`new\`.
+`,
+        },
+        {
+            code: `
+new BigInt(42);
+`,
+            output: `
+BigInt(42);
+`,
+            snapshot: `
+new BigInt(42);
+~~~
+BigInt cannot be called with \`new\`.
+`,
+        },
+        {
+            code: `
+const value = new Symbol();
+`,
+            output: `
+const value = Symbol();
+`,
+            snapshot: `
+const value = new Symbol();
+              ~~~
+              Symbol cannot be called with \`new\`.
+`,
+        },
+        {
+            code: `
+function create() {
+    return new BigInt(100);
+}
+`,
+            output: `
+function create() {
+    return BigInt(100);
+}
+`,
+            snapshot: `
+function create() {
+    return new BigInt(100);
+           ~~~
+           BigInt cannot be called with \`new\`.
+}
+`,
+        },
+    ],
+    valid: [
+        `Symbol("description");`,
+        `BigInt(42);`,
+        `const value = Symbol();`,
+        `const number = BigInt(100);`,
+        `function create() { return Symbol("key"); }`,
+        `const array = [Symbol("a"), Symbol("b")];`,
+        `new String("text");`,
+        `new Number(42);`,
+        `new Boolean(true);`,
+        `new Object();`,
+        `new Array();`,
+        `new Date();`,
+        `new Error("message");`,
+        `new Map();`,
+        `new Set();`,
+        `new Promise((resolve) => resolve());`,
+        `new WeakMap();`,
+        `new WeakSet();`,
+        `
+			class BigInt {}
+			new BigInt();
+			export {}
+		`,
+        `
+			class Symbol {}
+			new Symbol();
+			export {}
+		`,
+    ],
+});

package/lib/rules/objectProto.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using the deprecated __proto__ property to access or modify an object's prototype.";
+    readonly id: "objectProto";
+    readonly preset: "untyped";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noProto", undefined>;
+export default _default;

package/lib/rules/objectProto.js

@@ -0,0 +1,54 @@
+import * as ts from "typescript";
+import { typescriptLanguage } from "../language.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports using the deprecated __proto__ property to access or modify an object's prototype.",
+        id: "objectProto",
+        preset: "untyped",
+    },
+    messages: {
+        noProto: {
+            primary: "Use Object.getPrototypeOf or Object.setPrototypeOf instead of the deprecated __proto__ property.",
+            secondary: [
+                "The __proto__ property is deprecated and not part of the ECMAScript standard.",
+                "It is maintained for compatibility with older browsers but can cause performance issues and unexpected behavior.",
+                "Direct manipulation of an object's prototype can lead to hidden classes deoptimizations in JavaScript engines.",
+            ],
+            suggestions: [
+                "Use Object.getPrototypeOf(obj) to read the prototype of an object.",
+                "Use Object.setPrototypeOf(obj, proto) to set the prototype of an object.",
+                "Use Object.create(proto) when creating new objects with a specific prototype.",
+            ],
+        },
+    },
+    setup(context) {
+        return {
+            visitors: {
+                ElementAccessExpression: (node) => {
+                    if (ts.isStringLiteral(node.argumentExpression) &&
+                        node.argumentExpression.text === "__proto__") {
+                        context.report({
+                            message: "noProto",
+                            range: {
+                                begin: node.argumentExpression.getStart(context.sourceFile),
+                                end: node.argumentExpression.getEnd(),
+                            },
+                        });
+                    }
+                },
+                PropertyAccessExpression: (node) => {
+                    if (node.name.kind === ts.SyntaxKind.Identifier &&
+                        node.name.text === "__proto__") {
+                        context.report({
+                            message: "noProto",
+                            range: {
+                                begin: node.name.getStart(context.sourceFile),
+                                end: node.name.getEnd(),
+                            },
+                        });
+                    }
+                },
+            },
+        };
+    },
+});

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

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

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 {};