eslint-plugin-ts-data-forge 0.8.5 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-ts-data-forge",
-  "version": "0.8.5",
+  "version": "0.9.0",
   "private": false,
   "description": "ESLint rules that steer code toward ts-data-forge idioms.",
   "keywords": [
@@ -35,16 +35,17 @@
   ],
   "dependencies": {
     "@typescript-eslint/utils": "^8.71.1",
-    "ts-data-forge": "14.7.1",
+    "eslint-rule-forge": "^0.2.0",
+    "ts-data-forge": "14.8.0",
     "ts-type-forge": "~9.2.2"
   },
   "devDependencies": {
     "@typescript-eslint/parser": "8.71.1",
     "@typescript-eslint/rule-tester": "8.71.1",
     "dedent": "1.7.2",
-    "eslint-config-typed": "5.17.3",
-    "eslint-plugin-ts-fortress": "1.3.2",
-    "eslint-plugin-ts-type-forge": "0.8.7",
+    "eslint-config-typed": "5.19.0",
+    "eslint-plugin-ts-fortress": "1.3.4",
+    "eslint-plugin-ts-type-forge": "0.8.9",
     "prettier": "3.9.9",
     "prettier-plugin-organize-imports": "4.3.0",
     "prettier-plugin-packagejson": "3.0.2",
@@ -66,15 +67,15 @@
     "build": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/build.mts",
     "check:dist:branded-number-types": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/check-branded-number-types.mts",
     "check:ext": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/check-ext.mts",
-    "check:lint": "oxlint . && eslint .",
-    "check:test": "pnpm run z:vitest run",
-    "check:test:cov": "pnpm run z:vitest run --coverage",
-    "check:types": "node ../../node_modules/typescript-native/bin/tsc --noEmit",
+    "check:lint": "node ../../tools/scripts/cmd/assert-deps-built.mts && oxlint . && eslint .",
+    "check:test": "node ../../tools/scripts/cmd/assert-deps-built.mts && pnpm run z:vitest run",
+    "check:test:cov": "node ../../tools/scripts/cmd/assert-deps-built.mts && pnpm run z:vitest run --coverage",
+    "check:types": "node ../../tools/scripts/cmd/assert-deps-built.mts && node ../../node_modules/typescript-native/bin/tsc --noEmit",
     "doc": "pnpm run gen:readme",
     "fix:fmt": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../../libs/ts-repo-utils/src/cmd/format-uncommitted.mts --cwd .",
     "fix:fmt:diff": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ../../libs/ts-repo-utils/src/cmd/format-diff-from.mts origin/main --cwd .",
     "fix:fmt:full": "pnpm run z:prettier .",
-    "fix:lint": "oxlint . --fix && eslint . --fix",
+    "fix:lint": "node ../../tools/scripts/cmd/assert-deps-built.mts && oxlint . --fix && eslint . --fix",
     "fmt": "pnpm run fix:fmt",
     "gen": "run-s gen:rule-types gen:readme",
     "gen:readme": "tsx --tsconfig ../../tools/configs/tsconfig.tsx.json ./scripts/cmd/embed-examples.mts",

package/src/plugin.mts

@@ -13,6 +13,7 @@ const recommendedRules = {
   'ts-data-forge/prefer-canonical-array-slicing': 'error',
   'ts-data-forge/prefer-canonical-length-cast': 'error',
   'ts-data-forge/prefer-canonical-length-guard': 'error',
+  'ts-data-forge/prefer-arr-generate': 'error',
   'ts-data-forge/prefer-arr-is-array': 'error',
   'ts-data-forge/prefer-arr-scan': 'error',
   'ts-data-forge/prefer-arr-sum': 'error',

package/src/rule-types.mts

@@ -72,6 +72,21 @@ namespace PreferCanonicalLengthCast {
   export type RuleEntry = Linter.StringSeverity;
 }
 
+/**
+ * @description Replace the filter-and-map idiom `xs.flatMap((x) => (cond ? [f(x)] : []))` with a loop in `Arr.generate` from ts-data-forge.
+ *
+ *  ```md
+ *  | key        | value      |
+ *  | :--------- | :--------- |
+ *  | type       | suggestion |
+ *  | deprecated | false      |
+ *  | fixable    | code       |
+ *  ```
+ */
+namespace PreferArrGenerate {
+  export type RuleEntry = Linter.StringSeverity;
+}
+
 /**
  * @description Replace `Array.isArray` with `Arr.isArray` from ts-data-forge.
  *
@@ -148,7 +163,7 @@ namespace PreferAsInt {
 }
 
 /**
- * @description Replace `typeof u === "object" && u !== null` with `isNonNullObject(u)` from ts-data-forge.
+ * @description Replace `typeof u === "object" && u !== null`, in either order and anywhere in an `&&` chain, with `isNonNullObject(u)` from ts-data-forge.
  *
  *  ```md
  *  | key        | value      |
@@ -314,6 +329,7 @@ export type EslintTsDataForgeRules = Readonly<{
   'ts-data-forge/prefer-canonical-array-slicing': PreferCanonicalArraySlicing.RuleEntry;
   'ts-data-forge/prefer-canonical-length-guard': PreferCanonicalLengthGuard.RuleEntry;
   'ts-data-forge/prefer-canonical-length-cast': PreferCanonicalLengthCast.RuleEntry;
+  'ts-data-forge/prefer-arr-generate': PreferArrGenerate.RuleEntry;
   'ts-data-forge/prefer-arr-is-array': PreferArrIsArray.RuleEntry;
   'ts-data-forge/prefer-arr-scan': PreferArrScan.RuleEntry;
   'ts-data-forge/prefer-arr-sum': PreferArrSum.RuleEntry;

package/src/rules/ast-utils.mts

@@ -1,82 +1,22 @@
 import {
   AST_NODE_TYPES,
+  ASTUtils,
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
+import {
+  isTypeWrapper,
+  skipTypeWrappers,
+  typeWrapperLayers,
+} from 'eslint-rule-forge';
 import type { DeepReadonly } from 'ts-type-forge';
-
-/**
- * `node` with every `as`, `satisfies`, `!` and `<T>` around it taken off: the
- * expression whose value it is. A wrapper changes no value, so a rule judges
- * syntax on this — `xs.length > (0 as number)` compares with the literal `0`
- * — and writes its fix from the original node so the wrapper is kept. A type
- * is another matter: see {@link typeWrapperLayers}. See
- * `docs/writing-lint-rules.md` at the repository root. A copy of
- * `eslint-config-typed`'s `type-wrapper-utils.mts`, since this package is
- * published on its own.
- */
-export const skipTypeWrappers = <N extends TSESTree.Node>(
-  node: N,
-): N | TSESTree.Expression =>
-  isTypeWrapper(node) ? skipTypeWrappers(node.expression) : node;
-
-/**
- * `node` and every expression inside the type wrappers around it, outermost
- * first: `x as A as B` gives `x as A as B`, `x as A` and `x`.
- *
- * A conclusion a rule draws from a type — that a guard always holds, that a
- * value is an array, that `?? 0` is dead — has to hold for the type of every
- * layer. An assertion therefore only ever makes a rule more cautious: one
- * that widens (`x as string | null`) is the author saying the value may be
- * `null`, and is respected; one that narrows (`x!`, `v as string` on an
- * `unknown`) is a claim the checker cannot verify, and the value's own type
- * still decides.
- */
-export const typeWrapperLayers = <N extends TSESTree.Node>(
-  node: N,
-): readonly (N | TSESTree.Expression)[] =>
-  isTypeWrapper(node)
-    ? ([node, ...typeWrapperLayers(node.expression)] as const)
-    : ([node] as const);
-
-export const isTypeWrapper = (
-  node: DeepReadonly<TSESTree.Node>,
-): node is TypeWrapper => TYPE_WRAPPERS.has(node.type);
-
-export type TypeWrapper =
-  | TSESTree.TSAsExpression
-  | TSESTree.TSNonNullExpression
-  | TSESTree.TSSatisfiesExpression
-  | TSESTree.TSTypeAssertion;
-
-const TYPE_WRAPPERS: ReadonlySet<AST_NODE_TYPES> = new Set([
-  AST_NODE_TYPES.TSAsExpression,
-  AST_NODE_TYPES.TSNonNullExpression,
-  AST_NODE_TYPES.TSSatisfiesExpression,
-  AST_NODE_TYPES.TSTypeAssertion,
-]);
+import type * as ts from 'typescript';
 
 const isIntegerLiteral = (node: DeepReadonly<TSESTree.Expression>): boolean =>
   node.type === AST_NODE_TYPES.Literal &&
   typeof node.value === 'number' &&
   Number.isInteger(node.value);
 
-/**
- * The source text of `node` for an argument position. A node's text never
- * includes the parentheses the source wrote around it, so a comma (sequence)
- * expression gets them back rather than spilling into the next argument.
- */
-export const toArgumentText = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  node: TSESTree.Node,
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  sourceCode: TSESLint.SourceCode,
-): string => {
-  const text = sourceCode.getText(node);
-
-  return node.type === AST_NODE_TYPES.SequenceExpression ? `(${text})` : text;
-};
-
 /**
  * Whether `node` is an array or a tuple at every layer of type wrappers (see
  * {@link typeWrapperLayers}): a cast does not make a string an array, and the
@@ -135,9 +75,9 @@ export const isIntegerLiteralOrConstant = (
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   const scope = sourceCode.getScope(node as TSESTree.Node);
 
-  const variable = findVariable(scope, node.name);
+  const variable = ASTUtils.findVariable(scope, node.name);
 
-  if (variable === undefined) {
+  if (variable === null) {
     return false;
   }
 
@@ -205,7 +145,8 @@ type LengthComparison = Readonly<{
  * Parses a `<array>.length <op> <bound>` comparison (in either operand order)
  * into its array expression, integer-literal/`const` `bound`, and whether it is
  * a lower (`min`) or upper (`max`) length bound. Returns `undefined` for
- * anything else. The length and the bound are read through type wrappers; the
+ * anything else. The comparison, the length and the bound are read through
+ * type wrappers; the
  * `bound` returned is the literal or constant underneath, since a wrapper such
  * as `as number` would only widen the length a guard narrows to.
  *
@@ -214,10 +155,12 @@ type LengthComparison = Readonly<{
  */
 export const parseLengthComparison = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  node: TSESTree.Expression,
+  wrapped: TSESTree.Expression,
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   sourceCode: TSESLint.SourceCode,
 ): LengthComparison | undefined => {
+  const node = skipTypeWrappers(wrapped);
+
   if (
     node.type !== AST_NODE_TYPES.BinaryExpression ||
     (node.operator !== '>=' && node.operator !== '<=')
@@ -262,6 +205,8 @@ export const parseLengthComparison = (
  * together form the `Arr.isBoundedLengthArray` pattern handled by
  * `prefer-arr-is-bounded-length-array`. The single-bound rules skip such
  * operands so the bounded rule rewrites the whole `&&` instead of the parts.
+ * A comparison wrapped as a whole (`(xs.length >= 1 satisfies boolean) && …`)
+ * is still the operand.
  */
 export const isPartOfBoundedLengthCheck = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
@@ -269,10 +214,12 @@ export const isPartOfBoundedLengthCheck = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   sourceCode: TSESLint.SourceCode,
 ): boolean => {
-  const { parent } = node;
+  const operand = outermostTypeWrapper(node);
+
+  const { parent } = operand;
 
   if (
-    parent.type !== AST_NODE_TYPES.LogicalExpression ||
+    parent?.type !== AST_NODE_TYPES.LogicalExpression ||
     parent.operator !== '&&'
   ) {
     return false;
@@ -284,7 +231,7 @@ export const isPartOfBoundedLengthCheck = (
     return false;
   }
 
-  const sibling = parent.left === node ? parent.right : parent.left;
+  const sibling = parent.left === operand ? parent.right : parent.left;
 
   const other = parseLengthComparison(sibling, sourceCode);
 
@@ -298,6 +245,15 @@ export const isPartOfBoundedLengthCheck = (
   );
 };
 
+/** The outermost of the type wrappers around `node`, or `node` itself. */
+const outermostTypeWrapper = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: TSESTree.Node,
+): TSESTree.Node =>
+  node.parent !== undefined && isTypeWrapper(node.parent)
+    ? outermostTypeWrapper(node.parent)
+    : node;
+
 type VariableDefinition = Readonly<{
   type: string;
   parent: TSESTree.VariableDeclaration;
@@ -310,15 +266,52 @@ const isVariableDefinition = (
 ): def is TSESLint.Scope.Definition & VariableDefinition =>
   (def.type as string) === 'Variable';
 
-const findVariable = (
+/**
+ * Whether `node`, read through its type wrappers, is the identifier `name`:
+ * `Number`, `(Number as NumberConstructor)` and `Number!` are the same object.
+ */
+export const isIdentifierNamed = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  scope: TSESLint.Scope.Scope,
+  node: TSESTree.Node,
   name: string,
-): TSESLint.Scope.Variable | undefined => {
-  const variable = scope.set.get(name);
+): boolean => {
+  const unwrapped = skipTypeWrappers(node);
 
   return (
-    variable ??
-    (scope.upper === null ? undefined : findVariable(scope.upper, name))
+    unwrapped.type === AST_NODE_TYPES.Identifier && unwrapped.name === name
   );
 };
+
+/**
+ * Whether `holds` is true of the type of every layer of type wrappers around
+ * `node` (see {@link typeWrapperLayers}), outermost to innermost; `false`
+ * without type information. A widening cast (`s as string | number`) is the
+ * author saying the value may be more than it is, and is respected; a
+ * narrowing one (`s!`, `v as unknown as string`) cannot vouch for what the
+ * value's own type does not, and the fix, which keeps the wrapper, has to
+ * type-check at every layer too.
+ */
+export const typeHoldsAtEveryLayer = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  sourceCode: TSESLint.SourceCode,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: TSESTree.Node,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  holds: (type: ts.Type, typeChecker: ts.TypeChecker) => boolean,
+): boolean => {
+  const services = sourceCode.parserServices;
+
+  const checker = services?.program?.getTypeChecker();
+
+  if (checker === undefined) {
+    return false;
+  }
+
+  return typeWrapperLayers(node).every((layer) => {
+    const tsNode = services?.esTreeNodeToTSNodeMap?.get(layer);
+
+    return (
+      tsNode !== undefined && holds(checker.getTypeAtLocation(tsNode), checker)
+    );
+  });
+};

package/src/rules/constants.mts

@@ -1 +1,13 @@
+import * as ts from 'typescript';
+
 export const TS_DATA_FORGE_MODULE = 'ts-data-forge';
+
+/** The type flags of every primitive type but `void`. */
+export const primitiveTypeFlags =
+  ts.TypeFlags.StringLike |
+  ts.TypeFlags.NumberLike |
+  ts.TypeFlags.BigIntLike |
+  ts.TypeFlags.BooleanLike |
+  ts.TypeFlags.ESSymbolLike |
+  ts.TypeFlags.Null |
+  ts.TypeFlags.Undefined;

package/src/rules/mutable-result.mts

@@ -0,0 +1,204 @@
+import {
+  AST_NODE_TYPES,
+  type TSESLint,
+  type TSESTree,
+} from '@typescript-eslint/utils';
+import * as ts from 'typescript';
+import { primitiveTypeFlags } from './constants.mjs';
+
+/**
+ * Whether the code around `node` visibly relies on the result being a mutable
+ * array, so that swapping in the readonly array `Arr.uniq` or `Arr.generate`
+ * returns would not compile. Looks at `node` itself and, when it initializes a variable without a
+ * type annotation, at every read of that variable.
+ */
+export const needsMutableResult = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  sourceCode: TSESLint.SourceCode,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  checker: ts.TypeChecker,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  getTsNode: (esNode: TSESTree.Node) => ts.Node | undefined,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: TSESTree.Node,
+): boolean => {
+  const outer = outermostTypePreservingWrapper(node);
+
+  if (isUsedAsMutable(checker, getTsNode, outer)) {
+    return true;
+  }
+
+  const parent = outer.parent;
+
+  if (
+    parent?.type !== AST_NODE_TYPES.VariableDeclarator ||
+    parent.init !== outer ||
+    parent.id.type !== AST_NODE_TYPES.Identifier ||
+    parent.id.typeAnnotation !== undefined
+  ) {
+    return false;
+  }
+
+  const [variable] = sourceCode.getDeclaredVariables(parent);
+
+  return (
+    variable?.references.some(
+      (reference) =>
+        reference.init !== true &&
+        isUsedAsMutable(
+          checker,
+          getTsNode,
+          outermostTypePreservingWrapper(reference.identifier),
+        ),
+    ) ?? false
+  );
+};
+
+/**
+ * `node`, or the outermost `!` / `satisfies` around it. Neither changes the
+ * type the value is used at, so `Array.from(new Set(xs))!.push(4)` and
+ * `ys!.push(4)` still need a mutable array. An `as` does change it, and a
+ * readonly array may be cast to a mutable one, so the walk stops there.
+ */
+const outermostTypePreservingWrapper = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: TSESTree.Node,
+): TSESTree.Node => {
+  const { parent } = node;
+
+  return parent !== undefined &&
+    (parent.type === AST_NODE_TYPES.TSNonNullExpression ||
+      parent.type === AST_NODE_TYPES.TSSatisfiesExpression) &&
+    parent.expression === node
+    ? outermostTypePreservingWrapper(parent)
+    : node;
+};
+
+const isUsedAsMutable = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  checker: ts.TypeChecker,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  getTsNode: (esNode: TSESTree.Node) => ts.Node | undefined,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: TSESTree.Node,
+): boolean => {
+  const parent = node.parent;
+
+  if (
+    parent?.type === AST_NODE_TYPES.MemberExpression &&
+    parent.object === node
+  ) {
+    // xs.push(...), xs.sort(), ...
+    if (
+      !parent.computed &&
+      parent.property.type === AST_NODE_TYPES.Identifier &&
+      mutatingMethods.has(parent.property.name)
+    ) {
+      return true;
+    }
+
+    // xs[0] = ..., xs.length = ..., xs[0]++, delete xs[0]
+    const grandParent = parent.parent;
+
+    return (
+      (grandParent.type === AST_NODE_TYPES.AssignmentExpression &&
+        grandParent.left === parent) ||
+      grandParent.type === AST_NODE_TYPES.UpdateExpression ||
+      (grandParent.type === AST_NODE_TYPES.UnaryExpression &&
+        grandParent.operator === 'delete')
+    );
+  }
+
+  // Passed to a parameter, assigned to a variable, or returned from a function
+  // whose declared type is a mutable array.
+  const tsNode = getTsNode(node);
+
+  if (tsNode === undefined) {
+    return false;
+  }
+
+  if (!ts.isExpression(tsNode)) {
+    return false;
+  }
+
+  const expectedType =
+    getDeclaredParameterType(checker, tsNode) ??
+    checker.getContextualType(tsNode);
+
+  return (
+    expectedType !== undefined && isMutableArrayOnly(checker, expectedType)
+  );
+};
+
+/**
+ * The declared type of the parameter `argument` is passed to. The contextual
+ * type of an argument to a generic function is instantiated from that very
+ * argument — `Arr.toSorted(Array.from(set), cmp)` has `Ar` inferred as
+ * `string[]` — so it would read as "a mutable array is required" for any
+ * generic parameter. The declared type (`Ar extends readonly unknown[]`) is
+ * what the rewritten argument actually has to satisfy.
+ */
+const getDeclaredParameterType = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  checker: ts.TypeChecker,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  argument: ts.Expression,
+): ts.Type | undefined => {
+  const call = argument.parent;
+
+  if (!ts.isCallExpression(call) && !ts.isNewExpression(call)) {
+    return undefined;
+  }
+
+  const index = call.arguments?.indexOf(argument) ?? -1;
+
+  if (index === -1) {
+    return undefined;
+  }
+
+  const declaration = checker.getResolvedSignature(call)?.getDeclaration();
+
+  const parameter = declaration?.parameters[index];
+
+  // A rest parameter's declared type is the array of arguments, not the type of
+  // one; the contextual type is the better answer there.
+  return parameter === undefined || parameter.dotDotDotToken !== undefined
+    ? undefined
+    : checker.getTypeAtLocation(parameter);
+};
+
+/**
+ * Whether a readonly array cannot be assigned to `type`: it is a mutable array,
+ * or a union of mutable arrays and primitives. (A tuple accepted no array to
+ * begin with, so it does not matter here.)
+ */
+const isMutableArrayOnly = (
+  // 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 members = type.isUnion() ? type.types : ([type] as const);
+
+  return (
+    members.every(
+      (t) =>
+        // `null`, `undefined` and other primitives accept no array at all.
+        (t.flags & primitiveTypeFlags) !== 0 ||
+        (checker.isArrayType(t) && t.getSymbol()?.getName() === 'Array'),
+    ) && members.some((t) => (t.flags & primitiveTypeFlags) === 0)
+  );
+};
+
+/** Methods that `ReadonlyArray` lacks and that mutate the receiver. */
+const mutatingMethods: ReadonlySet<string> = new Set([
+  'copyWithin',
+  'fill',
+  'pop',
+  'push',
+  'reverse',
+  'shift',
+  'sort',
+  'splice',
+  'unshift',
+]);

package/src/rules/no-unnecessary-type-guard.mts

@@ -4,15 +4,16 @@ import {
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
-import type { DeepReadonly, ReadonlyRecord } from 'ts-type-forge';
-import * as ts from 'typescript';
-import { typeWrapperLayers } from './ast-utils.mjs';
 import {
   buildCalleeResolver,
-  buildImportFixes,
+  buildNamedImportFix,
+  getImportDeclarations,
   getImportedLocalName,
-  getTsDataForgeImport,
-} from './import-utils.mjs';
+  typeWrapperLayers,
+} from 'eslint-rule-forge';
+import type { DeepReadonly, ReadonlyRecord } from 'ts-type-forge';
+import * as ts from 'typescript';
+import { TS_DATA_FORGE_MODULE } from './constants.mjs';
 
 type Options = readonly [
   Readonly<{
@@ -169,9 +170,12 @@ export const noUnnecessaryTypeGuard: TSESLint.RuleModule<MessageIds, Options> =
 
       const ignored = new Set(options?.ignore);
 
-      const tsDataForgeImport = getTsDataForgeImport(program);
+      const tsDataForgeImports = getImportDeclarations(
+        program,
+        TS_DATA_FORGE_MODULE,
+      );
 
-      const resolveGuard = buildCalleeResolver(tsDataForgeImport);
+      const resolveGuard = buildCalleeResolver(tsDataForgeImports);
 
       const buildReplaceFix =
         (
@@ -191,7 +195,7 @@ export const noUnnecessaryTypeGuard: TSESLint.RuleModule<MessageIds, Options> =
           // alias), rename to its in-scope local name. Otherwise add a new
           // import and rename to the canonical name.
           const localName = getImportedLocalName(
-            tsDataForgeImport,
+            tsDataForgeImports,
             replacement,
           );
 
@@ -200,7 +204,7 @@ export const noUnnecessaryTypeGuard: TSESLint.RuleModule<MessageIds, Options> =
           }
 
           return [
-            ...buildImportFixes(fixer, program, tsDataForgeImport, [
+            ...buildNamedImportFix(fixer, program, TS_DATA_FORGE_MODULE, [
               replacement,
             ]),
             fixer.replaceText(propertyNode, replacement),