eslint-plugin-ts-data-forge 0.2.0 → 0.4.0

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

@@ -3,6 +3,8 @@ import {
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
+import { Arr } from 'ts-data-forge';
+import * as ts from 'typescript';
 import {
   buildImportFixes,
   getNamedImports,
@@ -11,7 +13,7 @@ import {
 
 type Options = readonly [];
 
-type MessageIds = 'useIsRecordAndHasKey';
+type MessageIds = 'useIsRecordAndHasKey' | 'useHasKey';
 
 export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
   {
@@ -26,6 +28,8 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
       messages: {
         useIsRecordAndHasKey:
           'Replace `{{original}}` with `isRecord({{objName}}) && hasKey({{objName}}, {{keyName}})` from ts-data-forge.',
+        useHasKey:
+          'Replace `{{original}}` with `hasKey({{objName}}, {{keyName}})` from ts-data-forge.',
       },
     },
 
@@ -36,6 +40,30 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
 
       const tsDataForgeImport = getTsDataForgeImport(program);
 
+      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.
+       */
+      const isKnownRecord = (
+        // 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);
+
+        return (
+          tsNode !== undefined &&
+          isAlreadyRecordType(checker, checker.getTypeAtLocation(tsNode))
+        );
+      };
+
       const mut_nodesToFix: {
         node: TSESTree.CallExpression | TSESTree.BinaryExpression;
         objExpression: TSESTree.Expression;
@@ -100,14 +128,25 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
         'Program:exit': () => {
           const namedImports = getNamedImports(tsDataForgeImport);
 
-          const hasIsRecordImport = namedImports.includes('isRecord');
-
-          const hasHasKeyImport = namedImports.includes('hasKey');
+          const rewrites = mut_nodesToFix.map((entry) => ({
+            ...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 importsToAdd: readonly string[] = [
+            ...(rewrites.some(({ needsIsRecord }) => needsIsRecord) &&
+            !namedImports.includes('isRecord')
+              ? ['isRecord']
+              : []),
+            ...(namedImports.includes('hasKey') ? [] : ['hasKey']),
+          ];
 
           for (const [
             index,
-            { node, objExpression, keyExpression },
-          ] of mut_nodesToFix.entries()) {
+            { node, objExpression, keyExpression, needsIsRecord },
+          ] of rewrites.entries()) {
             const objText = sourceCode.getText(objExpression);
 
             const keyText = sourceCode.getText(keyExpression);
@@ -116,32 +155,27 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
 
             context.report({
               node,
-              messageId: 'useIsRecordAndHasKey',
+              messageId: needsIsRecord ? 'useIsRecordAndHasKey' : 'useHasKey',
               data: {
                 original: originalText,
                 objName: objText,
                 keyName: keyText,
               },
               fix: (fixer) => {
-                const replacement = `(isRecord(${objText}) && hasKey(${objText}, ${keyText}))`;
-
-                const mut_importsToAdd: string[] = [];
-
-                if (!hasIsRecordImport) {
-                  mut_importsToAdd.push('isRecord');
-                }
-
-                if (!hasHasKeyImport) {
-                  mut_importsToAdd.push('hasKey');
-                }
+                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 && mut_importsToAdd.length > 0
+                  index === 0 && importsToAdd.length > 0
                     ? buildImportFixes(
                         fixer,
                         program,
                         tsDataForgeImport,
-                        mut_importsToAdd,
+                        importsToAdd,
                       )
                     : [];
 
@@ -154,3 +188,33 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
     },
     defaultOptions: [],
   } as const;
+
+/**
+ * Whether `type` already satisfies `hasKey`'s `R extends UnknownRecord`
+ * constraint, so that guarding the call with `isRecord` adds nothing.
+ *
+ * `UnknownRecord` is `ReadonlyRecord<string, unknown>`, so a string index
+ * signature is exactly what it asks for and its value type is `unknown`, which
+ * anything satisfies. Callables and arrays are excluded because `isRecord`
+ * rejects them at runtime (`typeof fn === 'object'` is false, `Array.isArray`
+ * is true), so dropping the guard there would change behavior.
+ *
+ * Deliberately conservative: a type TypeScript would accept through an
+ * *implicit* index signature (an object type alias without one of its own)
+ * keeps the guard, because the checker does not report such a signature here.
+ */
+const isAlreadyRecordType = (
+  // 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 =>
+  type.isUnion()
+    ? type.types.every((member) => isAlreadyRecordType(checker, member))
+    : checker.getIndexInfoOfType(type, ts.IndexKind.String) !== undefined &&
+      Arr.isEmpty(checker.getSignaturesOfType(type, ts.SignatureKind.Call)) &&
+      Arr.isEmpty(
+        checker.getSignaturesOfType(type, ts.SignatureKind.Construct),
+      ) &&
+      !checker.isArrayType(type) &&
+      !checker.isTupleType(type);

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

@@ -36,6 +36,80 @@ describe('prefer-is-record-and-has-key', () => {
       },
     ],
     invalid: [
+      {
+        name: 'drops isRecord when the object already has a string index signature',
+        code: dedent`
+          declare const obj: Readonly<Record<string, unknown>>;
+          const ok = Object.hasOwn(obj, 'a');
+        `,
+        output: dedent`
+          import { hasKey } from 'ts-data-forge';
+          declare const obj: Readonly<Record<string, unknown>>;
+          const ok = hasKey(obj, 'a');
+        `,
+        errors: [{ messageId: 'useHasKey' }],
+      },
+      {
+        name: 'drops isRecord for `key in obj` on a record-typed object',
+        code: dedent`
+          declare const obj: Record<string, number>;
+          const ok = 'a' in obj;
+        `,
+        output: dedent`
+          import { hasKey } from 'ts-data-forge';
+          declare const obj: Record<string, number>;
+          const ok = hasKey(obj, 'a');
+        `,
+        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`
+          type Callable = { (): void; [key: string]: unknown };
+          declare const obj: Callable;
+          const ok = Object.hasOwn(obj, 'a');
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-data-forge';
+          type Callable = { (): void; [key: string]: unknown };
+          declare const obj: Callable;
+          const ok = (isRecord(obj) && hasKey(obj, 'a'));
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'imports isRecord once when both forms appear in a file',
+        code: dedent`
+          declare const rec: Record<string, unknown>;
+          declare const unk: unknown;
+          const a = Object.hasOwn(rec, 'a');
+          const b = Object.hasOwn(unk, 'b');
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-data-forge';
+          declare const rec: Record<string, unknown>;
+          declare const unk: unknown;
+          const a = hasKey(rec, 'a');
+          const b = (isRecord(unk) && hasKey(unk, 'b'));
+        `,
+        errors: [
+          { messageId: 'useHasKey' },
+          { messageId: 'useIsRecordAndHasKey' },
+        ],
+      },
       {
         name: 'replaces Object.hasOwn(obj, key) with isRecord && hasKey',
         code: dedent`

package/src/rules/prefer-range-for-loop.mts

@@ -50,7 +50,7 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
         if (
           node.init?.type !== AST_NODE_TYPES.VariableDeclaration ||
           node.init.kind !== 'let' ||
-          !Arr.isFixedLengthTuple(node.init.declarations, 1)
+          !Arr.isFixedLengthTuple(1, node.init.declarations)
         ) {
           return;
         }

package/src/rules/rules.mts

@@ -4,6 +4,7 @@ import { preferArrIsArray } from './prefer-arr-is-array.mjs';
 import { preferArrSum } from './prefer-arr-sum.mjs';
 import { preferAsInt } from './prefer-as-int.mjs';
 import { preferCanonicalArraySlicing } from './prefer-canonical-array-slicing.mjs';
+import { preferCanonicalLengthCast } from './prefer-canonical-length-cast.mjs';
 import { preferCanonicalLengthGuard } from './prefer-canonical-length-guard.mjs';
 import { preferComparisonOverNullishGuard } from './prefer-comparison-over-nullish-guard.mjs';
 import { preferIsNonNullObject } from './prefer-is-non-null-object.mjs';
@@ -15,6 +16,7 @@ import { preferRangeForLoop } from './prefer-range-for-loop.mjs';
 export const tsDataForgeRules = {
   'prefer-canonical-array-slicing': preferCanonicalArraySlicing,
   'prefer-canonical-length-guard': preferCanonicalLengthGuard,
+  'prefer-canonical-length-cast': preferCanonicalLengthCast,
   'prefer-arr-is-array': preferArrIsArray,
   'prefer-arr-sum': preferArrSum,
   'prefer-as-int': preferAsInt,