eslint-plugin-ts-data-forge 0.8.6 → 0.9.0

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

@@ -5,12 +5,14 @@ import {
 } from '@typescript-eslint/utils';
 import {
   buildNamedImportFix,
+  getArgumentText,
   getImportDeclarations,
   getNamedImports,
-  typeWrapperLayers,
+  skipTypeWrappers,
 } from 'eslint-rule-forge';
 import { Arr } from 'ts-data-forge';
 import * as ts from 'typescript';
+import { isIdentifierNamed, typeHoldsAtEveryLayer } from './ast-utils.mjs';
 import { TS_DATA_FORGE_MODULE } from './constants.mjs';
 
 type Options = readonly [];
@@ -45,35 +47,40 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
         TS_DATA_FORGE_MODULE,
       );
 
-      const services = sourceCode.parserServices;
-
-      const checker = services?.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.
+       * `R extends UnknownRecord` constraint, at every layer of type
+       * wrappers: an array cast to a record is still rejected by `isRecord`,
+       * and a record widened to one that may be an array is the author saying
+       * it may need the guard. Without type information nothing is known, so
+       * the guard is kept.
        */
       const isKnownRecord = (
         // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
         expression: TSESTree.Expression,
-      ): boolean => {
-        if (checker === undefined) {
-          return false;
-        }
-
-        // At every layer of type wrappers (see typeWrapperLayers): an array
-        // cast to `Record<string, unknown>` still needs its `isRecord`.
-        return typeWrapperLayers(expression).every((layer) => {
-          const tsNode = services?.esTreeNodeToTSNodeMap?.get(layer);
-
-          return (
-            tsNode !== undefined &&
-            isAlreadyRecordType(checker, checker.getTypeAtLocation(tsNode))
-          );
-        });
-      };
+      ): boolean =>
+        typeHoldsAtEveryLayer(sourceCode, expression, (type, checker) =>
+          isAlreadyRecordType(checker, type),
+        );
+
+      /**
+       * Whether the object may be an array at some layer of type wrappers.
+       * `isRecord` rejects an array, so `'0' in xs` would turn from `true` to
+       * `false`; a widening cast to a type that may be an array is the author
+       * saying it may be one. Without type information nothing is known, and
+       * the rule reports as it always has.
+       */
+      const mayBeArray = (
+        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+        expression: TSESTree.Expression,
+      ): boolean =>
+        sourceCode.parserServices?.program != null &&
+        !typeHoldsAtEveryLayer(
+          sourceCode,
+          expression,
+          (type, checker) => !mayBeArrayType(checker, type),
+        );
 
       const mut_nodesToFix: {
         node: TSESTree.CallExpression | TSESTree.BinaryExpression;
@@ -84,12 +91,13 @@ 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;
           }
@@ -110,7 +118,8 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
           // Type guard: ensure arguments are Expressions (not SpreadElement)
           if (
             objArg.type === AST_NODE_TYPES.SpreadElement ||
-            keyArg.type === AST_NODE_TYPES.SpreadElement
+            keyArg.type === AST_NODE_TYPES.SpreadElement ||
+            mayBeArray(objArg)
           ) {
             return;
           }
@@ -133,7 +142,10 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
           const objExpression = node.right;
 
           // Type guard: ensure keyExpression is Expression (not PrivateIdentifier)
-          if (keyExpression.type === AST_NODE_TYPES.PrivateIdentifier) {
+          if (
+            keyExpression.type === AST_NODE_TYPES.PrivateIdentifier ||
+            mayBeArray(objExpression)
+          ) {
             return;
           }
 
@@ -147,28 +159,41 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
         'Program:exit': () => {
           const namedImports = getNamedImports(tsDataForgeImports);
 
-          const rewrites = mut_nodesToFix.map((entry) => ({
-            ...entry,
+          const rewrites = mut_nodesToFix.map((entry) => {
             // A record-typed object makes the `isRecord(...)` conjunct always
             // true, so it is left out of the replacement entirely.
-            needsIsRecord: !isKnownRecord(entry.objExpression),
-          }));
+            const needsIsRecord = !isKnownRecord(entry.objExpression);
+
+            return {
+              ...entry,
+              needsIsRecord,
+              // `isRecord(obj) && hasKey(obj, key)` evaluates `obj` twice.
+              fixable: !needsIsRecord || isSideEffectFree(entry.objExpression),
+            };
+          });
+
+          const fixableRewrites = rewrites.filter(({ fixable }) => fixable);
+
+          const importsToAdd: readonly string[] = Arr.isEmpty(fixableRewrites)
+            ? []
+            : [
+                ...(fixableRewrites.some(
+                  ({ needsIsRecord }) => needsIsRecord,
+                ) && !namedImports.includes('isRecord')
+                  ? ['isRecord']
+                  : []),
+                ...(namedImports.includes('hasKey') ? [] : ['hasKey']),
+              ];
 
-          const importsToAdd: readonly string[] = [
-            ...(rewrites.some(({ needsIsRecord }) => needsIsRecord) &&
-            !namedImports.includes('isRecord')
-              ? ['isRecord']
-              : []),
-            ...(namedImports.includes('hasKey') ? [] : ['hasKey']),
-          ];
+          const importCarrier = fixableRewrites[0];
 
-          for (const [
-            index,
-            { node, objExpression, keyExpression, needsIsRecord },
-          ] of rewrites.entries()) {
-            const objText = sourceCode.getText(objExpression);
+          for (const rewrite of rewrites) {
+            const { node, objExpression, keyExpression, needsIsRecord } =
+              rewrite;
 
-            const keyText = sourceCode.getText(keyExpression);
+            const objText = getArgumentText(sourceCode, objExpression);
+
+            const keyText = getArgumentText(sourceCode, keyExpression);
 
             const originalText = sourceCode.getText(node);
 
@@ -180,26 +205,32 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
                 objName: objText,
                 keyName: keyText,
               },
-              fix: (fixer) => {
-                const replacement = needsIsRecord
-                  ? `(isRecord(${objText}) && hasKey(${objText}, ${keyText}))`
-                  : `hasKey(${objText}, ${keyText})`;
-
-                // All import fixes have to live on the first report:
-                // `insertTextBefore(program, …)` produces overlapping ranges
-                // otherwise and only one of them would survive a pass.
-                const importFixes =
-                  index === 0 && importsToAdd.length > 0
-                    ? buildNamedImportFix(
-                        fixer,
-                        program,
-                        TS_DATA_FORGE_MODULE,
-                        importsToAdd,
-                      )
-                    : [];
-
-                return [...importFixes, fixer.replaceText(node, replacement)];
-              },
+              fix: !rewrite.fixable
+                ? undefined
+                : (fixer) => {
+                    const replacement = needsIsRecord
+                      ? `(isRecord(${objText}) && hasKey(${objText}, ${keyText}))`
+                      : `hasKey(${objText}, ${keyText})`;
+
+                    // All import fixes have to live on the first fixable
+                    // report: `insertTextBefore(program, …)` produces
+                    // overlapping ranges otherwise and only one of them would
+                    // survive a pass.
+                    const importFixes =
+                      rewrite === importCarrier && importsToAdd.length > 0
+                        ? buildNamedImportFix(
+                            fixer,
+                            program,
+                            TS_DATA_FORGE_MODULE,
+                            importsToAdd,
+                          )
+                        : [];
+
+                    return [
+                      ...importFixes,
+                      fixer.replaceText(node, replacement),
+                    ];
+                  },
             });
           }
         },
@@ -208,6 +239,56 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
     defaultOptions: [],
   } as const;
 
+/**
+ * Whether reading `node` again has no side effects: a variable, `this`, or a
+ * non-computed property chain on one, type wrappers aside.
+ */
+const isSideEffectFree = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  wrapped: TSESTree.Node,
+): boolean => {
+  const node = skipTypeWrappers(wrapped);
+
+  return (
+    node.type === AST_NODE_TYPES.Identifier ||
+    node.type === AST_NODE_TYPES.ThisExpression ||
+    (node.type === AST_NODE_TYPES.MemberExpression &&
+      !node.computed &&
+      isSideEffectFree(node.object))
+  );
+};
+
+/**
+ * Whether a value of `type` may be an array or a tuple: some member of a union
+ * or an intersection is one, or the constraint of a deferred type is.
+ * `object` and `unknown` say nothing either way and are not counted.
+ */
+const mayBeArrayType = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  checker: ts.TypeChecker,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  type: ts.Type,
+): boolean => {
+  if (type.isUnionOrIntersection()) {
+    return type.types.some((member) => mayBeArrayType(checker, member));
+  }
+
+  if (
+    (type.flags &
+      (ts.TypeFlags.TypeParameter |
+        ts.TypeFlags.IndexedAccess |
+        ts.TypeFlags.Conditional |
+        ts.TypeFlags.Substitution)) !==
+    0
+  ) {
+    const constraint = checker.getBaseConstraintOfType(type);
+
+    return constraint !== undefined && mayBeArrayType(checker, constraint);
+  }
+
+  return checker.isArrayType(type) || checker.isTupleType(type);
+};
+
 /**
  * Whether `type` already satisfies `hasKey`'s `R extends UnknownRecord`
  * constraint, so that guarding the call with `isRecord` adds nothing.

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

@@ -62,19 +62,6 @@ describe('prefer-is-record-and-has-key', () => {
         `,
         errors: [{ messageId: 'useHasKey' }],
       },
-      {
-        name: 'keeps isRecord when only part of a union is a record',
-        code: dedent`
-          declare const obj: Record<string, unknown> | readonly unknown[];
-          const ok = Object.hasOwn(obj, 'a');
-        `,
-        output: dedent`
-          import { isRecord, hasKey } from 'ts-data-forge';
-          declare const obj: Record<string, unknown> | readonly unknown[];
-          const ok = (isRecord(obj) && hasKey(obj, 'a'));
-        `,
-        errors: [{ messageId: 'useIsRecordAndHasKey' }],
-      },
       {
         name: 'keeps isRecord for an index-signature-carrying callable',
         code: dedent`
@@ -295,28 +282,136 @@ describe('prefer-is-record-and-has-key through type wrappers', () => {
     valid: [],
     invalid: [
       {
-        name: 'keeps isRecord for an array cast to a record: the value is still an array',
+        name: 'reads `Object` through `as`',
         code: dedent`
-          declare const arr: readonly string[];
-          const ok = Object.hasOwn(arr as unknown as Record<string, unknown>, '0');
+          declare const obj: Readonly<Record<string, unknown>>;
+          const ok = (Object as ObjectConstructor).hasOwn(obj, 'a');
         `,
         output: dedent`
-          import { isRecord, hasKey } from 'ts-data-forge';
+          import { hasKey } from 'ts-data-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',
+        code: dedent`
+          declare const a: number;
+          declare const o: Readonly<Record<string, unknown>>;
+          const ok = 'k' in (a, o);
+        `,
+        output: dedent`
+          import { hasKey } from 'ts-data-forge';
+          declare const a: number;
+          declare const o: Readonly<Record<string, unknown>>;
+          const ok = hasKey((a, o), 'k');
+        `,
+        errors: [{ messageId: 'useHasKey' }],
+      },
+      {
+        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-data-forge';
+          declare const a: number;
+          declare const o: Readonly<Record<string, unknown>>;
+          const ok = hasKey(o, (a, 'k'));
+        `,
+        errors: [{ messageId: 'useHasKey' }],
+      },
+    ],
+  });
+});
+
+describe('prefer-is-record-and-has-key where the rewrite would change behavior', () => {
+  tester.run('prefer-is-record-and-has-key', preferIsRecordAndHasKey, {
+    valid: [
+      {
+        // `isRecord` rejects an array, so `'0' in xs` would turn false.
+        name: 'an array',
+        code: dedent`
+          declare const xs: readonly number[];
+          const a = '0' in xs;
+          const b = Object.hasOwn(xs, 'length');
+        `,
+      },
+      {
+        name: 'a union with an array',
+        code: dedent`
+          declare const v: Readonly<Record<string, unknown>> | readonly number[];
+          const ok = 'k' in v;
+        `,
+      },
+      {
+        name: 'an array cast to a record',
+        code: dedent`
           declare const arr: readonly string[];
-          const ok = (isRecord(arr as unknown as Record<string, unknown>) && hasKey(arr as unknown as Record<string, unknown>, '0'));
+          const ok = Object.hasOwn(arr as unknown as Record<string, unknown>, '0');
         `,
-        errors: [{ messageId: 'useIsRecordAndHasKey' }],
       },
       {
-        name: 'keeps isRecord for a record widened to include an array: the author says it may be one',
+        name: 'a record widened by `as` to one that may be an array: the author says it may be one',
         code: dedent`
           declare const obj: Readonly<Record<string, unknown>>;
-          const ok = Object.hasOwn(obj as Readonly<Record<string, unknown>> | readonly unknown[], 'a');
+          const ok = Object.hasOwn(obj as Readonly<Record<string, unknown>> | readonly string[], 'a');
+        `,
+      },
+    ],
+    invalid: [
+      {
+        // `isRecord(…) && hasKey(…)` would evaluate the object twice.
+        name: 'an object with side effects is reported without a fix',
+        code: dedent`
+          declare const getObj: () => object;
+          declare const log: () => void;
+          declare const o: object;
+          const a = 'k' in getObj();
+          const b = Object.hasOwn(getObj(), 'k');
+          const c = 'k' in (log(), o);
+        `,
+        output: null,
+        errors: [
+          { messageId: 'useIsRecordAndHasKey' },
+          { messageId: 'useIsRecordAndHasKey' },
+          { messageId: 'useIsRecordAndHasKey' },
+        ],
+      },
+      {
+        name: 'an object with side effects is fixed when isRecord is dropped: it is read once',
+        code: dedent`
+          declare const getRec: () => Readonly<Record<string, unknown>>;
+          const ok = 'k' in getRec();
+        `,
+        output: dedent`
+          import { hasKey } from 'ts-data-forge';
+          declare const getRec: () => Readonly<Record<string, unknown>>;
+          const ok = hasKey(getRec(), 'k');
+        `,
+        errors: [{ messageId: 'useHasKey' }],
+      },
+      {
+        name: 'a reference read through type wrappers is still read without side effects',
+        code: dedent`
+          declare const o: { readonly p: object };
+          const ok = 'k' in (o.p satisfies object);
         `,
         output: dedent`
           import { isRecord, hasKey } from 'ts-data-forge';
-          declare const obj: Readonly<Record<string, unknown>>;
-          const ok = (isRecord(obj as Readonly<Record<string, unknown>> | readonly unknown[]) && hasKey(obj as Readonly<Record<string, unknown>> | readonly unknown[], 'a'));
+          declare const o: { readonly p: object };
+          const ok = (isRecord(o.p satisfies object) && hasKey(o.p satisfies object, 'k'));
         `,
         errors: [{ messageId: 'useIsRecordAndHasKey' }],
       },