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

package/src/rules/prefer-obj-over-entries-round-trip.mts

@@ -3,16 +3,10 @@ import {
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
-import {
-  buildNamedImportFix,
-  getArgumentText,
-  getImportDeclarations,
-  getImportedLocalName,
-  getNamedImports,
-} from 'eslint-rule-forge';
+import { getArgumentText } from 'eslint-rule-forge';
 import { Arr } from 'ts-data-forge';
 import type { ReadonlyRecord } from 'ts-type-forge';
-import { TS_DATA_FORGE_MODULE } from './constants.mjs';
+import { tsDataForgeValuesAt } from './import-binding.mjs';
 
 /* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 
@@ -92,13 +86,6 @@ export const preferObjOverEntriesRoundTrip: TSESLint.RuleModule<
   create: (context) => {
     const sourceCode = context.sourceCode;
 
-    const program = sourceCode.ast;
-
-    const tsDataForgeImports = getImportDeclarations(
-      program,
-      TS_DATA_FORGE_MODULE,
-    );
-
     const mut_roundTrips: {
       node: TSESTree.CallExpression;
       roundTrip: RoundTrip;
@@ -173,47 +160,42 @@ export const preferObjOverEntriesRoundTrip: TSESLint.RuleModule<
       },
 
       'Program:exit': () => {
-        const namedImports = getNamedImports(tsDataForgeImports);
-
-        const objName =
-          getImportedLocalName(tsDataForgeImports, 'Obj') ?? 'Obj';
+        const objAt = tsDataForgeValuesAt(sourceCode, ['Obj']).at;
 
-        const optionalName =
-          getImportedLocalName(tsDataForgeImports, 'Optional') ?? 'Optional';
+        const objOptionalAt = tsDataForgeValuesAt(sourceCode, [
+          'Obj',
+          'Optional',
+        ]).at;
 
-        const needsOptional = mut_roundTrips.some(
-          ({ roundTrip }) => roundTrip.body.kind === 'optional',
-        );
+        // Every fix brings the names it writes into scope itself, so that one
+        // applied alone (an editor's quick fix) is complete.
+        for (const { node, roundTrip } of mut_roundTrips) {
+          const binding = (
+            roundTrip.body.kind === 'optional' ? objOptionalAt : objAt
+          )(node);
 
-        const missingImports = (['Obj', 'Optional'] as const).filter(
-          (name) =>
-            (name !== 'Optional' || needsOptional) &&
-            !namedImports.includes(name),
-        );
+          const [objName, optionalName = 'Optional'] =
+            binding?.localNames ?? [];
 
-        // Note: the import is added by the first fix only, so that several
-        // fixes in one file do not each insert it at the same position.
-        for (const [index, { node, roundTrip }] of mut_roundTrips.entries()) {
           context.report({
             node,
             messageId: MESSAGE_ID_OF[roundTrip.method],
-            fix: (fixer) => {
-              const recordText = getArgumentText(sourceCode, roundTrip.record);
-
-              const replacement = `${objName}.${roundTrip.method}(${recordText}, ${buildParams(roundTrip)} => ${buildCallbackBody(roundTrip, optionalName)})`;
-
-              const importFixes =
-                index === 0 && missingImports.length > 0
-                  ? buildNamedImportFix(
-                      fixer,
-                      program,
-                      TS_DATA_FORGE_MODULE,
-                      missingImports,
-                    )
-                  : [];
-
-              return [...importFixes, fixer.replaceText(node, replacement)];
-            },
+            fix:
+              binding === undefined || objName === undefined
+                ? null
+                : (fixer) => {
+                    const recordText = getArgumentText(
+                      sourceCode,
+                      roundTrip.record,
+                    );
+
+                    const replacement = `${objName}.${roundTrip.method}(${recordText}, ${buildParams(roundTrip)} => ${buildCallbackBody(roundTrip, optionalName)})`;
+
+                    return [
+                      ...binding.edits(fixer),
+                      fixer.replaceText(node, replacement),
+                    ];
+                  },
           });
         }
       },
@@ -221,6 +203,127 @@ export const preferObjOverEntriesRoundTrip: TSESLint.RuleModule<
   },
 } as const;
 
+const isElidedOrIdentifier = (
+  element: TSESTree.DestructuringPattern | null | undefined,
+): element is TSESTree.Identifier | null | undefined =>
+  element === null ||
+  element === undefined ||
+  element.type === AST_NODE_TYPES.Identifier;
+
+/**
+ * Reads the `[key, value]` destructuring the entry callback binds. Anything
+ * beyond a plain binding — a default, a rest element, a nested pattern — is
+ * rejected, because the rewritten callback receives the value and the key
+ * directly rather than an entry tuple.
+ */
+const parseEntryPattern = (
+  pattern: TSESTree.ArrayPattern,
+): EntryParams | undefined => {
+  if (pattern.elements.length > 2) {
+    return undefined;
+  }
+
+  const [keyElement, valueElement] = pattern.elements;
+
+  return isElidedOrIdentifier(keyElement) && isElidedOrIdentifier(valueElement)
+    ? {
+        keyParam: keyElement ?? undefined,
+        valueParam: valueElement ?? undefined,
+      }
+    : undefined;
+};
+
+const isConstAssertion = (node: TSESTree.TSAsExpression): boolean =>
+  node.typeAnnotation.type === AST_NODE_TYPES.TSTypeReference &&
+  node.typeAnnotation.typeName.type === AST_NODE_TYPES.Identifier &&
+  node.typeAnnotation.typeName.name === 'const';
+
+/**
+ * Looks through the `as const` / `satisfies` an entry tuple usually carries.
+ * Any other assertion is left in place, so that a tuple asserted to a wider
+ * type than the callback returns is not reported: `Obj` would infer the
+ * narrower one and the rewrite would not type-check.
+ */
+const stripTypeWrappers = (node: TSESTree.Expression): TSESTree.Expression =>
+  node.type === AST_NODE_TYPES.TSSatisfiesExpression ||
+  (node.type === AST_NODE_TYPES.TSAsExpression && isConstAssertion(node))
+    ? stripTypeWrappers(node.expression)
+    : node;
+
+/**
+ * Matches `[k, value]` — an entry rebuilt under the very key it came from,
+ * which is the only shape `Obj.map` / `Obj.filterMap` can express. An entry
+ * built under a different key is left alone.
+ */
+const parseKeptEntry = (
+  node: TSESTree.Expression,
+  keyParam: TSESTree.Identifier | undefined,
+): KeptEntry | undefined => {
+  if (keyParam === undefined) {
+    return undefined;
+  }
+
+  const tuple = stripTypeWrappers(node);
+
+  if (
+    tuple.type !== AST_NODE_TYPES.ArrayExpression ||
+    !Arr.isFixedLengthTuple(2, tuple.elements)
+  ) {
+    return undefined;
+  }
+
+  const [key, value] = tuple.elements;
+
+  return key !== null &&
+    value !== null &&
+    key.type === AST_NODE_TYPES.Identifier &&
+    value.type !== AST_NODE_TYPES.SpreadElement &&
+    key.name === keyParam.name
+    ? { key, value }
+    : undefined;
+};
+
+/** Matches `[[k, value]]` — the `flatMap` branch that keeps an entry. */
+const parseSingletonEntry = (
+  node: TSESTree.Expression,
+  keyParam: TSESTree.Identifier | undefined,
+): KeptEntry | undefined => {
+  const array = stripTypeWrappers(node);
+
+  if (
+    array.type !== AST_NODE_TYPES.ArrayExpression ||
+    !Arr.isFixedLengthTuple(1, array.elements)
+  ) {
+    return undefined;
+  }
+
+  const [entry] = array.elements;
+
+  return entry === null || entry.type === AST_NODE_TYPES.SpreadElement
+    ? undefined
+    : parseKeptEntry(entry, keyParam);
+};
+
+/** Matches `[]` — the `flatMap` branch that drops an entry. */
+const isEmptyArray = (node: TSESTree.Expression): boolean => {
+  const array = stripTypeWrappers(node);
+
+  return (
+    array.type === AST_NODE_TYPES.ArrayExpression && array.elements.length === 0
+  );
+};
+
+const isObjectStaticCall = (
+  node: TSESTree.CallExpression,
+  name: 'entries' | 'fromEntries',
+): boolean =>
+  node.callee.type === AST_NODE_TYPES.MemberExpression &&
+  !node.callee.computed &&
+  node.callee.object.type === AST_NODE_TYPES.Identifier &&
+  node.callee.object.name === 'Object' &&
+  node.callee.property.type === AST_NODE_TYPES.Identifier &&
+  node.callee.property.name === name;
+
 /**
  * Matches `Object.fromEntries(Object.entries(record).map|filter|flatMap(cb))`
  * and reports which `Obj` function replaces it, or `undefined` when the call is
@@ -377,133 +480,12 @@ type EntryParams = Readonly<{
   valueParam: TSESTree.Identifier | undefined;
 }>;
 
-/**
- * Reads the `[key, value]` destructuring the entry callback binds. Anything
- * beyond a plain binding — a default, a rest element, a nested pattern — is
- * rejected, because the rewritten callback receives the value and the key
- * directly rather than an entry tuple.
- */
-const parseEntryPattern = (
-  pattern: TSESTree.ArrayPattern,
-): EntryParams | undefined => {
-  if (pattern.elements.length > 2) {
-    return undefined;
-  }
-
-  const [keyElement, valueElement] = pattern.elements;
-
-  return isElidedOrIdentifier(keyElement) && isElidedOrIdentifier(valueElement)
-    ? {
-        keyParam: keyElement ?? undefined,
-        valueParam: valueElement ?? undefined,
-      }
-    : undefined;
-};
-
-const isElidedOrIdentifier = (
-  element: TSESTree.DestructuringPattern | null | undefined,
-): element is TSESTree.Identifier | null | undefined =>
-  element === null ||
-  element === undefined ||
-  element.type === AST_NODE_TYPES.Identifier;
-
 type KeptEntry = Readonly<{
   /** The key identifier that only rebuilds the entry, dropped by the rewrite. */
   key: TSESTree.Identifier;
   value: TSESTree.Expression;
 }>;
 
-/**
- * Matches `[k, value]` — an entry rebuilt under the very key it came from,
- * which is the only shape `Obj.map` / `Obj.filterMap` can express. An entry
- * built under a different key is left alone.
- */
-const parseKeptEntry = (
-  node: TSESTree.Expression,
-  keyParam: TSESTree.Identifier | undefined,
-): KeptEntry | undefined => {
-  if (keyParam === undefined) {
-    return undefined;
-  }
-
-  const tuple = stripTypeWrappers(node);
-
-  if (
-    tuple.type !== AST_NODE_TYPES.ArrayExpression ||
-    !Arr.isFixedLengthTuple(2, tuple.elements)
-  ) {
-    return undefined;
-  }
-
-  const [key, value] = tuple.elements;
-
-  return key !== null &&
-    value !== null &&
-    key.type === AST_NODE_TYPES.Identifier &&
-    value.type !== AST_NODE_TYPES.SpreadElement &&
-    key.name === keyParam.name
-    ? { key, value }
-    : undefined;
-};
-
-/** Matches `[[k, value]]` — the `flatMap` branch that keeps an entry. */
-const parseSingletonEntry = (
-  node: TSESTree.Expression,
-  keyParam: TSESTree.Identifier | undefined,
-): KeptEntry | undefined => {
-  const array = stripTypeWrappers(node);
-
-  if (
-    array.type !== AST_NODE_TYPES.ArrayExpression ||
-    !Arr.isFixedLengthTuple(1, array.elements)
-  ) {
-    return undefined;
-  }
-
-  const [entry] = array.elements;
-
-  return entry === null || entry.type === AST_NODE_TYPES.SpreadElement
-    ? undefined
-    : parseKeptEntry(entry, keyParam);
-};
-
-/** Matches `[]` — the `flatMap` branch that drops an entry. */
-const isEmptyArray = (node: TSESTree.Expression): boolean => {
-  const array = stripTypeWrappers(node);
-
-  return (
-    array.type === AST_NODE_TYPES.ArrayExpression && array.elements.length === 0
-  );
-};
-
-/**
- * Looks through the `as const` / `satisfies` an entry tuple usually carries.
- * Any other assertion is left in place, so that a tuple asserted to a wider
- * type than the callback returns is not reported: `Obj` would infer the
- * narrower one and the rewrite would not type-check.
- */
-const stripTypeWrappers = (node: TSESTree.Expression): TSESTree.Expression =>
-  node.type === AST_NODE_TYPES.TSSatisfiesExpression ||
-  (node.type === AST_NODE_TYPES.TSAsExpression && isConstAssertion(node))
-    ? stripTypeWrappers(node.expression)
-    : node;
-
-const isConstAssertion = (node: TSESTree.TSAsExpression): boolean =>
-  node.typeAnnotation.type === AST_NODE_TYPES.TSTypeReference &&
-  node.typeAnnotation.typeName.type === AST_NODE_TYPES.Identifier &&
-  node.typeAnnotation.typeName.name === 'const';
-
-const isObjectStaticCall = (
-  node: TSESTree.CallExpression,
-  name: 'entries' | 'fromEntries',
-): boolean =>
-  node.callee.type === AST_NODE_TYPES.MemberExpression &&
-  !node.callee.computed &&
-  node.callee.object.type === AST_NODE_TYPES.Identifier &&
-  node.callee.object.name === 'Object' &&
-  node.callee.property.type === AST_NODE_TYPES.Identifier &&
-  node.callee.property.name === name;
-
 /**
  * `true` when the parameter is still referenced once the identifiers in
  * `dropped` — the ones that only rebuilt the entry key — are discounted.

package/src/rules/prefer-obj-over-entries-round-trip.test.mts

@@ -308,6 +308,38 @@ describe('prefer-obj-over-entries-round-trip', () => {
           `,
           errors: [{ messageId: 'useObjFilterMap' }],
         },
+        {
+          name: 'adds Obj and Optional to one existing import',
+          code: dedent`
+            import { asInt } from 'ts-data-forge';
+            const scores = { alice: 1, bob: 2 };
+            const scaled = Object.fromEntries(
+              Object.entries(scores).flatMap(([k, v]) =>
+                v > 1 ? [[k, v * 10]] : [],
+              ),
+            );
+          `,
+          output: dedent`
+            import { asInt, Obj, Optional } from 'ts-data-forge';
+            const scores = { alice: 1, bob: 2 };
+            const scaled = Obj.filterMap(scores, (v) => v > 1 ? Optional.some(v * 10) : Optional.none);
+          `,
+          errors: [{ messageId: 'useObjFilterMap' }],
+        },
+        {
+          name: 'no fix when an import type binds Optional',
+          code: dedent`
+            import type { Optional } from 'ts-data-forge';
+            const scores = { alice: 1, bob: 2 };
+            const scaled = Object.fromEntries(
+              Object.entries(scores).flatMap(([k, v]) =>
+                v > 1 ? [[k, v * 10]] : [],
+              ),
+            );
+          `,
+          output: null,
+          errors: [{ messageId: 'useObjFilterMap' }],
+        },
         {
           name: 'handles a flatMap whose branches are the other way round',
           code: dedent`
@@ -368,12 +400,22 @@ describe('prefer-obj-over-entries-round-trip', () => {
               Object.entries(scores).filter(([, v]) => v > 1),
             );
           `,
-          output: dedent`
-            import { Obj } from 'ts-data-forge';
-            const scores = { alice: 1, bob: 2 };
-            const doubled = Obj.map(scores, (v) => v * 2);
-            const passing = Obj.filter(scores, (v) => v > 1);
-          `,
+          output: [
+            dedent`
+              import { Obj } from 'ts-data-forge';
+              const scores = { alice: 1, bob: 2 };
+              const doubled = Obj.map(scores, (v) => v * 2);
+              const passing = Object.fromEntries(
+                Object.entries(scores).filter(([, v]) => v > 1),
+              );
+            `,
+            dedent`
+              import { Obj } from 'ts-data-forge';
+              const scores = { alice: 1, bob: 2 };
+              const doubled = Obj.map(scores, (v) => v * 2);
+              const passing = Obj.filter(scores, (v) => v > 1);
+            `,
+          ],
           errors: [{ messageId: 'useObjMap' }, { messageId: 'useObjFilter' }],
         },
         {

package/src/rules/prefer-pipe-map-nullable.mts

@@ -7,6 +7,7 @@ import {
   buildCalleeResolver,
   getArgumentText,
   getImportDeclarations,
+  hasCommentWithin,
   hasForeignBinding,
   isTypeWrapper,
   skipTypeWrappers,
@@ -33,8 +34,8 @@ type MessageIds = 'useMapNullable' | 'suggestMapNullable';
  * first infers `'a'` and the second `string`, and `(v) => [v, 1]` becomes
  * `number[]` instead of `readonly [number, 1]`. The fix is therefore applied
  * automatically only when the function's return type is not inferred, or is
- * inferred with nothing such a widening could change; otherwise, and whenever
- * a comment or a type wrapper around `mapNullable` would be dropped, it is
+ * inferred with nothing such a widening could change; otherwise, and whenever a
+ * comment or a type wrapper around `mapNullable` would be dropped, it is
  * offered as a suggestion.
  */
 export const preferPipeMapNullable: TSESLint.RuleModule<MessageIds, Options> = {
@@ -80,8 +81,8 @@ export const preferPipeMapNullable: TSESLint.RuleModule<MessageIds, Options> = {
     const esTreeNodeToTSNodeMap = services?.esTreeNodeToTSNodeMap;
 
     /**
-     * Whether `callee` calls the export `name` of the module `resolve`
-     * reads, rather than a local binding that shadows the import.
+     * Whether `callee` calls the export `name` of the module `resolve` reads,
+     * rather than a local binding that shadows the import.
      */
     const calls = (
       resolve: ReturnType<typeof buildCalleeResolver>,
@@ -169,9 +170,9 @@ export const preferPipeMapNullable: TSESLint.RuleModule<MessageIds, Options> = {
       }
 
       // The `B | undefined` that `mapNullable(fn)` returns, with `B` as the
-      // `const` type parameter inferred it. The function's own return type
-      // is no guide: for `(v) => ({ kind: 'n', v })` it is already widened
-      // to `{ kind: string; v: number }`, while `B` keeps `'n'`.
+      // `const` type parameter inferred it. The function's own return type is
+      // no guide: for `(v) => ({ kind: 'n', v })` it is already widened to
+      // `{ kind: string; v: number }`, while `B` keeps `'n'`.
       const signatures = checker
         .getTypeAtLocation(esTreeNodeToTSNodeMap.get(mapNullableCall))
         .getCallSignatures();
@@ -238,14 +239,11 @@ export const preferPipeMapNullable: TSESLint.RuleModule<MessageIds, Options> = {
           [mapFn.range[1], mapNullableCall.range[1]],
         ] as const;
 
-        const dropsComment = sourceCode
-          .getCommentsInside(mapNullableCall)
-          .some((comment) =>
-            droppedRanges.some(
-              ([start, end]) =>
-                start <= comment.range[0] && comment.range[1] <= end,
-            ),
-          );
+        const dropsComment = hasCommentWithin(
+          sourceCode,
+          mapNullableCall,
+          droppedRanges,
+        );
 
         const autofixable =
           !dropsComment &&
@@ -315,11 +313,11 @@ const MAX_DEPTH = 4;
 
 /**
  * Whether `type`, inferred for a `const` type parameter, has a part a plain
- * type parameter would infer differently: a literal (`'a'` against `string`)
- * or a tuple (`readonly [number, 1]` against `number[]`), at the top level or
+ * type parameter would infer differently: a literal (`'a'` against `string`) or
+ * a tuple (`readonly [number, 1]` against `number[]`), at the top level or
  * inside an array, a generic type's arguments or an object literal's
- * properties. Conservative: a declared literal type, which neither widens,
- * also counts.
+ * properties. Conservative: a declared literal type, which neither widens, also
+ * counts.
  */
 const hasConstInferredPart = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types

package/src/rules/prefer-range-for-loop.mts

@@ -4,15 +4,9 @@ import {
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
-import {
-  buildNamedImportFix,
-  getArgumentText,
-  getImportDeclarations,
-  getNamedImports,
-  skipTypeWrappers,
-} from 'eslint-rule-forge';
+import { getArgumentText, skipTypeWrappers } from 'eslint-rule-forge';
 import { Arr } from 'ts-data-forge';
-import { TS_DATA_FORGE_MODULE } from './constants.mjs';
+import { tsDataForgeValueAt } from './import-binding.mjs';
 
 type Options = readonly [];
 
@@ -37,17 +31,10 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
   create: (context) => {
     const sourceCode = context.sourceCode;
 
-    const program = sourceCode.ast;
-
-    const tsDataForgeImports = getImportDeclarations(
-      program,
-      TS_DATA_FORGE_MODULE,
-    );
-
     /**
      * Whether `node` is the same value on every iteration: a literal, or a
-     * variable that is never reassigned anywhere (not only in the loop, since
-     * a function the loop calls could reassign it). The loop reads its end and
+     * variable that is never reassigned anywhere (not only in the loop, since a
+     * function the loop calls could reassign it). The loop reads its end and
      * its step on every iteration, and `range` reads them once.
      */
     const isStableBound = (
@@ -116,8 +103,8 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
           return;
         }
 
-        // Check test: i < end. The loop variable and the step are read
-        // through type wrappers: `(i satisfies number) < n` tests `i`, and
+        // Check test: i < end. The loop variable and the step are read through
+        // type wrappers: `(i satisfies number) < n` tests `i`, and
         // `i += 0 as number` still steps by 0.
         if (
           node.test?.type !== AST_NODE_TYPES.BinaryExpression ||
@@ -179,8 +166,8 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
             }
           } else if (isNegatedLiteral(stepValue)) {
             // `i += -1` under `i < end` never gets there, and `range` with a
-            // negative step yields nothing: no fix that type-checks would
-            // keep that.
+            // negative step yields nothing: no fix that type-checks would keep
+            // that.
             return;
           } else {
             // Variable step like i += step. Its type is left to the type
@@ -214,15 +201,13 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
         });
       },
       'Program:exit': () => {
-        const namedImports = getNamedImports(tsDataForgeImports);
-
-        const hasRangeImport = namedImports.includes('range');
-
-        const importCarrier = mut_nodesToFix.find(({ fixable }) => fixable);
+        const rangeAt = tsDataForgeValueAt(sourceCode, 'range');
 
         for (const entry of mut_nodesToFix) {
           const { node, varName, begin, end, step } = entry;
 
+          const range = entry.fixable ? rangeAt(node) : undefined;
+
           context.report({
             node: node.init ?? node,
             messageId: 'useRangeForLoop',
@@ -231,33 +216,24 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
               begin,
               end,
             },
-            fix: entry.fixable
-              ? (fixer) => {
-                  const bodyText = sourceCode.getText(node.body);
-
-                  const rangeArgs =
-                    step === undefined
-                      ? `${begin}, ${end}`
-                      : `${begin}, ${end}, ${step}`;
-
-                  const replacement = `for (const ${varName} of range(${rangeArgs})) ${bodyText}`;
-
-                  // The import fix lives on the first fixable report:
-                  // `insertTextBefore(program, …)` produces overlapping ranges
-                  // otherwise.
-                  const importFixes =
-                    entry === importCarrier && !hasRangeImport
-                      ? buildNamedImportFix(
-                          fixer,
-                          program,
-                          TS_DATA_FORGE_MODULE,
-                          ['range'],
-                        )
-                      : [];
-
-                  return [...importFixes, fixer.replaceText(node, replacement)];
-                }
-              : undefined,
+            fix:
+              range === undefined
+                ? undefined
+                : (fixer) => {
+                    const bodyText = sourceCode.getText(node.body);
+
+                    const rangeArgs =
+                      step === undefined
+                        ? `${begin}, ${end}`
+                        : `${begin}, ${end}, ${step}`;
+
+                    const replacement = `for (const ${varName} of ${range.localName}(${rangeArgs})) ${bodyText}`;
+
+                    return [
+                      ...range.edits(fixer),
+                      fixer.replaceText(node, replacement),
+                    ];
+                  },
           });
         }
       },
@@ -286,6 +262,14 @@ const isNonIntegerNumberLiteral = (
   );
 };
 
+const isWithin = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: TSESTree.Node,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  container: TSESTree.Node,
+): boolean =>
+  container.range[0] <= node.range[0] && node.range[1] <= container.range[1];
+
 /**
  * Whether the loop variable declared by `declaration` is written anywhere but
  * its initializer and the loop's `update`.
@@ -307,11 +291,3 @@ const isAssignedOutsideUpdate = (
         reference.init !== true &&
         !isWithin(reference.identifier, update),
     );
-
-const isWithin = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  node: TSESTree.Node,
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  container: TSESTree.Node,
-): boolean =>
-  container.range[0] <= node.range[0] && node.range[1] <= container.range[1];

package/src/rules/prefer-range-for-loop.test.mts

@@ -309,8 +309,8 @@ describe('prefer-range-for-loop where the rewrite would change behavior', () =>
         errors: [{ messageId: 'useRangeForLoop' }],
       },
       {
-        // The type checker judges it: a `number` step makes the fixed call
-        // fail to type-check.
+        // The type checker judges it: a `number` step makes the fixed call fail
+        // to type-check.
         name: 'a variable step is fixed without asking its type',
         code: dedent`
           declare const n: number;