@flint.fyi/ts 0.14.3 → 0.14.5

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/octalNumbers.test.js

@@ -159,8 +159,8 @@ function calculate() {
             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?
+	       ~~~
+	       This legacy octal numeric literal evaluates to 63. Did you mean that value, or to use a modern octal syntax such as 0o77?
 }
 `,
             suggestions: [

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;

package/lib/rules/selfAssignments.js

@@ -0,0 +1,44 @@
+import * as ts from "typescript";
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+import { hasSameTokens } from "../utils/hasSameTokens.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports self-assignments which have no effect and are likely errors.",
+        id: "selfAssignments",
+        preset: "logical",
+    },
+    messages: {
+        selfAssignment: {
+            primary: "This value is being assigned to itself, which does nothing.",
+            secondary: [
+                "Self-assignments have no effect and typically indicate an incomplete refactoring or copy-paste error.",
+            ],
+            suggestions: [
+                "Review the assignment and ensure you're assigning the correct value.",
+            ],
+        },
+    },
+    setup(context) {
+        return {
+            visitors: {
+                BinaryExpression: (node) => {
+                    if (node.operatorToken.kind !== ts.SyntaxKind.EqualsToken &&
+                        node.operatorToken.kind !==
+                            ts.SyntaxKind.AmpersandAmpersandEqualsToken &&
+                        node.operatorToken.kind !== ts.SyntaxKind.BarBarEqualsToken &&
+                        node.operatorToken.kind !==
+                            ts.SyntaxKind.QuestionQuestionEqualsToken) {
+                        return;
+                    }
+                    if (hasSameTokens(node.left, node.right, context.sourceFile)) {
+                        context.report({
+                            message: "selfAssignment",
+                            range: getTSNodeRange(node, context.sourceFile),
+                        });
+                    }
+                },
+            },
+        };
+    },
+});

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

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

package/lib/rules/selfAssignments.test.js

@@ -0,0 +1,66 @@
+import { ruleTester } from "./ruleTester.js";
+import rule from "./selfAssignments.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+value = value;
+`,
+            snapshot: `
+value = value;
+~~~~~~~~~~~~~
+This value is being assigned to itself, which does nothing.
+`,
+        },
+        {
+            code: `
+count &&= count;
+`,
+            snapshot: `
+count &&= count;
+~~~~~~~~~~~~~~~
+This value is being assigned to itself, which does nothing.
+`,
+        },
+        {
+            code: `
+flag ||= flag;
+`,
+            snapshot: `
+flag ||= flag;
+~~~~~~~~~~~~~
+This value is being assigned to itself, which does nothing.
+`,
+        },
+        {
+            code: `
+data ??= data;
+`,
+            snapshot: `
+data ??= data;
+~~~~~~~~~~~~~
+This value is being assigned to itself, which does nothing.
+`,
+        },
+        {
+            code: `
+a.b ??= a.b;
+`,
+            snapshot: `
+a.b ??= a.b;
+~~~~~~~~~~~
+This value is being assigned to itself, which does nothing.
+`,
+        },
+    ],
+    valid: [
+        `value = other;`,
+        `first = second;`,
+        `let value = value;`,
+        `const data = data;`,
+        `value += value;`,
+        `count -= count;`,
+        `a ||= b;`,
+        `a.b ||= a.c;`,
+    ],
+});

package/lib/rules/selfComparisons.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports comparing a value to itself.";
+    readonly id: "selfComparisons";
+    readonly preset: "logical";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noSelfComparison", undefined>;
+export default _default;

package/lib/rules/selfComparisons.js

@@ -0,0 +1,41 @@
+import { typescriptLanguage } from "../language.js";
+import { hasSameTokens } from "../utils/hasSameTokens.js";
+import { isComparisonOperator } from "./utils/operators.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports comparing a value to itself.",
+        id: "selfComparisons",
+        preset: "logical",
+    },
+    messages: {
+        noSelfComparison: {
+            primary: "Comparing a value to itself is unnecessary and likely indicates a logic error.",
+            secondary: [
+                "Self-comparisons always evaluate to the same result for a given operator.",
+                "This pattern often indicates a copy-paste error or typo where different variables were intended.",
+            ],
+            suggestions: [
+                "Verify that you intended to compare two different values.",
+                "If checking for NaN, use `Number.isNaN()` or `isNaN()` instead.",
+            ],
+        },
+    },
+    setup(context) {
+        return {
+            visitors: {
+                BinaryExpression: (node) => {
+                    if (isComparisonOperator(node.operatorToken) &&
+                        hasSameTokens(node.left, node.right, context.sourceFile)) {
+                        context.report({
+                            message: "noSelfComparison",
+                            range: {
+                                begin: node.getStart(context.sourceFile),
+                                end: node.getEnd(),
+                            },
+                        });
+                    }
+                },
+            },
+        };
+    },
+});

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

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