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

package/src/rules/prefer-is-non-null-object.mts

@@ -3,7 +3,7 @@ import {
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
-import { type DeepReadonly } from 'ts-type-forge';
+import { skipTypeWrappers } from './ast-utils.mjs';
 import {
   buildImportFixes,
   getNamedImports,
@@ -45,7 +45,9 @@ export const preferIsNonNullObject: TSESLint.RuleModule<MessageIds, Options> = {
       LogicalExpression: (node) => {
         const identifierName = getNonNullObjectIdentifierName(node);
 
-        if (identifierName === undefined) return;
+        if (identifierName === undefined) {
+          return;
+        }
 
         mut_nodesToFix.push({ node, identifierName });
       },
@@ -83,60 +85,83 @@ export const preferIsNonNullObject: TSESLint.RuleModule<MessageIds, Options> = {
   defaultOptions: [],
 } as const;
 
+// Every operand below is read through its type wrappers: `typeof (u satisfies
+// unknown) === 'object' && u! !== null` is the same check.
+
 const getNonNullObjectIdentifierName = (
-  node: DeepReadonly<TSESTree.LogicalExpression>,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: TSESTree.LogicalExpression,
 ): string | undefined => {
-  if (node.operator !== '&&') return undefined;
-
-  const leftIdentifierName = getTypeofObjectIdentifierName(node.left);
-
-  const rightIdentifierName = getNonNullCheckIdentifierName(node.right);
-
-  if (leftIdentifierName === undefined) return undefined;
-
-  if (rightIdentifierName === undefined) return undefined;
-
-  if (leftIdentifierName !== rightIdentifierName) return undefined;
-
-  return leftIdentifierName;
+  if (node.operator !== '&&') {
+    return undefined;
+  }
+
+  const leftIdentifierName = getTypeofObjectIdentifierName(
+    skipTypeWrappers(node.left),
+  );
+
+  const rightIdentifierName = getNonNullCheckIdentifierName(
+    skipTypeWrappers(node.right),
+  );
+
+  return leftIdentifierName === undefined ||
+    rightIdentifierName === undefined ||
+    leftIdentifierName !== rightIdentifierName
+    ? undefined
+    : leftIdentifierName;
 };
 
 const getTypeofObjectIdentifierName = (
-  node: DeepReadonly<TSESTree.Expression>,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: TSESTree.Node,
 ): string | undefined => {
-  if (node.type !== AST_NODE_TYPES.BinaryExpression) return undefined;
-
-  if (node.operator !== '===') return undefined;
+  if (node.type !== AST_NODE_TYPES.BinaryExpression) {
+    return undefined;
+  }
 
-  const { left, right } = node;
+  if (node.operator !== '===') {
+    return undefined;
+  }
 
-  if (left.type !== AST_NODE_TYPES.UnaryExpression) return undefined;
+  const left = skipTypeWrappers(node.left);
 
-  if (left.operator !== 'typeof') return undefined;
+  const right = skipTypeWrappers(node.right);
 
-  if (right.type !== AST_NODE_TYPES.Literal) return undefined;
+  if (
+    left.type !== AST_NODE_TYPES.UnaryExpression ||
+    left.operator !== 'typeof' ||
+    right.type !== AST_NODE_TYPES.Literal ||
+    right.value !== 'object'
+  ) {
+    return undefined;
+  }
 
-  if (right.value !== 'object') return undefined;
+  const argument = skipTypeWrappers(left.argument);
 
-  if (left.argument.type !== AST_NODE_TYPES.Identifier) return undefined;
-
-  return left.argument.name;
+  return argument.type === AST_NODE_TYPES.Identifier
+    ? argument.name
+    : undefined;
 };
 
 const getNonNullCheckIdentifierName = (
-  node: DeepReadonly<TSESTree.Expression>,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: TSESTree.Node,
 ): string | undefined => {
-  if (node.type !== AST_NODE_TYPES.BinaryExpression) return undefined;
-
-  if (node.operator !== '!==') return undefined;
-
-  const { left, right } = node;
+  if (node.type !== AST_NODE_TYPES.BinaryExpression) {
+    return undefined;
+  }
 
-  if (left.type !== AST_NODE_TYPES.Identifier) return undefined;
+  if (node.operator !== '!==') {
+    return undefined;
+  }
 
-  if (right.type !== AST_NODE_TYPES.Literal) return undefined;
+  const left = skipTypeWrappers(node.left);
 
-  if (right.value !== null) return undefined;
+  const right = skipTypeWrappers(node.right);
 
-  return left.name;
+  return left.type !== AST_NODE_TYPES.Identifier ||
+    right.type !== AST_NODE_TYPES.Literal ||
+    right.value !== null
+    ? undefined
+    : left.name;
 };

package/src/rules/prefer-is-non-null-object.test.mts

@@ -52,3 +52,57 @@ ruleTester.run('prefer-is-non-null-object', preferIsNonNullObject, {
     },
   ],
 });
+
+// The replacement names the bare identifier: that is the reference both
+// halves narrow, and a wrapper around the argument would stop the guard from
+// narrowing it.
+describe('prefer-is-non-null-object through type wrappers', () => {
+  ruleTester.run('prefer-is-non-null-object', preferIsNonNullObject, {
+    valid: [
+      {
+        name: 'The two halves are about different identifiers behind wrappers',
+        code: dedent`
+          const ok = typeof (u satisfies unknown) === 'object' && v! !== null;
+        `,
+      },
+    ],
+    invalid: [
+      {
+        name: 'reads the typeof operand through `satisfies`',
+        code: dedent`
+          const ok = typeof (u satisfies unknown) === 'object' && u !== null;
+        `,
+        output: dedent`
+          import { isNonNullObject } from 'ts-std-forge';
+          const ok = isNonNullObject(u);
+        `,
+        errors: [{ messageId: 'useIsNonNullObject' }],
+      },
+      {
+        name: 'reads the null check through `!` and `as`',
+        code: dedent`
+          const ok = typeof u === 'object' && u! !== (null as null);
+        `,
+        output: dedent`
+          import { isNonNullObject } from 'ts-std-forge';
+          const ok = isNonNullObject(u);
+        `,
+        errors: [{ messageId: 'useIsNonNullObject' }],
+      },
+      {
+        name: 'reads the literal and both halves through wrappers',
+        code: dedent`
+          const ok =
+            ((typeof (<unknown>u) === ('object' as const)) satisfies boolean) &&
+            ((u !== null) as boolean);
+        `,
+        output: dedent`
+          import { isNonNullObject } from 'ts-std-forge';
+          const ok =
+            isNonNullObject(u);
+        `,
+        errors: [{ messageId: 'useIsNonNullObject' }],
+      },
+    ],
+  });
+});

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

@@ -5,6 +5,12 @@ import {
 } from '@typescript-eslint/utils';
 import { SafeArray } from 'ts-std-forge';
 import * as ts from 'typescript';
+import {
+  getArgumentText,
+  getValueType,
+  isIdentifierNamed,
+  skipTypeWrappers,
+} from './ast-utils.mjs';
 import {
   buildImportFixes,
   getNamedImports,
@@ -40,28 +46,26 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
 
       const tsStdForgeImport = getTsStdForgeImport(program);
 
-      const services = sourceCode.parserServices;
-
-      const checker = services?.program?.getTypeChecker();
+      const checker = sourceCode.parserServices?.program?.getTypeChecker();
 
       /**
        * Whether the `isRecord(...)` half of the rewrite would be dead code
        * because the object already satisfies `hasKey`'s
        * `R extends UnknownRecord` constraint. Without type information nothing
-       * is known, so the guard is kept.
+       * is known, so the guard is kept. The type is the value's, not a cast's:
+       * an array cast to a record is still rejected by `isRecord`.
        */
       const isKnownRecord = (
         // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
         expression: TSESTree.Expression,
       ): boolean => {
-        if (checker === undefined) return false;
+        if (checker === undefined) {
+          return false;
+        }
 
-        const tsNode = services?.esTreeNodeToTSNodeMap?.get(expression);
+        const type = getValueType(sourceCode, expression);
 
-        return (
-          tsNode !== undefined &&
-          isAlreadyRecordType(checker, checker.getTypeAtLocation(tsNode))
-        );
+        return type !== undefined && isAlreadyRecordType(checker, type);
       };
 
       const mut_nodesToFix: {
@@ -73,24 +77,29 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
       return {
         // Handle Object.hasOwn(obj, key)
         CallExpression: (node) => {
+          const callee = skipTypeWrappers(node.callee);
+
           if (
-            node.callee.type !== AST_NODE_TYPES.MemberExpression ||
-            node.callee.object.type !== AST_NODE_TYPES.Identifier ||
-            node.callee.object.name !== 'Object' ||
-            node.callee.property.type !== AST_NODE_TYPES.Identifier ||
-            node.callee.property.name !== 'hasOwn'
+            callee.type !== AST_NODE_TYPES.MemberExpression ||
+            !isIdentifierNamed(callee.object, 'Object') ||
+            callee.property.type !== AST_NODE_TYPES.Identifier ||
+            callee.property.name !== 'hasOwn'
           ) {
             return;
           }
 
           // Check arguments: Object.hasOwn(obj, key)
-          if (node.arguments.length !== 2) return;
+          if (node.arguments.length !== 2) {
+            return;
+          }
 
           const objArg = node.arguments[0];
 
           const keyArg = node.arguments[1];
 
-          if (objArg === undefined || keyArg === undefined) return;
+          if (objArg === undefined || keyArg === undefined) {
+            return;
+          }
 
           // Type guard: ensure arguments are Expressions (not SpreadElement)
           if (
@@ -109,14 +118,18 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
 
         // Handle key in obj
         BinaryExpression: (node) => {
-          if (node.operator !== 'in') return;
+          if (node.operator !== 'in') {
+            return;
+          }
 
           const keyExpression = node.left;
 
           const objExpression = node.right;
 
           // Type guard: ensure keyExpression is Expression (not PrivateIdentifier)
-          if (keyExpression.type === AST_NODE_TYPES.PrivateIdentifier) return;
+          if (keyExpression.type === AST_NODE_TYPES.PrivateIdentifier) {
+            return;
+          }
 
           mut_nodesToFix.push({
             node,
@@ -147,9 +160,9 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
             index,
             { node, objExpression, keyExpression, needsIsRecord },
           ] of rewrites.entries()) {
-            const objText = sourceCode.getText(objExpression);
+            const objText = getArgumentText(sourceCode, objExpression);
 
-            const keyText = sourceCode.getText(keyExpression);
+            const keyText = getArgumentText(sourceCode, keyExpression);
 
             const originalText = sourceCode.getText(node);
 

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,
@@ -41,7 +45,9 @@ export const preferSafeArrayIsArray: TSESLint.RuleModule<MessageIds, Options> =
 
       return {
         CallExpression: (node) => {
-          if (!isArrayIsArrayCall(node)) return;
+          if (!isArrayIsArrayCall(node)) {
+            return;
+          }
 
           mut_nodesToFix.push(node);
         },
@@ -59,18 +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',
+                  ),
+                ];
               },
             });
           }
@@ -81,19 +90,28 @@ 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 (callee.type !== AST_NODE_TYPES.MemberExpression) {
+    return false;
+  }
 
-  if (object.type !== AST_NODE_TYPES.Identifier) return false;
+  const { object, property } = callee;
 
-  if (object.name !== 'Array') return false;
+  if (!isIdentifierNamed(object, 'Array')) {
+    return false;
+  }
 
-  if (property.type !== AST_NODE_TYPES.Identifier) return false;
+  if (property.type !== AST_NODE_TYPES.Identifier) {
+    return false;
+  }
 
-  if (property.name !== 'isArray') return false;
+  if (property.name !== 'isArray') {
+    return false;
+  }
 
   return true;
 };

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' }],
+      },
+    ],
+  });
+});