eslint-plugin-ts-std-forge 0.1.4 → 0.1.6

package/src/rules/prefer-safe-number-parse-integer.test.mts

@@ -65,3 +65,107 @@ describe('prefer-safe-number-parse-integer', () => {
     ],
   });
 });
+
+describe('prefer-safe-number-parse-integer through type wrappers', () => {
+  tester.run('prefer-safe-number-parse-integer', preferSafeNumberParseInteger, {
+    valid: [
+      {
+        // `parseInt(1e21)` is 1, `SafeNumber.parseInteger(1e21)` is 1e21.
+        name: 'ignores a number cast to string',
+        code: dedent`
+          declare const x: number;
+          const n = parseInt(x as unknown as string);
+        `,
+      },
+      {
+        name: 'ignores a radix other than 10 behind `as const`',
+        code: dedent`
+          declare const s: string;
+          const n = parseInt(s, 16 as const);
+        `,
+      },
+    ],
+    invalid: [
+      {
+        name: 'reads a radix of 10 through `as const`',
+        code: dedent`
+          declare const s: string;
+          const n = parseInt(s, 10 as const);
+        `,
+        output: dedent`
+          import { Result, SafeNumber } from 'ts-std-forge';
+          declare const s: string;
+          const n = Result.unwrapOkOr(SafeNumber.parseInteger(s), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeNumberParseInteger' }],
+      },
+      {
+        name: 'reads a radix of 10 through `satisfies` and keeps `satisfies` on the argument',
+        code: dedent`
+          declare const s: string;
+          const n = Number.parseInt(s satisfies string, 10 satisfies number);
+        `,
+        output: dedent`
+          import { Result, SafeNumber } from 'ts-std-forge';
+          declare const s: string;
+          const n = Result.unwrapOkOr(SafeNumber.parseInteger(s satisfies string), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeNumberParseInteger' }],
+      },
+      {
+        name: 'reads the callee through `as` and `!`',
+        code: dedent`
+          declare const s: string;
+          const a = (parseInt as typeof parseInt)(s);
+          const b = (Number as NumberConstructor)!.parseInt(s, 10);
+        `,
+        output: dedent`
+          import { Result, SafeNumber } from 'ts-std-forge';
+          declare const s: string;
+          const a = Result.unwrapOkOr(SafeNumber.parseInteger(s), Number.NaN);
+          const b = Result.unwrapOkOr(SafeNumber.parseInteger(s), Number.NaN);
+        `,
+        errors: [
+          { messageId: 'useSafeNumberParseInteger' },
+          { messageId: 'useSafeNumberParseInteger' },
+        ],
+      },
+      {
+        name: 'reads `!` on an optional string as the string it asserts',
+        code: dedent`
+          declare const s: string | undefined;
+          const n = parseInt(s!);
+        `,
+        output: dedent`
+          import { Result, SafeNumber } from 'ts-std-forge';
+          declare const s: string | undefined;
+          const n = Result.unwrapOkOr(SafeNumber.parseInteger(s!), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeNumberParseInteger' }],
+      },
+    ],
+  });
+});
+
+describe('prefer-safe-number-parse-integer with parenthesized operands', () => {
+  tester.run('prefer-safe-number-parse-integer', preferSafeNumberParseInteger, {
+    valid: [],
+    invalid: [
+      {
+        name: 'keeps the parentheses of a sequence argument',
+        code: dedent`
+          declare const a: number;
+          declare const s: string;
+          const n = parseInt((a, s), (10));
+        `,
+        output: dedent`
+          import { Result, SafeNumber } from 'ts-std-forge';
+          declare const a: number;
+          declare const s: string;
+          const n = Result.unwrapOkOr(SafeNumber.parseInteger((a, s)), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeNumberParseInteger' }],
+      },
+    ],
+  });
+});

package/src/rules/prefer-safe-number-parse.mts

@@ -4,6 +4,12 @@ import {
   type TSESTree,
 } from '@typescript-eslint/utils';
 import * as ts from 'typescript';
+import {
+  getArgumentText,
+  getValueType,
+  isIdentifierNamed,
+  skipTypeWrappers,
+} from './ast-utils.mjs';
 import {
   buildImportFixes,
   getNamedImports,
@@ -65,8 +71,6 @@ export const preferSafeNumberParse: TSESLint.RuleModule<MessageIds, Options> = {
 
     const tsStdForgeImport = getTsStdForgeImport(program);
 
-    const services = sourceCode.parserServices;
-
     const mut_nodesToFix: {
       node: TSESTree.CallExpression;
       argExpression: TSESTree.Expression;
@@ -74,7 +78,7 @@ export const preferSafeNumberParse: TSESLint.RuleModule<MessageIds, Options> = {
 
     return {
       CallExpression: (node) => {
-        const { callee } = node;
+        const callee = skipTypeWrappers(node.callee);
 
         // Match `parseFloat(...)` (global function).
         const isGlobalParseFloat =
@@ -85,8 +89,7 @@ export const preferSafeNumberParse: TSESLint.RuleModule<MessageIds, Options> = {
         const isNumberParseFloat =
           callee.type === AST_NODE_TYPES.MemberExpression &&
           !callee.computed &&
-          callee.object.type === AST_NODE_TYPES.Identifier &&
-          callee.object.name === 'Number' &&
+          isIdentifierNamed(callee.object, 'Number') &&
           callee.property.type === AST_NODE_TYPES.Identifier &&
           callee.property.name === 'parseFloat';
 
@@ -112,23 +115,12 @@ export const preferSafeNumberParse: TSESLint.RuleModule<MessageIds, Options> = {
         }
 
         // The argument must be purely `string` so the autofix is type-safe
-        // against `SafeNumber.parse(value: string)`. Without type information,
-        // skip.
-        if (services?.program == null) {
-          return;
-        }
-
-        const checker = services.program.getTypeChecker();
-
-        const tsNode = services.esTreeNodeToTSNodeMap?.get(firstArg);
-
-        if (tsNode === undefined) {
-          return;
-        }
-
-        const argType = checker.getTypeAtLocation(tsNode);
+        // against `SafeNumber.parse(value: string)`, and that of the value, not
+        // of a cast: `Number(true as unknown as string)` is 1, the rewrite NaN.
+        // Without type information, skip.
+        const argType = getValueType(sourceCode, firstArg);
 
-        if (!isStringType(argType)) {
+        if (argType === undefined || !isStringType(argType)) {
           return;
         }
 
@@ -145,7 +137,7 @@ export const preferSafeNumberParse: TSESLint.RuleModule<MessageIds, Options> = {
           index,
           { node, argExpression },
         ] of mut_nodesToFix.entries()) {
-          const argText = sourceCode.getText(argExpression);
+          const argText = getArgumentText(sourceCode, argExpression);
 
           context.report({
             node,

package/src/rules/prefer-safe-number-parse.test.mts

@@ -107,3 +107,100 @@ describe('prefer-safe-number-parse', () => {
     ],
   });
 });
+
+describe('prefer-safe-number-parse through type wrappers', () => {
+  tester.run('prefer-safe-number-parse', preferSafeNumberParse, {
+    valid: [
+      {
+        name: 'ignores a boolean cast to string, which Number() reads as 0 or 1',
+        code: dedent`
+          declare const b: boolean;
+          const n = Number(b as unknown as string);
+        `,
+      },
+      {
+        name: 'ignores a number cast to string with `<T>`',
+        code: dedent`
+          declare const x: number;
+          const n = Number(<string>(<unknown>x));
+        `,
+      },
+      {
+        name: 'ignores a union made to look like a string with `!`',
+        code: dedent`
+          declare const x: string | number | undefined;
+          const n = parseFloat(x! as string);
+        `,
+      },
+    ],
+    invalid: [
+      {
+        name: 'keeps `satisfies` on a string argument',
+        code: dedent`
+          declare const s: string;
+          const n = Number(s satisfies string);
+        `,
+        output: dedent`
+          import { Result, SafeNumber } from 'ts-std-forge';
+          declare const s: string;
+          const n = Result.unwrapOkOr(SafeNumber.parse(s satisfies string), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeNumberParse' }],
+      },
+      {
+        name: 'reads the callee through `as` and `!`',
+        code: dedent`
+          declare const s: string;
+          const a = (Number as NumberConstructor)(s);
+          const b = Number!.parseFloat(s);
+        `,
+        output: dedent`
+          import { Result, SafeNumber } from 'ts-std-forge';
+          declare const s: string;
+          const a = Result.unwrapOkOr(SafeNumber.parse(s), Number.NaN);
+          const b = Result.unwrapOkOr(SafeNumber.parse(s), Number.NaN);
+        `,
+        errors: [
+          { messageId: 'useSafeNumberParse' },
+          { messageId: 'useSafeNumberParse' },
+        ],
+      },
+      {
+        name: 'reads `!` on an optional string as the string it asserts',
+        code: dedent`
+          declare const s: string | undefined;
+          const n = parseFloat(s!);
+        `,
+        output: dedent`
+          import { Result, SafeNumber } from 'ts-std-forge';
+          declare const s: string | undefined;
+          const n = Result.unwrapOkOr(SafeNumber.parse(s!), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeNumberParse' }],
+      },
+    ],
+  });
+});
+
+describe('prefer-safe-number-parse with parenthesized operands', () => {
+  tester.run('prefer-safe-number-parse', preferSafeNumberParse, {
+    valid: [],
+    invalid: [
+      {
+        name: 'keeps the parentheses of a sequence argument',
+        code: dedent`
+          declare const a: number;
+          declare const s: string;
+          const n = parseFloat((a, s));
+        `,
+        output: dedent`
+          import { Result, SafeNumber } from 'ts-std-forge';
+          declare const a: number;
+          declare const s: string;
+          const n = Result.unwrapOkOr(SafeNumber.parse((a, s)), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeNumberParse' }],
+      },
+    ],
+  });
+});

package/src/rules/rules.mts

@@ -1,4 +1,4 @@
-import { type ESLintPlugin } from '../types.mjs';
+import type { ESLintPlugin } from '../types.mjs';
 import { preferIsNonNullObject } from './prefer-is-non-null-object.mjs';
 import { preferIsRecordAndHasKey } from './prefer-is-record-and-has-key.mjs';
 import { preferSafeArrayIsArray } from './prefer-safe-array-is-array.mjs';

package/src/types.mts

@@ -1,5 +1,5 @@
-import { type TSESLint } from '@typescript-eslint/utils';
-import { type DeepReadonly } from 'ts-type-forge';
+import type { TSESLint } from '@typescript-eslint/utils';
+import type { DeepReadonly } from 'ts-type-forge';
 
 export type ESLintPlugin = DeepReadonly<TSESLint.FlatConfig.Plugin>;