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

package/src/rules/prefer-is-record-and-has-key.test.mts

@@ -78,3 +78,131 @@ describe('prefer-is-record-and-has-key', () => {
     ],
   });
 });
+
+describe('prefer-is-record-and-has-key through type wrappers', () => {
+  tester.run('prefer-is-record-and-has-key', preferIsRecordAndHasKey, {
+    valid: [],
+    invalid: [
+      {
+        // `isRecord` rejects an array, so dropping it on the cast's word
+        // would turn `false` into `true`.
+        name: 'keeps isRecord for an array cast to a record',
+        code: dedent`
+          declare const arr: string[];
+          const ok = Object.hasOwn(arr as unknown as Record<string, unknown>, '0');
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-std-forge';
+          declare const arr: string[];
+          const ok = (isRecord(arr as unknown as Record<string, unknown>) && hasKey(arr as unknown as Record<string, unknown>, '0'));
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'keeps isRecord for an unknown value cast to a record in `in`',
+        code: dedent`
+          declare const u: unknown;
+          const ok = 'a' in (<Record<string, unknown>>u);
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-std-forge';
+          declare const u: unknown;
+          const ok = (isRecord(<Record<string, unknown>>u) && hasKey(<Record<string, unknown>>u, 'a'));
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'drops isRecord for a record behind `satisfies` and keeps the wrapper',
+        code: dedent`
+          declare const obj: Readonly<Record<string, unknown>>;
+          const ok = Object.hasOwn(obj satisfies object, 'a');
+        `,
+        output: dedent`
+          import { hasKey } from 'ts-std-forge';
+          declare const obj: Readonly<Record<string, unknown>>;
+          const ok = hasKey(obj satisfies object, 'a');
+        `,
+        errors: [{ messageId: 'useHasKey' }],
+      },
+      {
+        name: 'reads `!` on an optional record as the record it asserts',
+        code: dedent`
+          declare const obj: Readonly<Record<string, unknown>> | undefined;
+          const ok = Object.hasOwn(obj!, 'a');
+        `,
+        output: dedent`
+          import { hasKey } from 'ts-std-forge';
+          declare const obj: Readonly<Record<string, unknown>> | undefined;
+          const ok = hasKey(obj!, 'a');
+        `,
+        errors: [{ messageId: 'useHasKey' }],
+      },
+      {
+        name: 'reads `Object` through `as`',
+        code: dedent`
+          declare const obj: Readonly<Record<string, unknown>>;
+          const ok = (Object as ObjectConstructor).hasOwn(obj, 'a');
+        `,
+        output: dedent`
+          import { hasKey } from 'ts-std-forge';
+          declare const obj: Readonly<Record<string, unknown>>;
+          const ok = hasKey(obj, 'a');
+        `,
+        errors: [{ messageId: 'useHasKey' }],
+      },
+    ],
+  });
+});
+
+describe('prefer-is-record-and-has-key with parenthesized operands', () => {
+  tester.run('prefer-is-record-and-has-key', preferIsRecordAndHasKey, {
+    valid: [],
+    invalid: [
+      {
+        name: 'keeps the parentheses of a sequence object in `in`',
+        code: dedent`
+          declare const a: number;
+          declare const o: unknown;
+          const ok = 'k' in (a, o);
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-std-forge';
+          declare const a: number;
+          declare const o: unknown;
+          const ok = (isRecord((a, o)) && hasKey((a, o), 'k'));
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'keeps the parentheses of a sequence object in Object.hasOwn',
+        code: dedent`
+          declare const a: number;
+          declare const o: unknown;
+          const ok = Object.hasOwn((a, o), 'k');
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-std-forge';
+          declare const a: number;
+          declare const o: unknown;
+          const ok = (isRecord((a, o)) && hasKey((a, o), 'k'));
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'keeps the parentheses of a sequence key',
+        code: dedent`
+          declare const a: number;
+          declare const o: Readonly<Record<string, unknown>>;
+          const ok = (a, 'k') in o;
+        `,
+        output: dedent`
+          import { hasKey } from 'ts-std-forge';
+          declare const a: number;
+          declare const o: Readonly<Record<string, unknown>>;
+          const ok = hasKey(o, (a, 'k'));
+        `,
+        errors: [{ messageId: 'useHasKey' }],
+      },
+    ],
+  });
+});

package/src/rules/prefer-safe-array-is-array.mts

@@ -3,7 +3,11 @@ import {
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
-import { type DeepReadonly } from 'ts-type-forge';
+import {
+  getRangeWithParens,
+  isIdentifierNamed,
+  skipTypeWrappers,
+} from './ast-utils.mjs';
 import {
   buildImportFixes,
   getNamedImports,
@@ -61,20 +65,21 @@ export const preferSafeArrayIsArray: TSESLint.RuleModule<MessageIds, Options> =
               node,
               messageId: 'useSafeArrayIsArray',
               fix: (fixer) => {
-                const callee = node.callee;
-
-                if (callee.type !== AST_NODE_TYPES.MemberExpression) {
-                  return [];
-                }
-
-                const replacement = `SafeArray.isArray${sourceCode.getText(node).slice(sourceCode.getText(callee).length)}`;
-
                 const importFixes =
                   index === 0 && !hasSafeArrayImport
                     ? buildImportFixes(fixer, program, ['SafeArray'])
                     : [];
 
-                return [...importFixes, fixer.replaceText(node, replacement)];
+                // Only the callee is replaced, type wrappers included, along
+                // with the parentheses around it, which its range leaves out;
+                // the arguments stay as written.
+                return [
+                  ...importFixes,
+                  fixer.replaceTextRange(
+                    getRangeWithParens(sourceCode, node.callee),
+                    'SafeArray.isArray',
+                  ),
+                ];
               },
             });
           }
@@ -85,19 +90,18 @@ export const preferSafeArrayIsArray: TSESLint.RuleModule<MessageIds, Options> =
   } as const;
 
 const isArrayIsArrayCall = (
-  node: DeepReadonly<TSESTree.CallExpression>,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: TSESTree.CallExpression,
 ): boolean => {
-  if (node.callee.type !== AST_NODE_TYPES.MemberExpression) {
-    return false;
-  }
+  const callee = skipTypeWrappers(node.callee);
 
-  const { object, property } = node.callee;
-
-  if (object.type !== AST_NODE_TYPES.Identifier) {
+  if (callee.type !== AST_NODE_TYPES.MemberExpression) {
     return false;
   }
 
-  if (object.name !== 'Array') {
+  const { object, property } = callee;
+
+  if (!isIdentifierNamed(object, 'Array')) {
     return false;
   }
 

package/src/rules/prefer-safe-array-is-array.test.mts

@@ -63,3 +63,96 @@ ruleTester.run('prefer-safe-array-is-array', preferSafeArrayIsArray, {
     },
   ],
 });
+
+describe('prefer-safe-array-is-array through type wrappers', () => {
+  ruleTester.run('prefer-safe-array-is-array', preferSafeArrayIsArray, {
+    valid: [],
+    invalid: [
+      {
+        name: 'reads `Array` through `as`',
+        code: dedent`
+          const result = (Array as ArrayConstructor).isArray(value);
+        `,
+        output: dedent`
+          import { SafeArray } from 'ts-std-forge';
+          const result = SafeArray.isArray(value);
+        `,
+        errors: [{ messageId: 'useSafeArrayIsArray' }],
+      },
+      {
+        name: 'reads `Array` through `!`',
+        code: dedent`
+          const result = Array!.isArray(value);
+        `,
+        output: dedent`
+          import { SafeArray } from 'ts-std-forge';
+          const result = SafeArray.isArray(value);
+        `,
+        errors: [{ messageId: 'useSafeArrayIsArray' }],
+      },
+      {
+        name: 'reads the callee through `satisfies`',
+        code: dedent`
+          const result = (Array.isArray satisfies unknown)(value);
+        `,
+        output: dedent`
+          import { SafeArray } from 'ts-std-forge';
+          const result = SafeArray.isArray(value);
+        `,
+        errors: [{ messageId: 'useSafeArrayIsArray' }],
+      },
+      {
+        name: 'keeps a wrapper on the argument',
+        code: dedent`
+          const result = Array.isArray(value satisfies unknown);
+        `,
+        output: dedent`
+          import { SafeArray } from 'ts-std-forge';
+          const result = SafeArray.isArray(value satisfies unknown);
+        `,
+        errors: [{ messageId: 'useSafeArrayIsArray' }],
+      },
+    ],
+  });
+});
+
+describe('prefer-safe-array-is-array with parenthesized operands', () => {
+  ruleTester.run('prefer-safe-array-is-array', preferSafeArrayIsArray, {
+    valid: [],
+    invalid: [
+      {
+        name: 'replaces a parenthesized callee with its parentheses',
+        code: dedent`
+          const result = (Array.isArray)(x);
+        `,
+        output: dedent`
+          import { SafeArray } from 'ts-std-forge';
+          const result = SafeArray.isArray(x);
+        `,
+        errors: [{ messageId: 'useSafeArrayIsArray' }],
+      },
+      {
+        name: 'replaces a doubly parenthesized callee of an optional call',
+        code: dedent`
+          const result = ((Array.isArray))?.(x);
+        `,
+        output: dedent`
+          import { SafeArray } from 'ts-std-forge';
+          const result = SafeArray.isArray?.(x);
+        `,
+        errors: [{ messageId: 'useSafeArrayIsArray' }],
+      },
+      {
+        name: 'keeps a parenthesized argument',
+        code: dedent`
+          const result = Array.isArray((a, x));
+        `,
+        output: dedent`
+          import { SafeArray } from 'ts-std-forge';
+          const result = SafeArray.isArray((a, x));
+        `,
+        errors: [{ messageId: 'useSafeArrayIsArray' }],
+      },
+    ],
+  });
+});

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,14 +84,13 @@ 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
@@ -96,15 +100,12 @@ export const preferSafeArrayLengthGuard: TSESLint.RuleModule<
         return false;
       }
 
-      const tsNode = services?.esTreeNodeToTSNodeMap?.get(expression);
-
-      if (tsNode === 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: {
@@ -140,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,
@@ -180,11 +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);
 
@@ -218,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,8 +85,7 @@ 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';
 
@@ -103,9 +106,11 @@ export const preferSafeNumberParseInteger: TSESLint.RuleModule<
           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;
@@ -113,23 +118,12 @@ 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;
-        }
-
-        const checker = services.program.getTypeChecker();
-
-        const tsNode = services.esTreeNodeToTSNodeMap?.get(firstArg);
-
-        if (tsNode === undefined) {
-          return;
-        }
-
-        const argType = checker.getTypeAtLocation(tsNode);
+        // `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);
 
-        if (!isStringType(argType)) {
+        if (argType === undefined || !isStringType(argType)) {
           return;
         }
 
@@ -146,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' }],
+      },
+    ],
+  });
+});