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

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

@@ -5,11 +5,14 @@ import {
   type TSESTree,
 } from '@typescript-eslint/utils';
 import {
-  buildNamedImportFix,
+  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';
@@ -210,10 +213,16 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
     const checker = parserServices.program.getTypeChecker();
 
     /**
-     * The in-scope way to reference the `Arr` namespace: a named import
-     * (possibly aliased), a namespace import member, or the canonical `Arr`
-     * (added by the import fix when nothing is imported yet).
+     * 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');
 
     const namespaceLocalName = tsDataForgeImports
@@ -223,12 +232,7 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
           specifier.type === AST_NODE_TYPES.ImportNamespaceSpecifier,
       )?.local.name;
 
-    const arrRef =
-      arrLocalName ??
-      (namespaceLocalName === undefined ? 'Arr' : `${namespaceLocalName}.Arr`);
-
-    const needsArrImport =
-      arrLocalName === undefined && namespaceLocalName === undefined;
+    const arrRef = arrTarget?.ref ?? 'Arr';
 
     /**
      * Deferred (non-concrete) types are reduced to their base constraint
@@ -855,27 +859,85 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
       },
 
       'Program:exit': () => {
-        for (const [index, nodeInfo] of mut_nodesToFix.entries()) {
+        // 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,
+            );
+
           context.report({
             node: nodeInfo.node,
             messageId: 'preferCanonicalArraySlicing',
             data: { replacement: nodeInfo.replacement },
-            fix: (fixer) => {
-              const importFixes =
-                index === 0 && needsArrImport
-                  ? buildNamedImportFix(fixer, program, TS_DATA_FORGE_MODULE, [
-                      'Arr',
-                    ])
-                  : [];
-
-              return [
-                ...importFixes,
-                fixer.replaceText(nodeInfo.node, nodeInfo.replacement),
-              ];
-            },
+            fix: writable
+              ? (fixer) => [
+                  ...arrTarget.edits(fixer),
+                  fixer.replaceText(nodeInfo.node, nodeInfo.replacement),
+                ]
+              : null,
           });
         }
       },
     };
   },
 } 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: () => [],
+    };
+  }
+
+  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

@@ -572,12 +572,20 @@ describe('prefer-canonical-array-slicing', () => {
           const ys = xs.slice(1);
           const zs = xs.slice(0, -1);
         `,
-        output: dedent`
-          import { Arr } from 'ts-data-forge';
-          declare const xs: readonly number[];
-          const ys = Arr.tail(xs);
-          const zs = Arr.butLast(xs);
-        `,
+        output: [
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            const ys = Arr.tail(xs);
+            const zs = xs.slice(0, -1);
+          `,
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            const ys = Arr.tail(xs);
+            const zs = Arr.butLast(xs);
+          `,
+        ],
         errors: [
           { messageId: 'preferCanonicalArraySlicing' },
           { messageId: 'preferCanonicalArraySlicing' },
@@ -629,13 +637,22 @@ describe('prefer-canonical-array-slicing through type wrappers', () => {
           const b = xs.slice(0 satisfies number, -1 as number);
           const c = xs.toSpliced(2 satisfies number);
         `,
-        output: dedent`
-          import { Arr } from 'ts-data-forge';
-          declare const xs: readonly number[];
-          const a = Arr.tail(xs);
-          const b = Arr.butLast(xs);
-          const c = Arr.take(xs, 2);
-        `,
+        output: [
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            const a = Arr.tail(xs);
+            const b = xs.slice(0 satisfies number, -1 as number);
+            const c = xs.toSpliced(2 satisfies number);
+          `,
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            const a = Arr.tail(xs);
+            const b = Arr.butLast(xs);
+            const c = Arr.take(xs, 2);
+          `,
+        ],
         errors: [
           { messageId: 'preferCanonicalArraySlicing' },
           { messageId: 'preferCanonicalArraySlicing' },
@@ -663,13 +680,22 @@ describe('prefer-canonical-array-slicing through type wrappers', () => {
           const ys = (xs satisfies readonly number[]).slice(1);
           const zs = [...xs!, v!];
         `,
-        output: dedent`
-          import { Arr } from 'ts-data-forge';
-          declare const xs: readonly number[];
-          declare const v: number | undefined;
-          const ys = Arr.tail(xs satisfies readonly number[]);
-          const zs = Arr.toPushed(xs!, v!);
-        `,
+        output: [
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            declare const v: number | undefined;
+            const ys = Arr.tail(xs satisfies readonly number[]);
+            const zs = [...xs!, v!];
+          `,
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            declare const v: number | undefined;
+            const ys = Arr.tail(xs satisfies readonly number[]);
+            const zs = Arr.toPushed(xs!, v!);
+          `,
+        ],
         errors: [
           { messageId: 'preferCanonicalArraySlicing' },
           { messageId: 'preferCanonicalArraySlicing' },
@@ -697,14 +723,24 @@ describe('prefer-canonical-array-slicing through type wrappers', () => {
           const c = xs.filter((_, i) => i < (xs.length satisfies number) - 2);
           const d = xs.toSpliced(0, xs!.length - 2);
         `,
-        output: dedent`
-          import { Arr } from 'ts-data-forge';
-          declare const xs: readonly number[];
-          const a = Arr.butLast(xs);
-          const b = Arr.butLast(xs);
-          const c = Arr.skipLast(xs, 2);
-          const d = Arr.takeLast(xs, 2);
-        `,
+        output: [
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            const a = Arr.butLast(xs);
+            const b = xs.slice(0, (xs as readonly number[]).length - 1);
+            const c = xs.filter((_, i) => i < (xs.length satisfies number) - 2);
+            const d = xs.toSpliced(0, xs!.length - 2);
+          `,
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            const a = Arr.butLast(xs);
+            const b = Arr.butLast(xs);
+            const c = Arr.skipLast(xs, 2);
+            const d = Arr.takeLast(xs, 2);
+          `,
+        ],
         errors: [
           { messageId: 'preferCanonicalArraySlicing' },
           { messageId: 'preferCanonicalArraySlicing' },
@@ -719,12 +755,20 @@ describe('prefer-canonical-array-slicing through type wrappers', () => {
           const a = (xs satisfies readonly number[]).slice(0, xs.length - 1);
           const b = xs.toSpliced((xs.length as number), 0, 1);
         `,
-        output: dedent`
-          import { Arr } from 'ts-data-forge';
-          declare const xs: readonly number[];
-          const a = Arr.butLast(xs satisfies readonly number[]);
-          const b = Arr.toPushed(xs, 1);
-        `,
+        output: [
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            const a = Arr.butLast(xs satisfies readonly number[]);
+            const b = xs.toSpliced((xs.length as number), 0, 1);
+          `,
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            const a = Arr.butLast(xs satisfies readonly number[]);
+            const b = Arr.toPushed(xs, 1);
+          `,
+        ],
         errors: [
           { messageId: 'preferCanonicalArraySlicing' },
           { messageId: 'preferCanonicalArraySlicing' },
@@ -733,3 +777,58 @@ 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: [],
+    invalid: [
+      {
+        name: 'writes through a namespace import, which needs no edit',
+        code: dedent`
+          import * as tdf from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ys = xs.slice(1);
+        `,
+        output: dedent`
+          import * as tdf from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ys = tdf.Arr.tail(xs);
+        `,
+        errors: [{ messageId: 'preferCanonicalArraySlicing' }],
+      },
+      {
+        name: 'joins an existing named import from the module',
+        code: dedent`
+          import { asInt } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ys = xs.slice(1);
+        `,
+        output: dedent`
+          import { asInt, Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ys = Arr.tail(xs);
+        `,
+        errors: [{ messageId: 'preferCanonicalArraySlicing' }],
+      },
+      {
+        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 ys = xs.slice(1);
+        `,
+        output: null,
+        errors: [{ messageId: 'preferCanonicalArraySlicing' }],
+      },
+      {
+        name: 'no fix where a local binding takes the name',
+        code: dedent`
+          declare const xs: readonly number[];
+          const f = (Arr: unknown) => xs.slice(1);
+        `,
+        output: null,
+        errors: [{ messageId: 'preferCanonicalArraySlicing' }],
+      },
+    ],
+  });
+});

package/src/rules/prefer-canonical-length-cast.mts

@@ -218,6 +218,24 @@ const getCastName = (
     : undefined;
 };
 
+/**
+ * A non-negative integer literal's value, or `undefined` for anything else.
+ * Read through type wrappers: `1 as const` is still the bound `1`.
+ */
+const getLengthLiteral = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  wrapped: TSESTree.Node,
+): number | undefined => {
+  const node = skipTypeWrappers(wrapped);
+
+  return node.type === AST_NODE_TYPES.Literal &&
+    typeof node.value === 'number' &&
+    Number.isSafeInteger(node.value) &&
+    node.value >= 0
+    ? node.value
+    : undefined;
+};
+
 /**
  * Whether the call is `cast(...bounds, array)` with every bound written as the
  * exact numeric literal the rewrite requires.
@@ -319,21 +337,3 @@ const dropBoundsFix = (
       ? []
       : [fixer.removeRange([start.range[0], end.range[0]])];
   });
-
-/**
- * A non-negative integer literal's value, or `undefined` for anything else.
- * Read through type wrappers: `1 as const` is still the bound `1`.
- */
-const getLengthLiteral = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  wrapped: TSESTree.Node,
-): number | undefined => {
-  const node = skipTypeWrappers(wrapped);
-
-  return node.type === AST_NODE_TYPES.Literal &&
-    typeof node.value === 'number' &&
-    Number.isSafeInteger(node.value) &&
-    node.value >= 0
-    ? node.value
-    : undefined;
-};