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

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`