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

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);

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';
@@ -84,8 +87,8 @@ const asNegatedPositiveIntegerLiteral = (
 
 /**
  * Whether re-reading the expression is free of side effects (a plain variable
- * or a non-computed property chain, type wrappers aside). Required for
- * patterns that reference the receiver twice, such as
+ * or a non-computed property chain, type wrappers aside). Required for patterns
+ * that reference the receiver twice, such as
  * `xs.filter((_, i) => i < xs.length - 1)`.
  */
 const isSimpleReference = (wrapped: TSESTree.Node): boolean => {
@@ -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,16 +232,11 @@ 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
-     * before checking; `any` / `unknown` are conservatively not array-like.
+     * Deferred (non-concrete) types are reduced to their base constraint before
+     * checking; `any` / `unknown` are conservatively not array-like.
      */
     const isArrayOrTupleType = (type: ts.Type): boolean => {
       if ((type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0) {
@@ -394,8 +398,8 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
 
     /**
      * Matches an index-only filter callback (`(_, i) => <comparison>`) and
-     * classifies the comparison. Both a leading index (`i >= 1`) and a
-     * trailing index (`1 <= i`) operand order are accepted.
+     * classifies the comparison. Both a leading index (`i >= 1`) and a trailing
+     * index (`1 <= i`) operand order are accepted.
      */
     const classifyFilterCallback = (
       callback: TSESTree.CallExpressionArgument,
@@ -467,10 +471,10 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
         return undefined;
       }
 
-      // The element parameter must not participate in the comparison (only
-      // the index side and a receiver-independent bound are recognized, so
-      // reaching here with an element reference is impossible for literals,
-      // but `xs.length - N` needs a stable receiver).
+      // The element parameter must not participate in the comparison (only the
+      // index side and a receiver-independent bound are recognized, so reaching
+      // here with an element reference is impossible for literals, but
+      // `xs.length - N` needs a stable receiver).
       const n = asNonNegativeIntegerLiteral(other);
 
       if (n !== undefined) {
@@ -720,8 +724,8 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
           return;
         }
 
-        // The receiver must be an array or tuple (not a string / typed array
-        // / other object that happens to share the method name).
+        // The receiver must be an array or tuple (not a string / typed array /
+        // other object that happens to share the method name).
         if (!holdsThroughWrappers(receiver, isArrayOrTupleType)) {
           return;
         }
@@ -794,8 +798,8 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
               return;
             }
 
-            // `xs.concat(item)` appends only when `item` can never be an
-            // array (otherwise `concat` would flatten it).
+            // `xs.concat(item)` appends only when `item` can never be an array
+            // (otherwise `concat` would flatten it).
             if (holdsThroughWrappers(arg, isDefinitelyNotArrayType)) {
               report(
                 node,
@@ -835,8 +839,7 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
               : [undefined, undefined, undefined];
 
         // `spread`, `item`, and `fn` are set together (all from the same
-        // tuple), so checking `spread` also guarantees the others are
-        // defined.
+        // tuple), so checking `spread` also guarantees the others are defined.
         if (spread === undefined) {
           return;
         }
@@ -855,27 +858,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 };
+};