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

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

@@ -1,5 +1,6 @@
 import {
   AST_NODE_TYPES,
+  ASTUtils,
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
@@ -42,12 +43,47 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
       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
+     * its step on every iteration, and `range` reads them once.
+     */
+    const isStableBound = (
+      // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+      wrapped: TSESTree.Node,
+    ): boolean => {
+      const node = skipTypeWrappers(wrapped);
+
+      if (node.type === AST_NODE_TYPES.Literal) {
+        return true;
+      }
+
+      if (node.type !== AST_NODE_TYPES.Identifier) {
+        return false;
+      }
+
+      const variable = ASTUtils.findVariable(
+        sourceCode.getScope(node),
+        node.name,
+      );
+
+      return (
+        variable !== null &&
+        variable.defs.length > 0 &&
+        variable.references.every(
+          (reference) => !reference.isWrite() || reference.init === true,
+        )
+      );
+    };
+
     const mut_nodesToFix: {
       node: TSESTree.ForStatement;
       varName: string;
       begin: string;
       end: string;
       step?: string;
+      fixable: boolean;
     }[] = [];
 
     return {
@@ -74,6 +110,11 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
 
         const beginExpr = declaration.init;
 
+        // `range` takes safe integers only.
+        if (isNonIntegerNumberLiteral(beginExpr)) {
+          return;
+        }
+
         // 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.
@@ -126,19 +167,35 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
             const stepNum = stepValue.value;
 
             // Only support positive integer steps
-            if (typeof stepNum === 'number' && stepNum > 0) {
+            if (
+              typeof stepNum === 'number' &&
+              Number.isSafeInteger(stepNum) &&
+              stepNum > 0
+            ) {
               mut_step = stepNum === 1 ? undefined : stepNum.toString();
             } else {
               return;
             }
+          } 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.
+            return;
           } else {
-            // Variable step like i += step
+            // Variable step like i += step. Its type is left to the type
+            // checker: a step that is not a non-zero safe integer makes the
+            // fixed `range(...)` call fail to type-check.
             mut_step = getArgumentText(sourceCode, node.update.right);
           }
         } else {
           return;
         }
 
+        // `const i` would not take an assignment anywhere but the update.
+        if (isAssignedOutsideUpdate(sourceCode, declaration, node.update)) {
+          return;
+        }
+
         const beginText = getArgumentText(sourceCode, beginExpr);
 
         const endText = getArgumentText(sourceCode, endExpr);
@@ -149,6 +206,10 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
           begin: beginText,
           end: endText,
           step: mut_step,
+          fixable:
+            isStableBound(endExpr) &&
+            (node.update.type !== AST_NODE_TYPES.AssignmentExpression ||
+              isStableBound(node.update.right)),
         });
       },
       'Program:exit': () => {
@@ -156,10 +217,11 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
 
         const hasRangeImport = namedImports.includes('range');
 
-        for (const [
-          index,
-          { node, varName, begin, end, step },
-        ] of mut_nodesToFix.entries()) {
+        const importCarrier = mut_nodesToFix.find(({ fixable }) => fixable);
+
+        for (const entry of mut_nodesToFix) {
+          const { node, varName, begin, end, step } = entry;
+
           context.report({
             node: node.init ?? node,
             messageId: 'useRangeForLoop',
@@ -168,25 +230,33 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
               begin,
               end,
             },
-            fix: (fixer) => {
-              const bodyText = sourceCode.getText(node.body);
+            fix: entry.fixable
+              ? (fixer) => {
+                  const bodyText = sourceCode.getText(node.body);
 
-              const rangeArgs =
-                step === undefined
-                  ? `${begin}, ${end}`
-                  : `${begin}, ${end}, ${step}`;
+                  const rangeArgs =
+                    step === undefined
+                      ? `${begin}, ${end}`
+                      : `${begin}, ${end}, ${step}`;
 
-              const replacement = `for (const ${varName} of range(${rangeArgs})) ${bodyText}`;
+                  const replacement = `for (const ${varName} of range(${rangeArgs})) ${bodyText}`;
 
-              const importFixes =
-                index === 0 && !hasRangeImport
-                  ? buildNamedImportFix(fixer, program, TS_DATA_FORGE_MODULE, [
-                      'range',
-                    ])
-                  : [];
+                  // 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)];
-            },
+                  return [...importFixes, fixer.replaceText(node, replacement)];
+                }
+              : undefined,
           });
         }
       },
@@ -194,3 +264,54 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
   },
   defaultOptions: [],
 } as const;
+
+const isNegatedLiteral = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: TSESTree.Node,
+): boolean =>
+  node.type === AST_NODE_TYPES.UnaryExpression &&
+  node.operator === '-' &&
+  skipTypeWrappers(node.argument).type === AST_NODE_TYPES.Literal;
+
+const isNonIntegerNumberLiteral = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  wrapped: TSESTree.Node,
+): boolean => {
+  const node = skipTypeWrappers(wrapped);
+
+  return (
+    node.type === AST_NODE_TYPES.Literal &&
+    typeof node.value === 'number' &&
+    !Number.isSafeInteger(node.value)
+  );
+};
+
+/**
+ * Whether the loop variable declared by `declaration` is written anywhere but
+ * its initializer and the loop's `update`.
+ */
+const isAssignedOutsideUpdate = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  sourceCode: TSESLint.SourceCode,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  declaration: TSESTree.VariableDeclarator,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  update: TSESTree.Expression,
+): boolean =>
+  sourceCode
+    .getDeclaredVariables(declaration)
+    .flatMap((variable) => variable.references)
+    .some(
+      (reference) =>
+        reference.isWrite() &&
+        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

@@ -205,22 +205,20 @@ describe('prefer-range-for-loop with parenthesized operands', () => {
     valid: [],
     invalid: [
       {
-        name: 'sequence bounds and step keep their parentheses',
+        name: 'a sequence begin keeps its parentheses',
         code: dedent`
           import { range } from 'ts-data-forge';
           declare const n: number;
-          declare const step: number;
           declare const log: () => void;
-          for (let i = (log(), 0); i < (log(), n); i += (log(), step)) {
+          for (let i = (log(), 0); i < n; ++i) {
             console.log(i);
           }
         `,
         output: dedent`
           import { range } from 'ts-data-forge';
           declare const n: number;
-          declare const step: number;
           declare const log: () => void;
-          for (const i of range((log(), 0), (log(), n), (log(), step))) {
+          for (const i of range((log(), 0), n)) {
             console.log(i);
           }
         `,
@@ -229,3 +227,127 @@ describe('prefer-range-for-loop with parenthesized operands', () => {
     ],
   });
 }, 20000);
+
+describe('prefer-range-for-loop where the rewrite would change behavior', () => {
+  tester.run('prefer-range-for-loop', preferRangeForLoop, {
+    valid: [
+      {
+        // `const i` could not be assigned.
+        name: 'the loop variable assigned in the body',
+        code: dedent`
+          declare const n: number;
+          declare const skip: boolean;
+          for (let i = 0; i < n; ++i) {
+            if (skip) i += 1;
+          }
+          for (let j = 0; j < n; ++j) {
+            j = n;
+          }
+        `,
+      },
+      {
+        // `range` takes safe integers only.
+        name: 'a step or a begin that is not an integer',
+        code: dedent`
+          declare const n: number;
+          for (let i = 0; i < n; i += 0.5) {
+            console.log(i);
+          }
+          for (let j = 0.5; j < n; ++j) {
+            console.log(j);
+          }
+        `,
+      },
+      {
+        // `i < n` with a negative step never ends; `range` yields nothing.
+        name: 'a negative literal step',
+        code: dedent`
+          declare const n: number;
+          for (let i = 0; i < n; i += -1) {
+            console.log(i);
+          }
+        `,
+      },
+    ],
+    invalid: [
+      {
+        // The loop tests its end on every iteration; `range` reads it once.
+        name: 'an end that is not a literal or a never-reassigned variable gets no fix',
+        code: dedent`
+          declare const xs: number[];
+          declare const getN: () => number;
+          let m = 3;
+          for (let i = 0; i < xs.length; ++i) {
+            xs.pop();
+          }
+          for (let j = 0; j < getN(); ++j) {
+            console.log(j);
+          }
+          for (let k = 0; k < m; ++k) {
+            m -= 1;
+          }
+        `,
+        output: null,
+        errors: [
+          { messageId: 'useRangeForLoop' },
+          { messageId: 'useRangeForLoop' },
+          { messageId: 'useRangeForLoop' },
+        ],
+      },
+      {
+        // The loop adds the step it reads on each iteration; `range` reads it
+        // once.
+        name: 'a variable step that is reassigned gets no fix',
+        code: dedent`
+          declare const n: number;
+          let step = 1;
+          for (let i = 0; i < n; i += step) {
+            step *= 2;
+          }
+        `,
+        output: null,
+        errors: [{ messageId: 'useRangeForLoop' }],
+      },
+      {
+        // 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;
+          declare const step: number;
+          for (let i = 0; i < n; i += step) {
+            console.log(i);
+          }
+        `,
+        output: dedent`
+          import { range } from 'ts-data-forge';
+          declare const n: number;
+          declare const step: number;
+          for (const i of range(0, n, step)) {
+            console.log(i);
+          }
+        `,
+        errors: [{ messageId: 'useRangeForLoop' }],
+      },
+      {
+        name: 'a parameter that is never reassigned is a fixed end',
+        code: dedent`
+          const f = (n: number): void => {
+            for (let i = 0; i < n; ++i) {
+              console.log(i);
+            }
+          };
+        `,
+        output: dedent`
+          import { range } from 'ts-data-forge';
+          const f = (n: number): void => {
+            for (const i of range(0, n)) {
+              console.log(i);
+            }
+          };
+        `,
+        errors: [{ messageId: 'useRangeForLoop' }],
+      },
+    ],
+  });
+}, 20000);

package/src/rules/rules.mts

@@ -1,6 +1,7 @@
 import type { ESLintPlugin } from '../types.mjs';
 import { noSideEffectImport } from './no-side-effect-import.mjs';
 import { noUnnecessaryTypeGuard } from './no-unnecessary-type-guard.mjs';
+import { preferArrGenerate } from './prefer-arr-generate.mjs';
 import { preferArrIsArray } from './prefer-arr-is-array.mjs';
 import { preferArrScan } from './prefer-arr-scan.mjs';
 import { preferArrSum } from './prefer-arr-sum.mjs';
@@ -21,6 +22,7 @@ export const tsDataForgeRules = {
   'prefer-canonical-array-slicing': preferCanonicalArraySlicing,
   'prefer-canonical-length-guard': preferCanonicalLengthGuard,
   'prefer-canonical-length-cast': preferCanonicalLengthCast,
+  'prefer-arr-generate': preferArrGenerate,
   'prefer-arr-is-array': preferArrIsArray,
   'prefer-arr-scan': preferArrScan,
   'prefer-arr-sum': preferArrSum,