@flint.fyi/ts 0.14.2 → 0.14.4

package/lib/rules/globalAssignments.test.js

@@ -0,0 +1,215 @@
+import rule from "./globalAssignments.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+undefined = 1;
+`,
+            snapshot: `
+undefined = 1;
+~~~~~~~~~
+Read-only global variables should not be reassigned or modified.
+`,
+        },
+        {
+            code: `
+NaN = 42;
+`,
+            snapshot: `
+NaN = 42;
+~~~
+Read-only global variables should not be reassigned or modified.
+`,
+        },
+        {
+            code: `
+Infinity = 100;
+`,
+            snapshot: `
+Infinity = 100;
+~~~~~~~~
+Read-only global variables should not be reassigned or modified.
+`,
+        },
+        {
+            code: `
+Object = null;
+`,
+            snapshot: `
+Object = null;
+~~~~~~
+Read-only global variables should not be reassigned or modified.
+`,
+        },
+        {
+            code: `
+Array = function() {};
+`,
+            snapshot: `
+Array = function() {};
+~~~~~
+Read-only global variables should not be reassigned or modified.
+`,
+        },
+        {
+            code: `
+String = "test";
+`,
+            snapshot: `
+String = "test";
+~~~~~~
+Read-only global variables should not be reassigned or modified.
+`,
+        },
+        {
+            code: `
+Number = 123;
+`,
+            snapshot: `
+Number = 123;
+~~~~~~
+Read-only global variables should not be reassigned or modified.
+`,
+        },
+        {
+            code: `
+Boolean = true;
+`,
+            snapshot: `
+Boolean = true;
+~~~~~~~
+Read-only global variables should not be reassigned or modified.
+`,
+        },
+        {
+            code: `
+Math = {};
+`,
+            snapshot: `
+Math = {};
+~~~~
+Read-only global variables should not be reassigned or modified.
+`,
+        },
+        {
+            code: `
+JSON = null;
+`,
+            snapshot: `
+JSON = null;
+~~~~
+Read-only global variables should not be reassigned or modified.
+`,
+        },
+        {
+            code: `
+window = {};
+`,
+            snapshot: `
+window = {};
+~~~~~~
+Read-only global variables should not be reassigned or modified.
+`,
+        },
+        {
+            code: `
+undefined += 1;
+`,
+            snapshot: `
+undefined += 1;
+~~~~~~~~~
+Read-only global variables should not be reassigned or modified.
+`,
+        },
+        {
+            code: `
+NaN *= 2;
+`,
+            snapshot: `
+NaN *= 2;
+~~~
+Read-only global variables should not be reassigned or modified.
+`,
+        },
+        {
+            code: `
+++undefined;
+`,
+            snapshot: `
+++undefined;
+  ~~~~~~~~~
+  Read-only global variables should not be reassigned or modified.
+`,
+        },
+        {
+            code: `
+NaN++;
+`,
+            snapshot: `
+NaN++;
+~~~
+Read-only global variables should not be reassigned or modified.
+`,
+        },
+        {
+            code: `
+--Infinity;
+`,
+            snapshot: `
+--Infinity;
+  ~~~~~~~~
+  Read-only global variables should not be reassigned or modified.
+`,
+        },
+        {
+            code: `
+Object--;
+`,
+            snapshot: `
+Object--;
+~~~~~~
+Read-only global variables should not be reassigned or modified.
+`,
+        },
+    ],
+    valid: [
+        `let undefined = 1;`,
+        `const NaN = 42;`,
+        `var Infinity = 100;`,
+        `function Object() {}`,
+        `let value = undefined;`,
+        `const result = NaN;`,
+        `if (value === undefined) {}`,
+        `const obj = { undefined: 1 };`,
+        `obj.undefined = 2;`,
+        `const custom = { NaN: 42 }; custom.NaN = 100;`,
+        `let myVar = 5; myVar = 10;`,
+        `const data = { value: 1 }; data.value = 2;`,
+        `let counter = 0; counter++;`,
+        `let index = 10; --index;`,
+        `
+function test() {
+    let undefined = 5;
+    undefined = 10;
+}
+`,
+        `
+const obj = {
+    undefined: 1,
+    NaN: 2,
+};
+obj.undefined = 5;
+`,
+        `
+const fn = (undefined: number) => {
+    undefined = 10;
+};
+`,
+        `
+function test(NaN: string) {
+    NaN = "updated";
+}
+`,
+    ],
+});

package/lib/rules/globalObjectCalls.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports calling global objects like Math, JSON, or Reflect as functions.";
+    readonly id: "globalObjectCalls";
+    readonly preset: "untyped";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noGlobalObjectCall", undefined>;
+export default _default;

package/lib/rules/globalObjectCalls.js

@@ -0,0 +1,43 @@
+import * as ts from "typescript";
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+const globalObjects = new Set(["Atomics", "JSON", "Math", "Reflect"]);
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports calling global objects like Math, JSON, or Reflect as functions.",
+        id: "globalObjectCalls",
+        preset: "untyped",
+    },
+    messages: {
+        noGlobalObjectCall: {
+            primary: "{{ name }} is not a function and cannot be called directly.",
+            secondary: [
+                "{{ name }} is a built-in global object that provides utility methods and properties.",
+                "It is not a constructor or function and cannot be called or instantiated.",
+            ],
+            suggestions: [
+                "Use the static methods available on {{ name }} instead (e.g., {{ name }}.methodName()).",
+            ],
+        },
+    },
+    setup(context) {
+        function reportGlobalObjectCall(expression, name) {
+            context.report({
+                data: { name },
+                message: "noGlobalObjectCall",
+                range: getTSNodeRange(expression, context.sourceFile),
+            });
+        }
+        function checkNode({ expression }) {
+            if (ts.isIdentifier(expression) && globalObjects.has(expression.text)) {
+                reportGlobalObjectCall(expression, expression.text);
+            }
+        }
+        return {
+            visitors: {
+                CallExpression: checkNode,
+                NewExpression: checkNode,
+            },
+        };
+    },
+});

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

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

package/lib/rules/globalObjectCalls.test.js

@@ -0,0 +1,93 @@
+import rule from "./globalObjectCalls.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+const result = Math();
+`,
+            snapshot: `
+const result = Math();
+               ~~~~
+               Math is not a function and cannot be called directly.
+`,
+        },
+        {
+            code: `
+const data = JSON();
+`,
+            snapshot: `
+const data = JSON();
+             ~~~~
+             JSON is not a function and cannot be called directly.
+`,
+        },
+        {
+            code: `
+const reflected = Reflect();
+`,
+            snapshot: `
+const reflected = Reflect();
+                  ~~~~~~~
+                  Reflect is not a function and cannot be called directly.
+`,
+        },
+        {
+            code: `
+const atomic = Atomics();
+`,
+            snapshot: `
+const atomic = Atomics();
+               ~~~~~~~
+               Atomics is not a function and cannot be called directly.
+`,
+        },
+        {
+            code: `
+const instance = new Math();
+`,
+            snapshot: `
+const instance = new Math();
+                     ~~~~
+                     Math is not a function and cannot be called directly.
+`,
+        },
+        {
+            code: `
+const instance = new JSON();
+`,
+            snapshot: `
+const instance = new JSON();
+                     ~~~~
+                     JSON is not a function and cannot be called directly.
+`,
+        },
+        {
+            code: `
+const instance = new Reflect();
+`,
+            snapshot: `
+const instance = new Reflect();
+                     ~~~~~~~
+                     Reflect is not a function and cannot be called directly.
+`,
+        },
+        {
+            code: `
+const instance = new Atomics();
+`,
+            snapshot: `
+const instance = new Atomics();
+                     ~~~~~~~
+                     Atomics is not a function and cannot be called directly.
+`,
+        },
+    ],
+    valid: [
+        `const value = Math.abs(-5);`,
+        `const parsed = JSON.parse("{}");`,
+        `const stringified = JSON.stringify({});`,
+        `const keys = Reflect.ownKeys({});`,
+        `const result = Atomics.add(buffer, 0, 1);`,
+    ],
+});

package/lib/rules/negativeZeroComparisons.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports comparisons with -0 that may not behave as expected.";
+    readonly id: "negativeZeroComparisons";
+    readonly preset: "logical";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "unexpectedNegativeZeroComparison", undefined>;
+export default _default;

package/lib/rules/negativeZeroComparisons.js

@@ -0,0 +1,65 @@
+import * as ts from "typescript";
+import { typescriptLanguage } from "../language.js";
+import { isComparisonOperator, isEqualityOperator, isNegatedEqualityOperator, } from "./utils/operators.js";
+function isNegativeZero(node) {
+    return (ts.isPrefixUnaryExpression(node) &&
+        node.operator === ts.SyntaxKind.MinusToken &&
+        ts.isNumericLiteral(node.operand) &&
+        node.operand.text === "0");
+}
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports comparisons with -0 that may not behave as expected.",
+        id: "negativeZeroComparisons",
+        preset: "logical",
+    },
+    messages: {
+        unexpectedNegativeZeroComparison: {
+            primary: "Comparisons with -0 using {{ operator }} do not distinguish between -0 and +0.",
+            secondary: [
+                "In JavaScript, -0 and +0 are considered equal when using comparison operators like === or ==, even though they are distinct values.",
+                "To properly check for -0, use `Object.is(value, -0)` which correctly distinguishes between -0 and +0.",
+            ],
+            suggestions: ["Use `Object.is()` to reliably check if a value is -0."],
+        },
+    },
+    setup(context) {
+        function generateObjectIsText(node, isNegated) {
+            const leftText = node.left.getText(context.sourceFile);
+            const rightText = node.right.getText(context.sourceFile);
+            const objectIsCall = `Object.is(${leftText}, ${rightText})`;
+            return isNegated ? `!${objectIsCall}` : objectIsCall;
+        }
+        return {
+            visitors: {
+                BinaryExpression: (node) => {
+                    if (!isComparisonOperator(node.operatorToken) ||
+                        (!isNegativeZero(node.left) && !isNegativeZero(node.right))) {
+                        return;
+                    }
+                    const operator = node.operatorToken.getText(context.sourceFile);
+                    const range = {
+                        begin: node.getStart(context.sourceFile),
+                        end: node.getEnd(),
+                    };
+                    context.report({
+                        data: {
+                            operator,
+                        },
+                        message: "unexpectedNegativeZeroComparison",
+                        range,
+                        suggestions: isEqualityOperator(node.operatorToken)
+                            ? [
+                                {
+                                    id: "useObjectIs",
+                                    range,
+                                    text: generateObjectIsText(node, isNegatedEqualityOperator(node.operatorToken)),
+                                },
+                            ]
+                            : undefined,
+                    });
+                },
+            },
+        };
+    },
+});

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

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

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),
+                        });
+                    }
+                },
+            },
+        };
+    },
+});