eslint-plugin-ts-data-forge 0.10.5 → 0.10.7

package/src/rules/prefer-arr-is-non-empty.test.mts

@@ -167,3 +167,113 @@ describe('prefer-arr-is-non-empty with parenthesized operands', () => {
     ],
   });
 }, 20000);
+
+describe('prefer-arr-is-non-empty and the import it adds', () => {
+  tester.run('prefer-arr-is-non-empty', preferArrIsNonEmpty, {
+    valid: [],
+    invalid: [
+      {
+        name: 'a leading directive stays first',
+        code: dedent`
+          'use client';
+          declare const xs: readonly number[];
+          const ok = xs.length > 0;
+        `,
+        output: dedent`
+          'use client';
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ok = Arr.isNonEmpty(xs);
+        `,
+        errors: [{ messageId: 'useIsNonEmpty' }],
+      },
+      {
+        name: 'joins an existing named import from the module',
+        code: dedent`
+          import { asInt } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ok = xs.length > 0;
+        `,
+        output: dedent`
+          import { asInt, Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ok = Arr.isNonEmpty(xs);
+        `,
+        errors: [{ messageId: 'useIsNonEmpty' }],
+      },
+      {
+        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 ok = xs.length > 0;
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ok = Arr.isNonEmpty(xs);
+        `,
+        errors: [{ messageId: 'useIsNonEmpty' }],
+      },
+      {
+        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 ok = xs.length > 0;
+        `,
+        output: dedent`
+          import { Arr as A } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ok = A.isNonEmpty(xs);
+        `,
+        errors: [{ messageId: 'useIsNonEmpty' }],
+      },
+      {
+        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 ok = xs.length > 0;
+        `,
+        output: null,
+        errors: [{ messageId: 'useIsNonEmpty' }],
+      },
+      {
+        name: 'no fix where a local binding takes the name',
+        code: dedent`
+          declare const xs: readonly number[];
+          const f = (Arr: unknown) => xs.length > 0;
+        `,
+        output: null,
+        errors: [{ messageId: 'useIsNonEmpty' }],
+      },
+      {
+        name: 'each fix adds the import it needs, one per pass',
+        code: dedent`
+          declare const xs: readonly number[];
+          const a = xs.length > 0;
+          const b = 0 < xs.length;
+        `,
+        output: [
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            const a = Arr.isNonEmpty(xs);
+            const b = 0 < xs.length;
+          `,
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            const a = Arr.isNonEmpty(xs);
+            const b = Arr.isNonEmpty(xs);
+          `,
+        ],
+        errors: [
+          { messageId: 'useIsNonEmpty' },
+          { messageId: 'useIsNonEmpty' },
+        ],
+      },
+    ],
+  });
+}, 20000);

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

@@ -4,17 +4,14 @@ import {
   type TSESTree,
 } from '@typescript-eslint/utils';
 import {
-  buildNamedImportFix,
   getArgumentText,
-  getImportDeclarations,
-  getNamedImports,
   skipTypeWrappers,
   typeWrapperLayers,
 } from 'eslint-rule-forge';
 import { Arr } from 'ts-data-forge';
 import type { FixedLengthTuple } from 'ts-type-forge';
 import * as ts from 'typescript';
-import { TS_DATA_FORGE_MODULE } from './constants.mjs';
+import { tsDataForgeValueAt } from './import-binding.mjs';
 
 type Options = readonly [];
 
@@ -47,8 +44,9 @@ type SliceCall = Readonly<{
 type AccumulationCandidate = Readonly<{
   call: TSESTree.CallExpression;
   /**
-   * What the call is replaced with, or `undefined` when the rewrite could not
-   * be derived and the report carries no fix.
+   * What the call is replaced with, after the name `Arr` is bound to
+   * (`scan(xs, f, init)`), or `undefined` when the rewrite could not be derived
+   * and the report carries no fix.
    */
   replacement: string | undefined;
 }>;
@@ -180,13 +178,6 @@ export const preferArrScan: 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();
@@ -289,12 +280,12 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
       // `acc.at(-1)` is `T | undefined` only because `at` can go out of bounds,
       // which a seeded accumulator never does. So once the value `scan` carries
       // is known not to be nullish, a `?? fallback` guarding the read is dead
-      // and the fix takes it with the read — leaving it would hand the author an
-      // unnecessary condition that no rule can fix for them. Every layer of
-      // type wrappers is asked (see typeWrapperLayers): the value under an
-      // `as` / `!` is what `scan` carries at run time (`[init!]` may still
-      // hold `undefined`), and a wider type a wrapper states is the author
-      // saying it may be nullish.
+      // and the fix takes it with the read — leaving it would hand the author
+      // an unnecessary condition that no rule can fix for them. Every layer of
+      // type wrappers is asked (see typeWrapperLayers): the value under an `as`
+      // / `!` is what `scan` carries at run time (`[init!]` may still hold
+      // `undefined`), and a wider type a wrapper states is the author saying it
+      // may be nullish.
       const carriesNullish = [seed, element].some((node) =>
         typeWrapperLayers(node).some(isNullish),
       );
@@ -363,7 +354,7 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
           ? `(${elementText})`
           : elementText;
 
-      return `Arr.scan(${arrayText}, (${parameterText}) => ${bodyText}, ${getArgumentText(sourceCode, seed)})`;
+      return `scan(${arrayText}, (${parameterText}) => ${bodyText}, ${getArgumentText(sourceCode, seed)})`;
     };
 
     /**
@@ -498,36 +489,20 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
       // been seen by the time its `map` is judged, whichever order the traversal
       // reached them in.
       'Program:exit': () => {
-        const hasArrImport =
-          getNamedImports(tsDataForgeImports).includes('Arr');
-
-        // The import is inserted once per pass: two fixes writing the same
-        // insertion point would otherwise produce it twice.
-        const mut_importNeededBy = hasArrImport
-          ? undefined
-          : mut_accumulations.find(
-              (accumulation) => accumulation.replacement !== undefined,
-            )?.call;
+        const arrAt = tsDataForgeValueAt(sourceCode, 'Arr');
 
-        for (const accumulation of mut_accumulations) {
-          const { call, replacement } = accumulation;
+        for (const { call, replacement } of mut_accumulations) {
+          const arr = arrAt(call);
 
           context.report({
             node: call,
             messageId: 'preferArrScanAccumulate',
             fix:
-              replacement === undefined
+              replacement === undefined || arr === undefined
                 ? undefined
                 : (fixer) => [
-                    ...(call === mut_importNeededBy
-                      ? buildNamedImportFix(
-                          fixer,
-                          program,
-                          TS_DATA_FORGE_MODULE,
-                          ['Arr'],
-                        )
-                      : []),
-                    fixer.replaceText(call, replacement),
+                    ...arr.edits(fixer),
+                    fixer.replaceText(call, `${arr.localName}.${replacement}`),
                   ],
           });
         }

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: {
@@ -77,9 +67,9 @@ export const preferArrSum: TSESLint.RuleModule<MessageIds, Options> = {
 
         const reducer = node.arguments[0];
 
-        // The initial value and the operands of the body are read through
-        // type wrappers: `0 as number` is still 0, `(b satisfies number)` is
-        // still `b`. Types are asked of the values underneath too.
+        // The initial value and the operands of the body are read through type
+        // wrappers: `0 as number` is still 0, `(b satisfies number)` is still
+        // `b`. Types are asked of the values underneath too.
         const initialValue = skipTypeWrappers(node.arguments[1]);
 
         // Check initial value is 0
@@ -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,21 +49,14 @@ 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();
 
     const esTreeNodeToTSNodeMap = services?.esTreeNodeToTSNodeMap;
 
-    // Without type information the rule cannot tell an array of primitives
-    // from an array of objects, and would suggest code that does not compile.
+    // Without type information the rule cannot tell an array of primitives from
+    // an array of objects, and would suggest code that does not compile.
     if (checker === undefined || esTreeNodeToTSNodeMap === undefined) {
       return {};
     }
@@ -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' }],
       },
       {