@flint.fyi/ts 0.14.2 → 0.14.4

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

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

package/lib/rules/nonOctalDecimalEscapes.js

@@ -0,0 +1,57 @@
+import { typescriptLanguage } from "../language.js";
+const nonOctalDecimalEscapePattern = /\\[89]/g;
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports non-octal decimal escape sequences (\\8 and \\9) in string literals.",
+        id: "nonOctalDecimalEscapes",
+        preset: "logical",
+    },
+    messages: {
+        unexpectedEscape: {
+            primary: "Non-octal decimal escape sequences (\\8 and \\9) should not be used in string literals.",
+            secondary: [
+                "Non-octal decimal escape sequences \\8 and \\9 are legacy features that are treated as identity escapes (the same as the literal digits).",
+                "They are optional in the ECMAScript specification and not supported in strict mode in all environments.",
+                "Use the literal digits directly instead.",
+            ],
+            suggestions: [
+                "Remove the backslash to use the literal digit.",
+                "If an escape sequence is needed, use a Unicode escape like \\u0038 or \\u0039.",
+            ],
+        },
+    },
+    setup(context) {
+        function checkNode(node) {
+            const text = node.getText(context.sourceFile);
+            const matches = [...text.matchAll(nonOctalDecimalEscapePattern)];
+            for (const match of matches) {
+                // Ignore escapes where the backslash itself is escaped (e.g. "\\\\8" -> literal "\\8").
+                // Count the number of consecutive backslashes immediately before the match.
+                const matchIndex = match.index;
+                let backslashesBefore = 0;
+                for (let i = matchIndex - 1; i >= 0 && text[i] === "\\"; i--) {
+                    backslashesBefore++;
+                }
+                // If there is an odd number of backslashes before this one, the backslash is escaped
+                // and should not be treated as an escape sequence.
+                if (backslashesBefore % 2 === 1) {
+                    continue;
+                }
+                const start = node.getStart(context.sourceFile) + matchIndex;
+                context.report({
+                    message: "unexpectedEscape",
+                    range: {
+                        begin: start,
+                        end: start + match[0].length,
+                    },
+                });
+            }
+        }
+        return {
+            visitors: {
+                NoSubstitutionTemplateLiteral: checkNode,
+                StringLiteral: checkNode,
+            },
+        };
+    },
+});

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

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

package/lib/rules/nonOctalDecimalEscapes.test.js

@@ -0,0 +1,69 @@
+import rule from "./nonOctalDecimalEscapes.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+"\\8"
+`,
+            snapshot: `
+"\\8"
+ ~~
+ Non-octal decimal escape sequences (\\8 and \\9) should not be used in string literals.
+`,
+        },
+        {
+            code: `
+"\\9"
+`,
+            snapshot: `
+"\\9"
+ ~~
+ Non-octal decimal escape sequences (\\8 and \\9) should not be used in string literals.
+`,
+        },
+        {
+            code: `
+"w\\8less"
+`,
+            snapshot: `
+"w\\8less"
+  ~~
+  Non-octal decimal escape sequences (\\8 and \\9) should not be used in string literals.
+`,
+        },
+        {
+            code: `
+"December 1\\9"
+`,
+            snapshot: `
+"December 1\\9"
+           ~~
+           Non-octal decimal escape sequences (\\8 and \\9) should not be used in string literals.
+`,
+        },
+        {
+            code: `
+"Don't use \\8 and \\9 escapes."
+`,
+            snapshot: `
+"Don't use \\8 and \\9 escapes."
+           ~~
+           Non-octal decimal escape sequences (\\8 and \\9) should not be used in string literals.
+                  ~~
+                  Non-octal decimal escape sequences (\\8 and \\9) should not be used in string literals.
+`,
+        },
+        {
+            code: `
+"\\0\\8"
+`,
+            snapshot: `
+"\\0\\8"
+   ~~
+   Non-octal decimal escape sequences (\\8 and \\9) should not be used in string literals.
+`,
+        },
+    ],
+    valid: ['"8"', '"9"', '"w8less"', '"December 19"', '"\\\\8"', '"\\0\\u0038"'],
+});

package/lib/rules/numericLiteralParsing.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports parseInt calls with binary, hexadecimal, or octal strings that can be replaced with numeric literals.";
+    readonly id: "numericLiteralParsing";
+    readonly preset: "stylistic";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "preferLiteral", undefined>;
+export default _default;

package/lib/rules/numericLiteralParsing.js

@@ -0,0 +1,97 @@
+import * as ts from "typescript";
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+import { isGlobalDeclaration } from "../utils/isGlobalDeclaration.js";
+function convertToLiteral(value, radix) {
+    const parsed = Number.parseInt(value, radix);
+    if (Number.isNaN(parsed)) {
+        return value;
+    }
+    switch (radix) {
+        case 2:
+            return `0b${parsed.toString(2)}`;
+        case 8:
+            return `0o${parsed.toString(8)}`;
+        case 16:
+            return `0x${parsed.toString(16).toUpperCase()}`;
+        default:
+            return value;
+    }
+}
+function getRadixValue(node) {
+    if (!ts.isNumericLiteral(node)) {
+        return undefined;
+    }
+    const value = Number(node.text);
+    if (![2, 8, 16].includes(value)) {
+        return undefined;
+    }
+    return value;
+}
+// TODO: Use a util like getStaticValue
+function getStringValue(node) {
+    return ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)
+        ? node.text
+        : undefined;
+}
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports parseInt calls with binary, hexadecimal, or octal strings that can be replaced with numeric literals.",
+        id: "numericLiteralParsing",
+        preset: "stylistic",
+    },
+    messages: {
+        preferLiteral: {
+            primary: "Use {{ literal }} instead of parseInt with radix {{ radix }}.",
+            secondary: [
+                "Binary, octal, and hexadecimal numeric literals are more readable and direct than using parseInt with a radix.",
+                "Numeric literals are supported natively and don't require function calls.",
+            ],
+            suggestions: ["Replace the parseInt call with the numeric literal."],
+        },
+    },
+    setup(context) {
+        function checkParseIntCall(node) {
+            if (node.arguments.length !== 2) {
+                return;
+            }
+            const stringValue = getStringValue(node.arguments[0]);
+            if (!stringValue) {
+                return;
+            }
+            const radixValue = getRadixValue(node.arguments[1]);
+            if (!radixValue) {
+                return;
+            }
+            context.report({
+                data: {
+                    literal: convertToLiteral(stringValue, radixValue),
+                    radix: String(radixValue),
+                },
+                message: "preferLiteral",
+                range: getTSNodeRange(node, context.sourceFile),
+            });
+        }
+        return {
+            visitors: {
+                CallExpression: (node) => {
+                    if (ts.isIdentifier(node.expression)) {
+                        if (node.expression.text === "parseInt" &&
+                            isGlobalDeclaration(node.expression, context.typeChecker)) {
+                            checkParseIntCall(node);
+                        }
+                    }
+                    else if (ts.isPropertyAccessExpression(node.expression)) {
+                        if (ts.isIdentifier(node.expression.expression) &&
+                            node.expression.expression.text === "Number" &&
+                            ts.isIdentifier(node.expression.name) &&
+                            node.expression.name.text === "parseInt" &&
+                            isGlobalDeclaration(node.expression.expression, context.typeChecker)) {
+                            checkParseIntCall(node);
+                        }
+                    }
+                },
+            },
+        };
+    },
+});

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

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

package/lib/rules/numericLiteralParsing.test.js

@@ -0,0 +1,99 @@
+import rule from "./numericLiteralParsing.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+const binary = parseInt("111110111", 2);
+`,
+            snapshot: `
+const binary = parseInt("111110111", 2);
+               ~~~~~~~~~~~~~~~~~~~~~~~~
+               Use 0b111110111 instead of parseInt with radix 2.
+`,
+        },
+        {
+            code: `
+const octal = parseInt("767", 8);
+`,
+            snapshot: `
+const octal = parseInt("767", 8);
+              ~~~~~~~~~~~~~~~~~~
+              Use 0o767 instead of parseInt with radix 8.
+`,
+        },
+        {
+            code: `
+const hex = parseInt("1F7", 16);
+`,
+            snapshot: `
+const hex = parseInt("1F7", 16);
+            ~~~~~~~~~~~~~~~~~~~
+            Use 0x1F7 instead of parseInt with radix 16.
+`,
+        },
+        {
+            code: `
+const value = Number.parseInt("111110111", 2);
+`,
+            snapshot: `
+const value = Number.parseInt("111110111", 2);
+              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+              Use 0b111110111 instead of parseInt with radix 2.
+`,
+        },
+        {
+            code: `
+const result = Number.parseInt("767", 8);
+`,
+            snapshot: `
+const result = Number.parseInt("767", 8);
+               ~~~~~~~~~~~~~~~~~~~~~~~~~
+               Use 0o767 instead of parseInt with radix 8.
+`,
+        },
+        {
+            code: `
+const num = Number.parseInt("1F7", 16);
+`,
+            snapshot: `
+const num = Number.parseInt("1F7", 16);
+            ~~~~~~~~~~~~~~~~~~~~~~~~~~
+            Use 0x1F7 instead of parseInt with radix 16.
+`,
+        },
+        {
+            code: `
+const value = parseInt(\`111110111\`, 2);
+`,
+            snapshot: `
+const value = parseInt(\`111110111\`, 2);
+              ~~~~~~~~~~~~~~~~~~~~~~~~
+              Use 0b111110111 instead of parseInt with radix 2.
+`,
+        },
+    ],
+    valid: [
+        `const decimal = parseInt("123");`,
+        `const value = parseInt("123", 10);`,
+        `const ternary = parseInt("102", 3);`,
+        `const binary = 0b111110111;`,
+        `const octal = 0o767;`,
+        `const hex = 0x1F7;`,
+        `const dynamic = parseInt(value, 2);`,
+        `const variable = parseInt("111", radix);`,
+        `const single = parseInt("111");`,
+        `Number.parseInt("123");`,
+        `Number.parseInt("123", 10);`,
+        `
+			function parseInt(...values: unknown[]) {}
+			parseInt("1", 2);
+			export {};
+		`,
+        `
+			const Number = { parseInt(...values: unknown[]) {} };
+			Number.parseInt("1", 2);
+			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 {};