eslint-plugin-ts-data-forge 0.10.8 → 0.10.10

package/src/rules/prefer-canonical-array-slicing.mts

@@ -5,18 +5,16 @@ import {
   type TSESTree,
 } from '@typescript-eslint/utils';
 import {
-  bindValueImports,
   getImportDeclarations,
   getImportedLocalName,
   hasForeignBinding,
-  importedNameOf,
   skipTypeWrappers,
   typeWrapperLayers,
-  type ValueImportBinding,
 } from 'eslint-rule-forge';
 import type { ReadonlyRecord } from 'ts-type-forge';
 import * as ts from 'typescript';
 import { TS_DATA_FORGE_MODULE } from './constants.mjs';
+import { tsDataForgeValueAt } from './import-binding.mjs';
 
 /* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 
@@ -203,25 +201,16 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
 
     const program = sourceCode.ast;
 
+    // `import type` binds no value a call could go through.
     const tsDataForgeImports = getImportDeclarations(
       program,
       TS_DATA_FORGE_MODULE,
-    );
+    ).filter((declaration) => declaration.importKind !== 'type');
 
     const parserServices = ESLintUtils.getParserServices(context);
 
     const checker = parserServices.program.getTypeChecker();
 
-    /**
-     * The in-scope way to reference the `Arr` namespace, the name the reference
-     * starts with, and the edits that bring it into scope: a value
-     * import of `Arr` (possibly aliased), a namespace import member, or `Arr`
-     * bound by {@link bindValueImports}, which adds it to an existing import or
-     * drops `type` from one. `undefined` when none can: `import type { Arr }`
-     * with no namespace import.
-     */
-    const arrTarget = resolveArrTarget(sourceCode, tsDataForgeImports);
-
     /** How a call already in the file names `Arr`, to recognize it. */
     const arrLocalName = getImportedLocalName(tsDataForgeImports, 'Arr');
 
@@ -232,7 +221,23 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
           specifier.type === AST_NODE_TYPES.ImportNamespaceSpecifier,
       )?.local.name;
 
-    const arrRef = arrTarget?.ref ?? 'Arr';
+    /**
+     * Whether `identifier` is `localName`, bound by the import from
+     * ts-data-forge where it is rather than by a local binding.
+     */
+    const isImportedAs = (
+      identifier: TSESTree.Node,
+      localName: string | undefined,
+    ): boolean =>
+      localName !== undefined &&
+      identifier.type === AST_NODE_TYPES.Identifier &&
+      identifier.name === localName &&
+      !hasForeignBinding(
+        sourceCode,
+        identifier,
+        localName,
+        TS_DATA_FORGE_MODULE,
+      );
 
     /**
      * Deferred (non-concrete) types are reduced to their base constraint before
@@ -317,39 +322,14 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
         : text;
     };
 
-    const toReplacementText = (op: CopyOp, xsText: string): string => {
-      switch (op.fn) {
-        case 'tail':
-        case 'butLast':
-          return `${arrRef}.${op.fn}(${xsText})`;
-
-        case 'skip':
-        case 'take':
-        case 'skipLast':
-        case 'takeLast':
-          return `${arrRef}.${op.fn}(${xsText}, ${op.count})`;
-
-        // Emit the curried form for `toUnshifted` so the new element stays in
-        // the same textual position as in the `[item, ...xs]` source, keeping
-        // the rewrite easy to read.
-        case 'toUnshifted':
-          return `${arrRef}.toUnshifted(${op.itemText})(${xsText})`;
-
-        case 'toPushed':
-          return `${arrRef}.toPushed(${xsText}, ${op.itemText})`;
-      }
-    };
-
     const mut_nodesToFix: {
       node: TSESTree.Node;
-      replacement: string;
+      op: CopyOp;
+      xsText: string;
     }[] = [];
 
     const report = (node: TSESTree.Node, op: CopyOp, xsText: string): void => {
-      mut_nodesToFix.push({
-        node,
-        replacement: toReplacementText(op, xsText),
-      });
+      mut_nodesToFix.push({ node, op, xsText });
     };
 
     /**
@@ -654,17 +634,22 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
         const receiver = callee.object;
 
         // `Arr.skip(xs, 1)` → `Arr.tail(xs)`, `Arr.skipLast(xs, 1)` →
-        // `Arr.butLast(xs)` (also via a namespace import or an alias).
+        // `Arr.butLast(xs)` (also via a namespace import or an alias, and
+        // through type wrappers), unless a local binding shadows the import
+        // where the call is.
         if (methodName === 'skip' || methodName === 'skipLast') {
+          const arrObject = skipTypeWrappers(receiver);
+
           const isArrObject =
-            (receiver.type === AST_NODE_TYPES.Identifier &&
-              receiver.name === arrLocalName) ||
-            (receiver.type === AST_NODE_TYPES.MemberExpression &&
-              !receiver.computed &&
-              receiver.object.type === AST_NODE_TYPES.Identifier &&
-              receiver.object.name === namespaceLocalName &&
-              receiver.property.type === AST_NODE_TYPES.Identifier &&
-              receiver.property.name === 'Arr');
+            isImportedAs(arrObject, arrLocalName) ||
+            (arrObject.type === AST_NODE_TYPES.MemberExpression &&
+              !arrObject.computed &&
+              isImportedAs(
+                skipTypeWrappers(arrObject.object),
+                namespaceLocalName,
+              ) &&
+              arrObject.property.type === AST_NODE_TYPES.Identifier &&
+              arrObject.property.name === 'Arr');
 
           const [arrayArg, countArg] = node.arguments;
 
@@ -858,28 +843,34 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
       },
 
       'Program:exit': () => {
+        if (mut_nodesToFix.length === 0) {
+          return;
+        }
+
+        const arrAt = tsDataForgeValueAt(sourceCode, 'Arr');
+
         // Every fix brings `Arr` into scope itself, so that one applied alone
         // (an editor's quick fix) is complete.
         for (const nodeInfo of mut_nodesToFix) {
-          const writable =
-            arrTarget !== undefined &&
-            !hasForeignBinding(
-              sourceCode,
-              nodeInfo.node,
-              arrTarget.boundName,
-              TS_DATA_FORGE_MODULE,
-            );
+          const arr = arrAt(nodeInfo.node);
+
+          const replacement = toReplacementText(
+            arr?.localName ?? 'Arr',
+            nodeInfo.op,
+            nodeInfo.xsText,
+          );
 
           context.report({
             node: nodeInfo.node,
             messageId: 'preferCanonicalArraySlicing',
-            data: { replacement: nodeInfo.replacement },
-            fix: writable
-              ? (fixer) => [
-                  ...arrTarget.edits(fixer),
-                  fixer.replaceText(nodeInfo.node, nodeInfo.replacement),
-                ]
-              : null,
+            data: { replacement },
+            fix:
+              arr === undefined
+                ? null
+                : (fixer) => [
+                    ...arr.edits(fixer),
+                    fixer.replaceText(nodeInfo.node, replacement),
+                  ],
           });
         }
       },
@@ -887,56 +878,30 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
   },
 } as const;
 
-/**
- * How `Arr` is written in this file; see where it is called. A value import of
- * `Arr` comes first, then a namespace import, and only then an edit.
- */
-const resolveArrTarget = (
-  sourceCode: TSESLint.SourceCode,
-  tsDataForgeImports: readonly TSESTree.ImportDeclaration[],
-):
-  | Readonly<{
-      ref: string;
-      boundName: string;
-      edits: ValueImportBinding['edits'];
-    }>
-  | undefined => {
-  const valueSpecifiers = tsDataForgeImports
-    .filter((declaration) => declaration.importKind !== 'type')
-    .flatMap((declaration) => declaration.specifiers);
-
-  const arrImport = valueSpecifiers.find(
-    (specifier) =>
-      specifier.type === AST_NODE_TYPES.ImportSpecifier &&
-      specifier.importKind !== 'type' &&
-      importedNameOf(specifier) === 'Arr',
-  );
-
-  if (arrImport !== undefined) {
-    return {
-      ref: arrImport.local.name,
-      boundName: arrImport.local.name,
-      edits: () => [],
-    };
-  }
-
-  const namespace = valueSpecifiers.find(
-    (specifier) => specifier.type === AST_NODE_TYPES.ImportNamespaceSpecifier,
-  );
-
-  if (namespace !== undefined) {
-    return {
-      ref: `${namespace.local.name}.Arr`,
-      boundName: namespace.local.name,
-      edits: () => [],
-    };
+/** The call `op` is rewritten to, writing `Arr` as `arrRef`. */
+const toReplacementText = (
+  arrRef: string,
+  op: CopyOp,
+  xsText: string,
+): string => {
+  switch (op.fn) {
+    case 'tail':
+    case 'butLast':
+      return `${arrRef}.${op.fn}(${xsText})`;
+
+    case 'skip':
+    case 'take':
+    case 'skipLast':
+    case 'takeLast':
+      return `${arrRef}.${op.fn}(${xsText}, ${op.count})`;
+
+    // Emit the curried form for `toUnshifted` so the new element stays in the
+    // same textual position as in the `[item, ...xs]` source, keeping the
+    // rewrite easy to read.
+    case 'toUnshifted':
+      return `${arrRef}.toUnshifted(${op.itemText})(${xsText})`;
+
+    case 'toPushed':
+      return `${arrRef}.toPushed(${xsText}, ${op.itemText})`;
   }
-
-  const binding = bindValueImports(sourceCode, TS_DATA_FORGE_MODULE, ['Arr']);
-
-  const localName = binding?.localNames[0];
-
-  return binding === undefined || localName === undefined
-    ? undefined
-    : { ref: localName, boundName: localName, edits: binding.edits };
 };

package/src/rules/prefer-canonical-array-slicing.test.mts

@@ -780,7 +780,35 @@ describe('prefer-canonical-array-slicing through type wrappers', () => {
 
 describe('prefer-canonical-array-slicing and the import it adds', () => {
   tester.run('prefer-canonical-array-slicing', preferCanonicalArraySlicing, {
-    valid: [],
+    valid: [
+      {
+        name: 'a namespace imported by `import type` binds no value',
+        code: dedent`
+          import type * as T from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ys = T.Arr.skip(xs, 1);
+        `,
+      },
+      {
+        name: 'a local binding that shadows the imported `Arr` is not ts-data-forge',
+        code: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const f = (Arr: { skip: (a: unknown, n: number) => unknown }) =>
+            Arr.skip(xs, 1);
+        `,
+      },
+      {
+        name: 'a local binding that shadows the namespace import is not ts-data-forge',
+        code: dedent`
+          import * as tdf from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const f = (tdf: {
+            Arr: { skip: (a: unknown, n: number) => unknown };
+          }) => tdf.Arr.skip(xs, 1);
+        `,
+      },
+    ],
     invalid: [
       {
         name: 'writes through a namespace import, which needs no edit',
@@ -829,6 +857,92 @@ describe('prefer-canonical-array-slicing and the import it adds', () => {
         output: null,
         errors: [{ messageId: 'preferCanonicalArraySlicing' }],
       },
+      {
+        name: 'sees `Arr.skip` and `ns.Arr.skip` through type wrappers',
+        code: dedent`
+          import { Arr } from 'ts-data-forge';
+          import * as tdf from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const a = (Arr as typeof Arr).skip(xs, 1);
+          const b = (tdf satisfies typeof tdf).Arr.skipLast(xs, 1);
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          import * as tdf from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const a = Arr.tail(xs);
+          const b = Arr.butLast(xs);
+        `,
+        errors: [
+          { messageId: 'preferCanonicalArraySlicing' },
+          { messageId: 'preferCanonicalArraySlicing' },
+        ],
+      },
+      {
+        name: 'drops `type` from an inline type specifier',
+        code: dedent`
+          import { type Arr, asInt } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ys = xs.slice(1);
+        `,
+        output: dedent`
+          import { Arr, asInt } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ys = Arr.tail(xs);
+        `,
+        errors: [{ messageId: 'preferCanonicalArraySlicing' }],
+      },
+      {
+        name: 'adds the import after a leading directive',
+        code: dedent`
+          'use client';
+          declare const xs: readonly number[];
+          const ys = xs.slice(1);
+        `,
+        output: dedent`
+          'use client';
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ys = Arr.tail(xs);
+        `,
+        errors: [{ messageId: 'preferCanonicalArraySlicing' }],
+      },
+      {
+        name: 'imports `Arr` by name where a local binding shadows the namespace import',
+        code: dedent`
+          import * as tdf from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const f = (tdf: unknown) => xs.slice(1);
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          import * as tdf from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const f = (tdf: unknown) => Arr.tail(xs);
+        `,
+        errors: [
+          {
+            messageId: 'preferCanonicalArraySlicing',
+            data: { replacement: 'Arr.tail(xs)' },
+          },
+        ],
+      },
+      {
+        name: 'no fix where a local binding shadows the namespace import and another import takes `Arr`',
+        code: dedent`
+          import * as tdf from 'ts-data-forge';
+          import { Arr } from 'other';
+          declare const xs: readonly number[];
+          const f = (tdf: unknown) => xs.slice(1);
+        `,
+        output: null,
+        errors: [
+          {
+            messageId: 'preferCanonicalArraySlicing',
+            data: { replacement: 'Arr.tail(xs)' },
+          },
+        ],
+      },
     ],
   });
 });

package/src/rules/prefer-obj-over-entries-round-trip.mts

@@ -92,11 +92,11 @@ export const preferObjOverEntriesRoundTrip: TSESLint.RuleModule<
     }[] = [];
 
     /**
-     * Rebuilds the callback's parameter list. The entry pattern binds
+     * The names of the rebuilt callback's parameters. The entry pattern binds
      * `[key, value]`; `Obj` passes `(value, key)`, and either parameter is
      * dropped when the rewritten body no longer refers to it.
      */
-    const buildParams = (roundTrip: RoundTrip): string => {
+    const rebuiltParamNames = (roundTrip: RoundTrip): readonly string[] => {
       const scope = sourceCode.getScope(roundTrip.callback);
 
       const dropped = new Set<TSESTree.Node>(roundTrip.dropped);
@@ -112,13 +112,13 @@ export const preferObjOverEntriesRoundTrip: TSESLint.RuleModule<
       if (keyName !== undefined) {
         // `Obj` puts the value first, so a callback that only needs the key
         // still has to name a value parameter.
-        return `(${valueName ?? unusedValueParamName(scope)}, ${keyName})`;
+        return [valueName ?? unusedValueParamName(scope), keyName];
       }
 
       return valueName !== undefined &&
         isReferencedOutside(scope, valueName, dropped)
-        ? `(${valueName})`
-        : '()';
+        ? [valueName]
+        : [];
     };
 
     const buildCallbackBody = (
@@ -160,12 +160,12 @@ export const preferObjOverEntriesRoundTrip: TSESLint.RuleModule<
       },
 
       'Program:exit': () => {
-        const objAt = tsDataForgeValuesAt(sourceCode, ['Obj']).at;
+        const objAt = tsDataForgeValuesAt(sourceCode, ['Obj']);
 
         const objOptionalAt = tsDataForgeValuesAt(sourceCode, [
           'Obj',
           'Optional',
-        ]).at;
+        ]);
 
         // Every fix brings the names it writes into scope itself, so that one
         // applied alone (an editor's quick fix) is complete.
@@ -177,11 +177,19 @@ export const preferObjOverEntriesRoundTrip: TSESLint.RuleModule<
           const [objName, optionalName = 'Optional'] =
             binding?.localNames ?? [];
 
+          const paramNames = rebuiltParamNames(roundTrip);
+
+          // `Optional` is written inside the rebuilt callback, where a
+          // parameter it keeps would capture the name `Optional` starts with.
+          const isCaptured =
+            roundTrip.body.kind === 'optional' &&
+            paramNames.includes(optionalName.split('.', 1)[0] ?? optionalName);
+
           context.report({
             node,
             messageId: MESSAGE_ID_OF[roundTrip.method],
             fix:
-              binding === undefined || objName === undefined
+              binding === undefined || objName === undefined || isCaptured
                 ? null
                 : (fixer) => {
                     const recordText = getArgumentText(
@@ -189,7 +197,7 @@ export const preferObjOverEntriesRoundTrip: TSESLint.RuleModule<
                       roundTrip.record,
                     );
 
-                    const replacement = `${objName}.${roundTrip.method}(${recordText}, ${buildParams(roundTrip)} => ${buildCallbackBody(roundTrip, optionalName)})`;
+                    const replacement = `${objName}.${roundTrip.method}(${recordText}, (${paramNames.join(', ')}) => ${buildCallbackBody(roundTrip, optionalName)})`;
 
                     return [
                       ...binding.edits(fixer),

package/src/rules/prefer-obj-over-entries-round-trip.test.mts

@@ -308,6 +308,68 @@ describe('prefer-obj-over-entries-round-trip', () => {
           `,
           errors: [{ messageId: 'useObjFilterMap' }],
         },
+        {
+          name: 'writes through a namespace import',
+          code: dedent`
+            import * as tdf from 'ts-data-forge';
+            const scores = { alice: 1, bob: 2 };
+            const scaled = Object.fromEntries(
+              Object.entries(scores).flatMap(([k, v]) =>
+                v > 1 ? [[k, v * 10]] : [],
+              ),
+            );
+          `,
+          output: dedent`
+            import * as tdf from 'ts-data-forge';
+            const scores = { alice: 1, bob: 2 };
+            const scaled = tdf.Obj.filterMap(scores, (v) => v > 1 ? tdf.Optional.some(v * 10) : tdf.Optional.none);
+          `,
+          errors: [{ messageId: 'useObjFilterMap' }],
+        },
+        {
+          name: 'no fix when a parameter the callback keeps shadows the namespace it reads',
+          code: dedent`
+            import * as tdf from 'ts-data-forge';
+            const scores = { alice: 1, bob: 2 };
+            const scaled = Object.fromEntries(
+              Object.entries(scores).flatMap(([k, tdf]) =>
+                tdf > 1 ? [[k, tdf * 10]] : [],
+              ),
+            );
+          `,
+          output: null,
+          errors: [{ messageId: 'useObjFilterMap' }],
+        },
+        {
+          name: 'no fix when a parameter the callback keeps is named Optional',
+          code: dedent`
+            const scores = { alice: 1, bob: 2 };
+            const scaled = Object.fromEntries(
+              Object.entries(scores).flatMap(([k, Optional]) =>
+                Optional > 1 ? [[k, Optional * 10]] : [],
+              ),
+            );
+          `,
+          output: null,
+          errors: [{ messageId: 'useObjFilterMap' }],
+        },
+        {
+          name: 'a dropped key parameter named Optional captures nothing',
+          code: dedent`
+            const scores = { alice: 1, bob: 2 };
+            const scaled = Object.fromEntries(
+              Object.entries(scores).flatMap(([Optional, v]) =>
+                v > 1 ? [[Optional, v * 10]] : [],
+              ),
+            );
+          `,
+          output: dedent`
+            import { Obj, Optional } from 'ts-data-forge';
+            const scores = { alice: 1, bob: 2 };
+            const scaled = Obj.filterMap(scores, (v) => v > 1 ? Optional.some(v * 10) : Optional.none);
+          `,
+          errors: [{ messageId: 'useObjFilterMap' }],
+        },
         {
           name: 'adds Obj and Optional to one existing import',
           code: dedent`