eslint-plugin-ts-std-forge 0.1.3 → 0.1.5

package/src/rules/prefer-safe-array-length-guard.mts

@@ -3,7 +3,12 @@ import {
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
-import { type ReadonlyRecord } from 'ts-type-forge';
+import type { ReadonlyRecord } from 'ts-type-forge';
+import {
+  getArgumentText,
+  getValueType,
+  skipTypeWrappers,
+} from './ast-utils.mjs';
 import {
   buildImportFixes,
   getNamedImports,
@@ -79,28 +84,28 @@ export const preferSafeArrayLengthGuard: TSESLint.RuleModule<
 
     const tsStdForgeImport = getTsStdForgeImport(program);
 
-    const services = sourceCode.parserServices;
-
-    const checker = services?.program?.getTypeChecker();
+    const checker = sourceCode.parserServices?.program?.getTypeChecker();
 
     /**
      * Whether `expression` is an array or tuple. Without type information the
      * answer is no: `.length` is also a string's, a function's and a
-     * `TypedArray`'s, and none of those can be handed to the guard.
+     * `TypedArray`'s, and none of those can be handed to the guard. The type is
+     * the value's, not a cast's: a string cast to an array is still a string.
      */
     const isArrayLike = (
       // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
       expression: TSESTree.Expression,
     ): boolean => {
-      if (checker === undefined) return false;
-
-      const tsNode = services?.esTreeNodeToTSNodeMap?.get(expression);
-
-      if (tsNode === undefined) return false;
+      if (checker === undefined) {
+        return false;
+      }
 
-      const type = checker.getTypeAtLocation(tsNode);
+      const type = getValueType(sourceCode, expression);
 
-      return checker.isArrayType(type) || checker.isTupleType(type);
+      return (
+        type !== undefined &&
+        (checker.isArrayType(type) || checker.isTupleType(type))
+      );
     };
 
     const mut_nodesToFix: {
@@ -113,9 +118,13 @@ export const preferSafeArrayLengthGuard: TSESLint.RuleModule<
       BinaryExpression: (node) => {
         const matched = matchLengthComparison(node);
 
-        if (matched === undefined) return;
+        if (matched === undefined) {
+          return;
+        }
 
-        if (!isArrayLike(matched.arrayExpression)) return;
+        if (!isArrayLike(matched.arrayExpression)) {
+          return;
+        }
 
         mut_nodesToFix.push({ node, ...matched });
       },
@@ -132,7 +141,7 @@ export const preferSafeArrayLengthGuard: TSESLint.RuleModule<
           index,
           { node, arrayExpression, guard },
         ] of mut_nodesToFix.entries()) {
-          const arrayText = sourceCode.getText(arrayExpression);
+          const arrayText = getArgumentText(sourceCode, arrayExpression);
 
           context.report({
             node,
@@ -172,9 +181,11 @@ const matchLengthComparison = (
 ):
   | Readonly<{ arrayExpression: TSESTree.Expression; guard: Guard }>
   | undefined => {
-  const { left, right } = node;
+  // Both operands are read through their type wrappers, which change neither
+  // the length nor the bound: `(xs.length as number) > (0 as const)`.
+  const left = skipTypeWrappers(node.left);
 
-  if (left.type === AST_NODE_TYPES.PrivateIdentifier) return undefined;
+  const right = skipTypeWrappers(node.right);
 
   const lengthOnLeft = isLengthAccess(left);
 
@@ -182,7 +193,9 @@ const matchLengthComparison = (
 
   const boundSide = lengthOnLeft ? right : left;
 
-  if (!isLengthAccess(lengthSide)) return undefined;
+  if (!isLengthAccess(lengthSide)) {
+    return undefined;
+  }
 
   // `xs.length === ys.length` has `.length` on both sides and no literal
   // bound, so the bound check below rejects it.
@@ -206,7 +219,7 @@ const matchLengthComparison = (
 
 const isLengthAccess = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  node: TSESTree.Expression,
+  node: TSESTree.Node,
 ): node is TSESTree.MemberExpression =>
   node.type === AST_NODE_TYPES.MemberExpression &&
   !node.computed &&

package/src/rules/prefer-safe-array-length-guard.test.mts

@@ -150,3 +150,101 @@ describe('prefer-safe-array-length-guard', () => {
     ],
   });
 });
+
+describe('prefer-safe-array-length-guard through type wrappers', () => {
+  tester.run('prefer-safe-array-length-guard', preferSafeArrayLengthGuard, {
+    valid: [
+      {
+        name: 'a string cast to an array is still a string',
+        code: dedent`
+          declare const s: string;
+          const ok = (s as unknown as readonly string[]).length > 0;
+        `,
+      },
+      {
+        name: 'a bound with no named guard behind `as const` is left alone',
+        code: dedent`
+          declare const xs: readonly number[];
+          const ok = xs.length > (2 as const);
+        `,
+      },
+    ],
+    invalid: [
+      {
+        name: 'reads the bound through `as const`',
+        code: dedent`
+          declare const xs: readonly number[];
+          const ok = xs.length > (0 as const);
+        `,
+        output: dedent`
+          import { SafeArray } from 'ts-std-forge';
+          declare const xs: readonly number[];
+          const ok = SafeArray.isNonEmpty(xs);
+        `,
+        errors: [{ messageId: 'useIsNonEmpty' }],
+      },
+      {
+        name: 'reads the length through `as`',
+        code: dedent`
+          declare const xs: readonly number[];
+          const ok = (xs.length as number) > 0;
+        `,
+        output: dedent`
+          import { SafeArray } from 'ts-std-forge';
+          declare const xs: readonly number[];
+          const ok = SafeArray.isNonEmpty(xs);
+        `,
+        errors: [{ messageId: 'useIsNonEmpty' }],
+      },
+      {
+        name: 'reads the length through `!`, with the bound on the left',
+        code: dedent`
+          declare const xs: readonly number[];
+          const ok = (0 satisfies number) === xs.length!;
+        `,
+        output: dedent`
+          import { SafeArray } from 'ts-std-forge';
+          declare const xs: readonly number[];
+          const ok = SafeArray.isEmpty(xs);
+        `,
+        errors: [{ messageId: 'useIsEmpty' }],
+      },
+      {
+        name: 'keeps a wrapper on the array and reads `!` as the array it asserts',
+        code: dedent`
+          declare const xs: readonly number[] | undefined;
+          const ok = xs!.length !== 0;
+        `,
+        output: dedent`
+          import { SafeArray } from 'ts-std-forge';
+          declare const xs: readonly number[] | undefined;
+          const ok = SafeArray.isNonEmpty(xs!);
+        `,
+        errors: [{ messageId: 'useIsNonEmpty' }],
+      },
+    ],
+  });
+});
+
+describe('prefer-safe-array-length-guard with parenthesized operands', () => {
+  tester.run('prefer-safe-array-length-guard', preferSafeArrayLengthGuard, {
+    valid: [],
+    invalid: [
+      {
+        name: 'keeps the parentheses of a sequence array',
+        code: dedent`
+          declare const a: number;
+          declare const xs: readonly number[];
+          const ok = (a, xs).length > 0;
+        `,
+        output: dedent`
+          import { SafeArray } from 'ts-std-forge';
+          declare const a: number;
+          declare const xs: readonly number[];
+          const ok = SafeArray.isNonEmpty((a, xs));
+        `,
+        errors: [{ messageId: 'useIsNonEmpty' }],
+      },
+    ],
+  });
+});

package/src/rules/prefer-safe-number-parse-integer.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,
@@ -62,8 +68,6 @@ export const preferSafeNumberParseInteger: TSESLint.RuleModule<
 
     const tsStdForgeImport = getTsStdForgeImport(program);
 
-    const services = sourceCode.parserServices;
-
     const mut_nodesToFix: {
       node: TSESTree.CallExpression;
       argExpression: TSESTree.Expression;
@@ -71,7 +75,7 @@ export const preferSafeNumberParseInteger: TSESLint.RuleModule<
 
     return {
       CallExpression: (node) => {
-        const { callee } = node;
+        const callee = skipTypeWrappers(node.callee);
 
         // Match `parseInt(...)` or `Number.parseInt(...)`.
         const isGlobalParseInt =
@@ -81,25 +85,32 @@ export const preferSafeNumberParseInteger: TSESLint.RuleModule<
         const isNumberParseInt =
           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 === 'parseInt';
 
-        if (!isGlobalParseInt && !isNumberParseInt) return;
+        if (!isGlobalParseInt && !isNumberParseInt) {
+          return;
+        }
 
         const args = node.arguments;
 
         const firstArg = args[0];
 
-        if (firstArg === undefined) return;
+        if (firstArg === undefined) {
+          return;
+        }
 
         // Spread argument (`parseInt(...rest)`) cannot be rewritten safely.
-        if (firstArg.type === AST_NODE_TYPES.SpreadElement) return;
+        if (firstArg.type === AST_NODE_TYPES.SpreadElement) {
+          return;
+        }
 
-        // Only base 10: accept a missing radix or an explicit literal `10`.
+        // Only base 10: accept a missing radix or an explicit literal `10`,
+        // read through its type wrappers, which leave the value as it is.
         if (args.length >= 2) {
-          const radix = args[1];
+          const radix =
+            args[1] === undefined ? undefined : skipTypeWrappers(args[1]);
 
           if (radix?.type !== AST_NODE_TYPES.Literal || radix.value !== 10) {
             return;
@@ -107,19 +118,14 @@ export const preferSafeNumberParseInteger: TSESLint.RuleModule<
         }
 
         // The argument must be a `string` so the autofix is type-safe against
-        // `SafeNumber.parseInteger(value: string)`. Without type information,
-        // skip.
-        if (services?.program == null) return;
+        // `SafeNumber.parseInteger(value: string)`, and that of the value, not
+        // of a cast: `parseInt(1e21 as unknown as string)` is 1, the rewrite
+        // 1e21. Without type information, skip.
+        const argType = getValueType(sourceCode, firstArg);
 
-        const checker = services.program.getTypeChecker();
-
-        const tsNode = services.esTreeNodeToTSNodeMap?.get(firstArg);
-
-        if (tsNode === undefined) return;
-
-        const argType = checker.getTypeAtLocation(tsNode);
-
-        if (!isStringType(argType)) return;
+        if (argType === undefined || !isStringType(argType)) {
+          return;
+        }
 
         mut_nodesToFix.push({ node, argExpression: firstArg });
       },
@@ -134,7 +140,7 @@ export const preferSafeNumberParseInteger: TSESLint.RuleModule<
           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-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';
 
@@ -94,31 +97,32 @@ export const preferSafeNumberParse: TSESLint.RuleModule<MessageIds, Options> = {
         const isNumberCall =
           callee.type === AST_NODE_TYPES.Identifier && callee.name === 'Number';
 
-        if (!isGlobalParseFloat && !isNumberParseFloat && !isNumberCall) return;
+        if (!isGlobalParseFloat && !isNumberParseFloat && !isNumberCall) {
+          return;
+        }
 
         const args = node.arguments;
 
         const firstArg = args[0];
 
-        if (firstArg === undefined) return;
+        if (firstArg === undefined) {
+          return;
+        }
 
         // Spread argument (`parseFloat(...rest)`) cannot be rewritten safely.
-        if (firstArg.type === AST_NODE_TYPES.SpreadElement) return;
+        if (firstArg.type === AST_NODE_TYPES.SpreadElement) {
+          return;
+        }
 
         // 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;
+        // 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);
 
-        const checker = services.program.getTypeChecker();
-
-        const tsNode = services.esTreeNodeToTSNodeMap?.get(firstArg);
-
-        if (tsNode === undefined) return;
-
-        const argType = checker.getTypeAtLocation(tsNode);
-
-        if (!isStringType(argType)) return;
+        if (argType === undefined || !isStringType(argType)) {
+          return;
+        }
 
         mut_nodesToFix.push({ node, argExpression: firstArg });
       },
@@ -133,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>;