@flint.fyi/ts 0.14.1 → 0.14.3

package/lib/rules/negativeZeroComparisons.test.js

@@ -0,0 +1,209 @@
+import rule from "./negativeZeroComparisons.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+if (value === -0) {}
+`,
+            snapshot: `
+if (value === -0) {}
+    ~~~~~~~~~~~~
+    Comparisons with -0 using === do not distinguish between -0 and +0.
+`,
+            suggestions: [
+                {
+                    id: "useObjectIs",
+                    updated: `
+if (Object.is(value, -0)) {}
+`,
+                },
+            ],
+        },
+        {
+            code: `
+if (-0 === value) {}
+`,
+            snapshot: `
+if (-0 === value) {}
+    ~~~~~~~~~~~~
+    Comparisons with -0 using === do not distinguish between -0 and +0.
+`,
+            suggestions: [
+                {
+                    id: "useObjectIs",
+                    updated: `
+if (Object.is(-0, value)) {}
+`,
+                },
+            ],
+        },
+        {
+            code: `
+if (value == -0) {}
+`,
+            snapshot: `
+if (value == -0) {}
+    ~~~~~~~~~~~
+    Comparisons with -0 using == do not distinguish between -0 and +0.
+`,
+            suggestions: [
+                {
+                    id: "useObjectIs",
+                    updated: `
+if (Object.is(value, -0)) {}
+`,
+                },
+            ],
+        },
+        {
+            code: `
+if (value !== -0) {}
+`,
+            snapshot: `
+if (value !== -0) {}
+    ~~~~~~~~~~~~
+    Comparisons with -0 using !== do not distinguish between -0 and +0.
+`,
+            suggestions: [
+                {
+                    id: "useObjectIs",
+                    updated: `
+if (!Object.is(value, -0)) {}
+`,
+                },
+            ],
+        },
+        {
+            code: `
+if (value != -0) {}
+`,
+            snapshot: `
+if (value != -0) {}
+    ~~~~~~~~~~~
+    Comparisons with -0 using != do not distinguish between -0 and +0.
+`,
+            suggestions: [
+                {
+                    id: "useObjectIs",
+                    updated: `
+if (!Object.is(value, -0)) {}
+`,
+                },
+            ],
+        },
+        {
+            code: `
+if (value < -0) {}
+`,
+            snapshot: `
+if (value < -0) {}
+    ~~~~~~~~~~
+    Comparisons with -0 using < do not distinguish between -0 and +0.
+`,
+        },
+        {
+            code: `
+if (value <= -0) {}
+`,
+            snapshot: `
+if (value <= -0) {}
+    ~~~~~~~~~~~
+    Comparisons with -0 using <= do not distinguish between -0 and +0.
+`,
+        },
+        {
+            code: `
+if (value > -0) {}
+`,
+            snapshot: `
+if (value > -0) {}
+    ~~~~~~~~~~
+    Comparisons with -0 using > do not distinguish between -0 and +0.
+`,
+        },
+        {
+            code: `
+if (value >= -0) {}
+`,
+            snapshot: `
+if (value >= -0) {}
+    ~~~~~~~~~~~
+    Comparisons with -0 using >= do not distinguish between -0 and +0.
+`,
+        },
+        {
+            code: `
+const result = value === -0 ? "negative zero" : "other";
+`,
+            snapshot: `
+const result = value === -0 ? "negative zero" : "other";
+               ~~~~~~~~~~~~
+               Comparisons with -0 using === do not distinguish between -0 and +0.
+`,
+            suggestions: [
+                {
+                    id: "useObjectIs",
+                    updated: `
+const result = Object.is(value, -0) ? "negative zero" : "other";
+`,
+                },
+            ],
+        },
+        {
+            code: `
+while (value !== -0) {
+	value++;
+}
+`,
+            snapshot: `
+while (value !== -0) {
+       ~~~~~~~~~~~~
+       Comparisons with -0 using !== do not distinguish between -0 and +0.
+	value++;
+}
+`,
+            suggestions: [
+                {
+                    id: "useObjectIs",
+                    updated: `
+while (!Object.is(value, -0)) {
+	value++;
+}
+`,
+                },
+            ],
+        },
+        {
+            code: `
+const isNegativeZero = value === -0;
+`,
+            snapshot: `
+const isNegativeZero = value === -0;
+                       ~~~~~~~~~~~~
+                       Comparisons with -0 using === do not distinguish between -0 and +0.
+`,
+            suggestions: [
+                {
+                    id: "useObjectIs",
+                    updated: `
+const isNegativeZero = Object.is(value, -0);
+`,
+                },
+            ],
+        },
+    ],
+    valid: [
+        `if (value === 0) {}`,
+        `if (value === -1) {}`,
+        `if (value === 1) {}`,
+        `if (Object.is(value, -0)) {}`,
+        `if (Object.is(-0, value)) {}`,
+        `const result = -0;`,
+        `const value = -0 + 1;`,
+        `const value = -0 * 2;`,
+        `const value = Math.abs(-0);`,
+        `const value = [-0, 0, 1];`,
+        `function test() { return -0; }`,
+    ],
+});

package/lib/rules/newExpressions.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports standalone new expressions that don't use the constructed object.";
+    readonly id: "newExpressions";
+    readonly preset: "logical";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noStandaloneNew", undefined>;
+export default _default;

package/lib/rules/newExpressions.js

@@ -0,0 +1,54 @@
+import * as ts from "typescript";
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports standalone new expressions that don't use the constructed object.",
+        id: "newExpressions",
+        preset: "logical",
+    },
+    messages: {
+        noStandaloneNew: {
+            primary: "Constructors should only be called when their return value is used.",
+            secondary: [
+                "Using `new` to construct an object but not storing or using the result is often a mistake or indicates unclear code intent.",
+                "If the constructor has side effects you want to trigger, it's better to make that explicit by calling a separate method rather than relying on constructor side effects.",
+            ],
+            suggestions: [
+                "If you need to use the constructed object, assign it to a variable or return it.",
+                "If you only need the constructor's side effects, consider refactoring to a function that makes the side effects explicit.",
+            ],
+        },
+    },
+    setup(context) {
+        function isStandaloneExpression(node) {
+            const parent = node.parent;
+            // If parent is an ExpressionStatement, it's standalone
+            if (parent.kind === ts.SyntaxKind.ExpressionStatement) {
+                return true;
+            }
+            // If parent is a comma expression, check recursively
+            if (ts.isBinaryExpression(parent) &&
+                parent.operatorToken.kind === ts.SyntaxKind.CommaToken) {
+                // If this is the last expression in the comma sequence, check if the parent is standalone
+                if (parent.right === node) {
+                    return isStandaloneExpression(parent);
+                }
+                return true;
+            }
+            return false;
+        }
+        return {
+            visitors: {
+                NewExpression: (node) => {
+                    if (isStandaloneExpression(node)) {
+                        context.report({
+                            message: "noStandaloneNew",
+                            range: getTSNodeRange(node.getChildAt(0, context.sourceFile), context.sourceFile),
+                        });
+                    }
+                },
+            },
+        };
+    },
+});

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

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

package/lib/rules/newExpressions.test.js

@@ -0,0 +1,79 @@
+import rule from "./newExpressions.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+new MyClass();
+`,
+            snapshot: `
+new MyClass();
+~~~
+Constructors should only be called when their return value is used.
+`,
+        },
+        {
+            code: `
+function process() {
+    new EventEmitter();
+}
+`,
+            snapshot: `
+function process() {
+    new EventEmitter();
+    ~~~
+    Constructors should only be called when their return value is used.
+}
+`,
+        },
+        {
+            code: `
+if (condition) {
+    new Logger();
+}
+`,
+            snapshot: `
+if (condition) {
+    new Logger();
+    ~~~
+    Constructors should only be called when their return value is used.
+}
+`,
+        },
+        {
+            code: `
+new DatabaseConnection(), processData();
+`,
+            snapshot: `
+new DatabaseConnection(), processData();
+~~~
+Constructors should only be called when their return value is used.
+`,
+        },
+        {
+            code: `
+someFunction(), new Queue();
+`,
+            snapshot: `
+someFunction(), new Queue();
+                ~~~
+                Constructors should only be called when their return value is used.
+`,
+        },
+    ],
+    valid: [
+        `const instance = new MyClass();`,
+        `let value = new MyClass();`,
+        `const result = condition ? new MyClass() : new OtherClass();`,
+        `return new MyClass();`,
+        `throw new Error("message");`,
+        `function create() { return new MyClass(); }`,
+        `const array = [new MyClass(), new OtherClass()];`,
+        `const object = { value: new MyClass() };`,
+        `myFunction(new MyClass());`,
+        `new MyClass().method();`,
+        `const value = new MyClass() || fallback;`,
+        `const value = new MyClass() && other;`,
+        `const value = new MyClass() ?? fallback;`,
+    ],
+});

package/lib/rules/newNativeNonConstructors.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Disallows using `new` with global non-constructor functions like Symbol and BigInt.";
+    readonly id: "newNativeNonConstructors";
+    readonly preset: "untyped";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noNewNonConstructor", undefined>;
+export default _default;

package/lib/rules/newNativeNonConstructors.js

@@ -0,0 +1,49 @@
+import * as ts from "typescript";
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+import { isGlobalDeclaration } from "../utils/isGlobalDeclaration.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Disallows using `new` with global non-constructor functions like Symbol and BigInt.",
+        id: "newNativeNonConstructors",
+        preset: "untyped",
+    },
+    messages: {
+        noNewNonConstructor: {
+            primary: "{{ name }} cannot be called with `new`.",
+            secondary: [
+                "`Symbol` and `BigInt` are not constructors and will throw a `TypeError` when called with `new`.",
+                "These functions should be called directly without the `new` keyword to create their respective values.",
+            ],
+            suggestions: ["Remove the `new` keyword and call the function directly."],
+        },
+    },
+    setup(context) {
+        return {
+            visitors: {
+                NewExpression: (node) => {
+                    if (!ts.isIdentifier(node.expression)) {
+                        return;
+                    }
+                    const name = node.expression.text;
+                    if (!["BigInt", "Symbol"].includes(name) ||
+                        !isGlobalDeclaration(node.expression, context.typeChecker)) {
+                        return;
+                    }
+                    context.report({
+                        data: { name },
+                        fix: {
+                            range: {
+                                begin: node.getStart(context.sourceFile),
+                                end: node.expression.getStart(context.sourceFile),
+                            },
+                            text: "",
+                        },
+                        message: "noNewNonConstructor",
+                        range: getTSNodeRange(node.getChildAt(0, context.sourceFile), context.sourceFile),
+                    });
+                },
+            },
+        };
+    },
+});

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

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

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

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using octal escape sequences in string literals.";
+    readonly id: "octalEscapes";
+    readonly preset: "logical";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noOctalEscape", undefined>;
+export default _default;