eslint-plugin-ts-data-forge 0.10.4 → 0.10.6

package/src/rules/prefer-arr-scan.test.mts

@@ -442,3 +442,58 @@ describe('prefer-arr-scan with parenthesized operands', () => {
     ],
   });
 });
+
+describe('prefer-arr-scan and the import it adds', () => {
+  tester.run('prefer-arr-scan', preferArrScan, {
+    valid: [],
+    invalid: [
+      {
+        name: 'writes the local name of an aliased import',
+        code: dedent`
+          import { Arr as A } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const totals = xs.reduce<readonly number[]>(
+            (acc, x) => [...acc, (acc.at(-1) ?? 0) + x],
+            [0],
+          );
+        `,
+        output: dedent`
+          import { Arr as A } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const totals = A.scan(xs, (acc, x) => (acc) + x, 0);
+        `,
+        errors: [{ messageId: 'preferArrScanAccumulate' }],
+      },
+      {
+        name: 'turns a type-only specifier into a value import',
+        code: dedent`
+          import { type Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const totals = xs.reduce<readonly number[]>(
+            (acc, x) => [...acc, (acc.at(-1) ?? 0) + x],
+            [0],
+          );
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const totals = Arr.scan(xs, (acc, x) => (acc) + x, 0);
+        `,
+        errors: [{ messageId: 'preferArrScanAccumulate' }],
+      },
+      {
+        name: 'no fix when an import type binds the name',
+        code: dedent`
+          import type { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const totals = xs.reduce<readonly number[]>(
+            (acc, x) => [...acc, (acc.at(-1) ?? 0) + x],
+            [0],
+          );
+        `,
+        output: null,
+        errors: [{ messageId: 'preferArrScanAccumulate' }],
+      },
+    ],
+  });
+});

package/src/rules/prefer-arr-sum.mts

@@ -4,16 +4,13 @@ import {
   type TSESTree,
 } from '@typescript-eslint/utils';
 import {
-  buildNamedImportFix,
   getArgumentText,
-  getImportDeclarations,
-  getNamedImports,
   skipTypeWrappers,
   typeWrapperLayers,
 } from 'eslint-rule-forge';
 import { Arr, pipe } from 'ts-data-forge';
 import type { TypeReference } from 'typescript';
-import { TS_DATA_FORGE_MODULE } from './constants.mjs';
+import { tsDataForgeValueAt } from './import-binding.mjs';
 
 type Options = readonly [];
 
@@ -39,13 +36,6 @@ export const preferArrSum: TSESLint.RuleModule<MessageIds, Options> = {
   create: (context) => {
     const sourceCode = context.sourceCode;
 
-    const program = sourceCode.ast;
-
-    const tsDataForgeImports = getImportDeclarations(
-      program,
-      TS_DATA_FORGE_MODULE,
-    );
-
     const services = context.sourceCode.parserServices;
 
     const mut_nodesToFix: {
@@ -267,16 +257,16 @@ export const preferArrSum: TSESLint.RuleModule<MessageIds, Options> = {
         }
       },
       'Program:exit': () => {
-        const namedImports = getNamedImports(tsDataForgeImports);
-
-        const hasArrImport = namedImports.includes('Arr');
+        const arrAt = tsDataForgeValueAt(sourceCode, 'Arr');
 
-        for (const [index, nodeInfo] of mut_nodesToFix.entries()) {
+        for (const nodeInfo of mut_nodesToFix) {
           const arrayText = getArgumentText(
             sourceCode,
             nodeInfo.arrayExpression,
           );
 
+          const arr = arrAt(nodeInfo.node);
+
           context.report({
             node: nodeInfo.node,
             messageId: nodeInfo.messageId,
@@ -284,24 +274,20 @@ export const preferArrSum: TSESLint.RuleModule<MessageIds, Options> = {
               arrayName: arrayText,
               mapper: nodeInfo.mapper ?? '',
             },
-            fix: (fixer) => {
-              const replacement =
-                nodeInfo.messageId === 'useArrSum'
-                  ? `Arr.sum(${arrayText})`
-                  : `Arr.sumBy(${arrayText}, ${nodeInfo.mapper})`;
-
-              const importFixes =
-                index === 0 && !hasArrImport
-                  ? buildNamedImportFix(fixer, program, TS_DATA_FORGE_MODULE, [
-                      'Arr',
-                    ])
-                  : [];
-
-              return [
-                ...importFixes,
-                fixer.replaceText(nodeInfo.node, replacement),
-              ];
-            },
+            fix:
+              arr === undefined
+                ? null
+                : (fixer) => {
+                    const replacement =
+                      nodeInfo.messageId === 'useArrSum'
+                        ? `${arr.localName}.sum(${arrayText})`
+                        : `${arr.localName}.sumBy(${arrayText}, ${nodeInfo.mapper})`;
+
+                    return [
+                      ...arr.edits(fixer),
+                      fixer.replaceText(nodeInfo.node, replacement),
+                    ];
+                  },
           });
         }
       },

package/src/rules/prefer-arr-uniq.mts

@@ -5,16 +5,14 @@ import {
   type TSESTree,
 } from '@typescript-eslint/utils';
 import {
-  buildNamedImportFix,
   getArgumentText,
-  getImportDeclarations,
-  getImportedLocalName,
   skipTypeWrappers,
   typeWrapperLayers,
 } from 'eslint-rule-forge';
 import { Arr } from 'ts-data-forge';
 import * as ts from 'typescript';
-import { primitiveTypeFlags, TS_DATA_FORGE_MODULE } from './constants.mjs';
+import { primitiveTypeFlags } from './constants.mjs';
+import { tsDataForgeValueAt } from './import-binding.mjs';
 import { needsMutableResult } from './mutable-result.mjs';
 
 type Options = readonly [];
@@ -51,13 +49,6 @@ export const preferArrUniq: TSESLint.RuleModule<MessageIds, Options> = {
   create: (context) => {
     const sourceCode = context.sourceCode;
 
-    const program = sourceCode.ast;
-
-    const tsDataForgeImports = getImportDeclarations(
-      program,
-      TS_DATA_FORGE_MODULE,
-    );
-
     const services = sourceCode.parserServices;
 
     const checker = services?.program?.getTypeChecker();
@@ -159,14 +150,7 @@ export const preferArrUniq: TSESLint.RuleModule<MessageIds, Options> = {
         check(node, element.argument);
       },
       'Program:exit': () => {
-        const arrLocalName = getImportedLocalName(tsDataForgeImports, 'Arr');
-
-        const arrName = arrLocalName ?? 'Arr';
-
-        // The import is added by the first fix only, so that several fixes do
-        // not insert it at the same position. When the first match is not
-        // autofixable, the first autofixable one carries it instead.
-        const firstAutofixable = mut_matches.find((m) => m.autofixable);
+        const arrAt = tsDataForgeValueAt(sourceCode, 'Arr');
 
         for (const match of mut_matches) {
           const arrayText = sourceCode.getText(match.arrayExpression);
@@ -176,16 +160,18 @@ export const preferArrUniq: TSESLint.RuleModule<MessageIds, Options> = {
             match.arrayExpression,
           );
 
-          const buildFix =
-            (withImport: boolean): TSESLint.ReportFixFunction =>
-            (fixer) => [
-              ...(withImport && arrLocalName === undefined
-                ? buildNamedImportFix(fixer, program, TS_DATA_FORGE_MODULE, [
-                    'Arr',
-                  ])
-                : []),
-              fixer.replaceText(match.node, `${arrName}.uniq(${argumentText})`),
-            ];
+          const arr = arrAt(match.node);
+
+          const fix: TSESLint.ReportFixFunction | null =
+            arr === undefined
+              ? null
+              : (fixer) => [
+                  ...arr.edits(fixer),
+                  fixer.replaceText(
+                    match.node,
+                    `${arr.localName}.uniq(${argumentText})`,
+                  ),
+                ];
 
           const data = { arrayName: arrayText } as const;
 
@@ -194,20 +180,23 @@ export const preferArrUniq: TSESLint.RuleModule<MessageIds, Options> = {
               node: match.node,
               messageId: 'useArrUniq',
               data,
-              fix: buildFix(match === firstAutofixable),
+              fix,
             });
           } else {
             context.report({
               node: match.node,
               messageId: 'useArrUniq',
               data,
-              suggest: [
-                {
-                  messageId: 'suggestArrUniq',
-                  data,
-                  fix: buildFix(true),
-                },
-              ],
+              suggest:
+                fix === null
+                  ? []
+                  : [
+                      {
+                        messageId: 'suggestArrUniq',
+                        data,
+                        fix,
+                      },
+                    ],
             });
           }
         }
@@ -257,6 +246,29 @@ const isGlobal = (
   return variable === null || variable.defs.length === 0;
 };
 
+const resolveConstraint = (
+  // 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,
+): ts.Type =>
+  (type.flags & ts.TypeFlags.TypeParameter) !== 0
+    ? (checker.getBaseConstraintOfType(type) ?? type)
+    : type;
+
+const isPrimitiveType = (
+  // 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 => {
+  const resolved = resolveConstraint(checker, type);
+
+  return resolved.isUnion()
+    ? resolved.types.every((t) => isPrimitiveType(checker, t))
+    : (resolved.flags & primitiveTypeFlags) !== 0;
+};
+
 /**
  * Whether `type` is an array or tuple (or a union or intersection of them) whose elements are
  * all primitives, i.e. something `Arr.uniq` accepts.
@@ -291,26 +303,3 @@ const isPrimitiveArrayType = (
   // An empty tuple has nothing to deduplicate, but is still accepted.
   return typeArguments.every((t) => isPrimitiveType(checker, t));
 };
-
-const isPrimitiveType = (
-  // 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 => {
-  const resolved = resolveConstraint(checker, type);
-
-  return resolved.isUnion()
-    ? resolved.types.every((t) => isPrimitiveType(checker, t))
-    : (resolved.flags & primitiveTypeFlags) !== 0;
-};
-
-const resolveConstraint = (
-  // 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,
-): ts.Type =>
-  (type.flags & ts.TypeFlags.TypeParameter) !== 0
-    ? (checker.getBaseConstraintOfType(type) ?? type)
-    : type;

package/src/rules/prefer-arr-uniq.test.mts

@@ -188,12 +188,20 @@ describe('prefer-arr-uniq', () => {
           const ys = [...new Set(xs)];
           const zs = Array.from(new Set(xs));
         `,
-        output: dedent`
-          import { Arr } from 'ts-data-forge';
-          const xs = ['a', 'b'];
-          const ys = Arr.uniq(xs);
-          const zs = Arr.uniq(xs);
-        `,
+        output: [
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            const xs = ['a', 'b'];
+            const ys = Arr.uniq(xs);
+            const zs = Array.from(new Set(xs));
+          `,
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            const xs = ['a', 'b'];
+            const ys = Arr.uniq(xs);
+            const zs = Arr.uniq(xs);
+          `,
+        ],
         errors: [{ messageId: 'useArrUniq' }, { messageId: 'useArrUniq' }],
       },
       {
@@ -205,14 +213,24 @@ describe('prefer-arr-uniq', () => {
           const b = [...new Set(u)];
           const c = Array.from(new Set([1, 2, 1]));
         `,
-        output: dedent`
-          import { Arr } from 'ts-data-forge';
-          const t = [1, 'a', 1] as const;
-          const u: readonly ('x' | 'y' | null | undefined | boolean | bigint)[] = [];
-          const a = Arr.uniq(t);
-          const b = Arr.uniq(u);
-          const c = Arr.uniq([1, 2, 1]);
-        `,
+        output: [
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            const t = [1, 'a', 1] as const;
+            const u: readonly ('x' | 'y' | null | undefined | boolean | bigint)[] = [];
+            const a = Arr.uniq(t);
+            const b = [...new Set(u)];
+            const c = Array.from(new Set([1, 2, 1]));
+          `,
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            const t = [1, 'a', 1] as const;
+            const u: readonly ('x' | 'y' | null | undefined | boolean | bigint)[] = [];
+            const a = Arr.uniq(t);
+            const b = Arr.uniq(u);
+            const c = Arr.uniq([1, 2, 1]);
+          `,
+        ],
         errors: [
           { messageId: 'useArrUniq' },
           { messageId: 'useArrUniq' },
@@ -465,12 +483,20 @@ describe('prefer-arr-uniq through type wrappers', () => {
           const a = Array.from(new Set(xs) as ReadonlySet<string>);
           const b = [...(new Set(xs) satisfies ReadonlySet<string>)];
         `,
-        output: dedent`
-          import { Arr } from 'ts-data-forge';
-          declare const xs: readonly string[];
-          const a = Arr.uniq(xs);
-          const b = Arr.uniq(xs);
-        `,
+        output: [
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly string[];
+            const a = Arr.uniq(xs);
+            const b = [...(new Set(xs) satisfies ReadonlySet<string>)];
+          `,
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly string[];
+            const a = Arr.uniq(xs);
+            const b = Arr.uniq(xs);
+          `,
+        ],
         errors: [{ messageId: 'useArrUniq' }, { messageId: 'useArrUniq' }],
       },
       {

package/src/rules/prefer-as-int.mts

@@ -3,15 +3,10 @@ import {
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
-import {
-  buildNamedImportFix,
-  getArgumentText,
-  getImportDeclarations,
-  getNamedImports,
-} from 'eslint-rule-forge';
+import { getArgumentText } from 'eslint-rule-forge';
 import type { DeepReadonly } from 'ts-type-forge';
 import { brandedNumberTypeNameToFunctionName } from './branded-number-types.mjs';
-import { TS_DATA_FORGE_MODULE } from './constants.mjs';
+import { tsDataForgeValueAtByName } from './import-binding.mjs';
 
 type Options = readonly [];
 
@@ -36,13 +31,6 @@ export const preferAsInt: TSESLint.RuleModule<MessageIds, Options> = {
   create: (context) => {
     const sourceCode = context.sourceCode;
 
-    const program = sourceCode.ast;
-
-    const tsDataForgeImports = getImportDeclarations(
-      program,
-      TS_DATA_FORGE_MODULE,
-    );
-
     const mut_nodesToFix: {
       node: TSESTree.TSAsExpression | TSESTree.TSTypeAssertion;
       typeName: string;
@@ -71,44 +59,31 @@ export const preferAsInt: TSESLint.RuleModule<MessageIds, Options> = {
       TSAsExpression: collect,
       TSTypeAssertion: collect,
       'Program:exit': () => {
-        const namedImports = getNamedImports(tsDataForgeImports);
-
-        // Group nodes by function name to handle imports efficiently
-        const functionNameToNodes = Map.groupBy(
-          mut_nodesToFix,
-          (nodeInfo) => nodeInfo.functionName,
-        );
-
-        // Process each group
-        for (const [functionName, nodes] of functionNameToNodes) {
-          const hasImport = namedImports.includes(functionName);
-
-          for (const [index, { node, typeName }] of nodes.entries()) {
-            context.report({
-              node,
-              messageId: 'useBrandedNumberCastFunction',
-              data: {
-                typeName,
-                functionName,
-              },
-              fix: (fixer) => {
-                const replacement = `${functionName}(${getArgumentText(sourceCode, node.expression)})`;
-
-                // Add import only for the first node of this function and only if not already imported
-                const importFixes =
-                  index === 0 && !hasImport
-                    ? buildNamedImportFix(
-                        fixer,
-                        program,
-                        TS_DATA_FORGE_MODULE,
-                        [functionName],
-                      )
-                    : [];
-
-                return [...importFixes, fixer.replaceText(node, replacement)];
-              },
-            });
-          }
+        // One binding per cast function, however many casts use it.
+        const castAt = tsDataForgeValueAtByName(sourceCode);
+
+        for (const { node, typeName, functionName } of mut_nodesToFix) {
+          const cast = castAt(functionName)(node);
+
+          context.report({
+            node,
+            messageId: 'useBrandedNumberCastFunction',
+            data: {
+              typeName,
+              // The name the fix writes: an aliased import's local name.
+              functionName: cast?.localName ?? functionName,
+            },
+            fix:
+              cast === undefined
+                ? null
+                : (fixer) => [
+                    ...cast.edits(fixer),
+                    fixer.replaceText(
+                      node,
+                      `${cast.localName}(${getArgumentText(sourceCode, node.expression)})`,
+                    ),
+                  ],
+          });
         }
       },
     };

package/src/rules/prefer-as-int.test.mts

@@ -60,24 +60,6 @@ describe('prefer-as-int', () => {
           `,
           errors: [{ messageId: 'useBrandedNumberCastFunction' }],
         },
-        {
-          name: 'replaces multiple as Int with asInt imports',
-          code: dedent`
-            const n = 1;
-            const result = n as Int;
-            const another = (n + 1) as Int;
-          `,
-          output: dedent`
-            import { asInt } from 'ts-data-forge';
-            const n = 1;
-            const result = asInt(n);
-            const another = asInt(n + 1);
-          `,
-          errors: [
-            { messageId: 'useBrandedNumberCastFunction' },
-            { messageId: 'useBrandedNumberCastFunction' },
-          ],
-        },
         // {
         //   name: 'replaces as Int with asInt import with another disabled line',
         //   code: dedent`
@@ -140,7 +122,7 @@ describe('prefer-as-int', () => {
 
       ...([
         {
-          name: 'adds import even if ts-data-forge import exists',
+          name: 'adds the name to an existing ts-data-forge import',
           code: dedent`
             import { isNonNullObject } from 'ts-data-forge';
 
@@ -148,8 +130,7 @@ describe('prefer-as-int', () => {
             const result = n as Int;
           `,
           output: dedent`
-            import { asInt } from 'ts-data-forge';
-            import { isNonNullObject } from 'ts-data-forge';
+            import { isNonNullObject, asInt } from 'ts-data-forge';
 
             const n = 1;
             const result = asInt(n);
@@ -157,7 +138,7 @@ describe('prefer-as-int', () => {
           errors: [{ messageId: 'useBrandedNumberCastFunction' }],
         },
         {
-          name: 'adds import even if ts-data-forge import exists (with other imports)',
+          name: 'adds the name to an existing ts-data-forge import (with other imports)',
           code: dedent`
             import { noop } from './noop.mjs';
             import { isNonNullObject } from 'ts-data-forge';
@@ -166,9 +147,8 @@ describe('prefer-as-int', () => {
             const result = n as Int;
           `,
           output: dedent`
-            import { asInt } from 'ts-data-forge';
             import { noop } from './noop.mjs';
-            import { isNonNullObject } from 'ts-data-forge';
+            import { isNonNullObject, asInt } from 'ts-data-forge';
 
             const n = 1;
             const result = asInt(n);
@@ -183,6 +163,32 @@ describe('prefer-as-int', () => {
   tester.run('prefer-as-int (other types)', preferAsInt, {
     valid: [],
     invalid: [
+      {
+        name: 'replaces multiple as Int with asInt imports',
+        code: dedent`
+          const n = 1;
+          const result = n as Int;
+          const another = (n + 1) as Int;
+        `,
+        output: [
+          dedent`
+            import { asInt } from 'ts-data-forge';
+            const n = 1;
+            const result = asInt(n);
+            const another = (n + 1) as Int;
+          `,
+          dedent`
+            import { asInt } from 'ts-data-forge';
+            const n = 1;
+            const result = asInt(n);
+            const another = asInt(n + 1);
+          `,
+        ],
+        errors: [
+          { messageId: 'useBrandedNumberCastFunction' },
+          { messageId: 'useBrandedNumberCastFunction' },
+        ],
+      },
       {
         name: 'replaces as Uint32 with asUint32',
         code: dedent`
@@ -239,17 +245,14 @@ describe('prefer-as-int', () => {
             const c = n as SafeInt;
           `,
           dedent`
-            import { asUint32 } from 'ts-data-forge';
-            import { asInt } from 'ts-data-forge';
+            import { asInt, asUint32 } from 'ts-data-forge';
             const n = 1;
             const a = asInt(n);
             const b = asUint32(n);
             const c = n as SafeInt;
           `,
           dedent`
-            import { asSafeInt } from 'ts-data-forge';
-            import { asUint32 } from 'ts-data-forge';
-            import { asInt } from 'ts-data-forge';
+            import { asInt, asUint32, asSafeInt } from 'ts-data-forge';
             const n = 1;
             const a = asInt(n);
             const b = asUint32(n);
@@ -316,3 +319,50 @@ describe('prefer-as-int with parenthesized operands', () => {
     ],
   });
 }, 20000);
+
+describe('prefer-as-int and the import it adds', () => {
+  tester.run('prefer-as-int', preferAsInt, {
+    valid: [],
+    invalid: [
+      {
+        name: 'writes the local name of an aliased import',
+        code: dedent`
+          import { asInt as toInt } from 'ts-data-forge';
+          const n = 1;
+          const result = n as Int;
+        `,
+        output: dedent`
+          import { asInt as toInt } from 'ts-data-forge';
+          const n = 1;
+          const result = toInt(n);
+        `,
+        errors: [
+          {
+            messageId: 'useBrandedNumberCastFunction',
+            data: { typeName: 'Int', functionName: 'toInt' },
+          },
+        ],
+      },
+      {
+        name: 'no fix when an import type binds the name',
+        code: dedent`
+          import type { asInt } from 'ts-data-forge';
+          const n = 1;
+          const result = n as Int;
+        `,
+        output: null,
+        errors: [{ messageId: 'useBrandedNumberCastFunction' }],
+      },
+      {
+        name: 'no fix where a local binding takes the name',
+        code: dedent`
+          const asInt = (x: number): number => x;
+          const n = 1;
+          const result = n as Int;
+        `,
+        output: null,
+        errors: [{ messageId: 'useBrandedNumberCastFunction' }],
+      },
+    ],
+  });
+}, 20000);