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

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';
@@ -15,12 +16,14 @@ import { preferIsRecordAndHasKey } from './prefer-is-record-and-has-key.mjs';
 import { preferNumSafeParseFloat } from './prefer-num-safe-parse-float.mjs';
 import { preferNumSafeParseInt } from './prefer-num-safe-parse-int.mjs';
 import { preferObjOverEntriesRoundTrip } from './prefer-obj-over-entries-round-trip.mjs';
+import { preferPipeMapNullable } from './prefer-pipe-map-nullable.mjs';
 import { preferRangeForLoop } from './prefer-range-for-loop.mjs';
 
 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,
@@ -35,4 +38,5 @@ export const tsDataForgeRules = {
   'no-unnecessary-type-guard': noUnnecessaryTypeGuard,
   'prefer-comparison-over-nullish-guard': preferComparisonOverNullishGuard,
   'prefer-obj-over-entries-round-trip': preferObjOverEntriesRoundTrip,
+  'prefer-pipe-map-nullable': preferPipeMapNullable,
 } as const satisfies ESLintPlugin['rules'];