eslint-plugin-ts-data-forge 0.8.2 → 0.8.3

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

@@ -4,6 +4,7 @@ import {
   type TSESTree,
 } from '@typescript-eslint/utils';
 import { Arr } from 'ts-data-forge';
+import { skipTypeWrappers, toArgumentText } from './ast-utils.mjs';
 import {
   buildImportFixes,
   getNamedImports,
@@ -68,12 +69,21 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
 
         const beginExpr = declaration.init;
 
-        // Check test: i < end
+        // 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 ||
-          node.test.operator !== '<' ||
-          node.test.left.type !== AST_NODE_TYPES.Identifier ||
-          node.test.left.name !== varName
+          node.test.operator !== '<'
+        ) {
+          return;
+        }
+
+        const testedVariable = skipTypeWrappers(node.test.left);
+
+        if (
+          testedVariable.type !== AST_NODE_TYPES.Identifier ||
+          testedVariable.name !== varName
         ) {
           return;
         }
@@ -105,7 +115,7 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
           node.update.left.name === varName
         ) {
           // i += step
-          const stepValue = node.update.right;
+          const stepValue = skipTypeWrappers(node.update.right);
 
           if (stepValue.type === AST_NODE_TYPES.Literal) {
             const stepNum = stepValue.value;
@@ -118,15 +128,15 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
             }
           } else {
             // Variable step like i += step
-            mut_step = sourceCode.getText(stepValue);
+            mut_step = toArgumentText(node.update.right, sourceCode);
           }
         } else {
           return;
         }
 
-        const beginText = sourceCode.getText(beginExpr);
+        const beginText = toArgumentText(beginExpr, sourceCode);
 
-        const endText = sourceCode.getText(endExpr);
+        const endText = toArgumentText(endExpr, sourceCode);
 
         mut_nodesToFix.push({
           node,

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

@@ -154,3 +154,78 @@ describe('prefer-range-for-loop', () => {
     ],
   });
 }, 20000);
+
+describe('prefer-range-for-loop through type wrappers', () => {
+  tester.run('prefer-range-for-loop', preferRangeForLoop, {
+    valid: [
+      {
+        name: 'a wrapped non-positive step',
+        code: dedent`
+          declare const n: number;
+          for (let i = 0; i < n; i += 0 as number) {
+            console.log(i);
+          }
+        `,
+      },
+    ],
+    invalid: [
+      {
+        name: 'the loop variable or the step wrapped',
+        code: dedent`
+          import { range } from 'ts-data-forge';
+          declare const n: number;
+          for (let i = 0; (i satisfies number) < n; ++i) {
+            console.log(i);
+          }
+          for (let j = 0; j! < n; j += 2 as number) {
+            console.log(j);
+          }
+        `,
+        output: dedent`
+          import { range } from 'ts-data-forge';
+          declare const n: number;
+          for (const i of range(0, n)) {
+            console.log(i);
+          }
+          for (const j of range(0, n, 2)) {
+            console.log(j);
+          }
+        `,
+        errors: [
+          { messageId: 'useRangeForLoop' },
+          { messageId: 'useRangeForLoop' },
+        ],
+      },
+    ],
+  });
+}, 20000);
+
+describe('prefer-range-for-loop with parenthesized operands', () => {
+  tester.run('prefer-range-for-loop', preferRangeForLoop, {
+    valid: [],
+    invalid: [
+      {
+        name: 'sequence bounds and step keep their 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)) {
+            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))) {
+            console.log(i);
+          }
+        `,
+        errors: [{ messageId: 'useRangeForLoop' }],
+      },
+    ],
+  });
+}, 20000);

package/src/rules/rules.mts

@@ -1,4 +1,4 @@
-import { type ESLintPlugin } from '../types.mjs';
+import type { ESLintPlugin } from '../types.mjs';
 import { noSideEffectImport } from './no-side-effect-import.mjs';
 import { noUnnecessaryTypeGuard } from './no-unnecessary-type-guard.mjs';
 import { preferArrIsArray } from './prefer-arr-is-array.mjs';

package/src/types.mts

@@ -1,5 +1,5 @@
-import { type TSESLint } from '@typescript-eslint/utils';
-import { type DeepReadonly } from 'ts-type-forge';
+import type { TSESLint } from '@typescript-eslint/utils';
+import type { DeepReadonly } from 'ts-type-forge';
 
 export type ESLintPlugin = DeepReadonly<TSESLint.FlatConfig.Plugin>;