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

package/src/rules/prefer-num-safe-parse-float.mts

@@ -4,6 +4,7 @@ import {
   type TSESTree,
 } from '@typescript-eslint/utils';
 import * as ts from 'typescript';
+import { toArgumentText, typeWrapperLayers } from './ast-utils.mjs';
 import {
   buildImportFixes,
   getNamedImports,
@@ -36,7 +37,9 @@ const isStringType = (type: ts.Type): boolean => {
  * `Result.unwrapOkOr(Num.safeParseFloat(x), Number.NaN)` (ts-data-forge).
  *
  * `Number(x)` is only flagged when x is purely a string type to avoid false
- * positives for `Number(someBoolean)` or `Number(someNumber)` uses.
+ * positives for `Number(someBoolean)` or `Number(someNumber)` uses. The type is
+ * asked of the value under any `as` / `!` / `satisfies` too, so a cast does not
+ * vouch for a string that is not one.
  */
 export const preferNumSafeParseFloat: TSESLint.RuleModule<MessageIds, Options> =
   {
@@ -91,32 +94,53 @@ export const preferNumSafeParseFloat: TSESLint.RuleModule<MessageIds, Options> =
             callee.type === AST_NODE_TYPES.Identifier &&
             callee.name === 'Number';
 
-          if (!isGlobalParseFloat && !isNumberParseFloat && !isNumberCall)
+          if (!isGlobalParseFloat && !isNumberParseFloat && !isNumberCall) {
             return;
+          }
 
           const args = node.arguments;
 
           const firstArg = args[0];
 
-          if (firstArg === undefined) return;
+          if (firstArg === undefined) {
+            return;
+          }
 
           // Spread argument (`parseFloat(...rest)`) cannot be rewritten safely.
-          if (firstArg.type === AST_NODE_TYPES.SpreadElement) return;
+          if (firstArg.type === AST_NODE_TYPES.SpreadElement) {
+            return;
+          }
 
           // The argument must be purely `string` so the autofix is type-safe
           // against `Num.safeParseFloat(s: string)`. Without type information,
           // skip.
-          if (services?.program == null) return;
+          if (services?.program == null) {
+            return;
+          }
 
           const checker = services.program.getTypeChecker();
 
-          const tsNode = services.esTreeNodeToTSNodeMap?.get(firstArg);
-
-          if (tsNode === undefined) return;
-
-          const argType = checker.getTypeAtLocation(tsNode);
-
-          if (!isStringType(argType)) return;
+          // Every layer of type wrappers must be `string` (see
+          // typeWrapperLayers): the value underneath is what `Number` sees at
+          // run time (`Number(v as string)` may still be handed `true`), and
+          // the type a wrapper states is what the fix, which keeps the
+          // wrapper, passes on.
+          const isString = (
+            // AST nodes hold mutable child arrays, so they are not deeply readonly.
+            // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+            expression: TSESTree.Node,
+          ): boolean => {
+            const tsNode = services.esTreeNodeToTSNodeMap?.get(expression);
+
+            return (
+              tsNode !== undefined &&
+              isStringType(checker.getTypeAtLocation(tsNode))
+            );
+          };
+
+          if (!typeWrapperLayers(firstArg).every(isString)) {
+            return;
+          }
 
           mut_nodesToFix.push({ node, argExpression: firstArg });
         },
@@ -131,7 +155,7 @@ export const preferNumSafeParseFloat: TSESLint.RuleModule<MessageIds, Options> =
             index,
             { node, argExpression },
           ] of mut_nodesToFix.entries()) {
-            const argText = sourceCode.getText(argExpression);
+            const argText = toArgumentText(argExpression, sourceCode);
 
             const originalText = sourceCode.getText(node);
 

package/src/rules/prefer-num-safe-parse-float.test.mts

@@ -161,3 +161,82 @@ describe('prefer-num-safe-parse-float', () => {
     ],
   });
 }, 20000);
+
+describe('prefer-num-safe-parse-float through type wrappers', () => {
+  tester.run('prefer-num-safe-parse-float', preferNumSafeParseFloat, {
+    valid: [
+      {
+        name: 'an unknown value cast to string',
+        code: dedent`
+          declare const v: unknown;
+          const a = Number(v as string);
+          const b = parseFloat(<string>v);
+        `,
+      },
+      {
+        name: 'a number cast to string',
+        code: dedent`
+          declare const n: number;
+          const a = Number(n as unknown as string);
+        `,
+      },
+      {
+        name: 'a string whose type a middle layer does not vouch for',
+        code: dedent`
+          declare const s: string;
+          const a = Number(s as unknown as string);
+        `,
+      },
+      {
+        name: 'a `!` that leaves null in place (`Number(null)` is 0)',
+        code: dedent`
+          declare const s: string | null;
+          const a = Number(s!);
+        `,
+      },
+    ],
+    invalid: [
+      {
+        name: 'a string argument keeps its wrapper',
+        code: dedent`
+          declare const s: string;
+          const a = Number(s!);
+          const b = parseFloat(s satisfies string);
+        `,
+        output: dedent`
+          import { Num, Result } from 'ts-data-forge';
+          declare const s: string;
+          const a = Result.unwrapOkOr(Num.safeParseFloat(s!), Number.NaN);
+          const b = Result.unwrapOkOr(Num.safeParseFloat(s satisfies string), Number.NaN);
+        `,
+        errors: [
+          { messageId: 'useSafeParseFloat' },
+          { messageId: 'useSafeParseFloat' },
+        ],
+      },
+    ],
+  });
+}, 20000);
+
+describe('prefer-num-safe-parse-float with parenthesized operands', () => {
+  tester.run('prefer-num-safe-parse-float', preferNumSafeParseFloat, {
+    valid: [],
+    invalid: [
+      {
+        name: 'a sequence argument keeps its parentheses',
+        code: dedent`
+          declare const s: string;
+          declare const log: () => void;
+          const a = Number((log(), s));
+        `,
+        output: dedent`
+          import { Num, Result } from 'ts-data-forge';
+          declare const s: string;
+          declare const log: () => void;
+          const a = Result.unwrapOkOr(Num.safeParseFloat((log(), s)), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeParseFloat' }],
+      },
+    ],
+  });
+}, 20000);

package/src/rules/prefer-num-safe-parse-int.mts

@@ -4,6 +4,11 @@ import {
   type TSESTree,
 } from '@typescript-eslint/utils';
 import * as ts from 'typescript';
+import {
+  skipTypeWrappers,
+  toArgumentText,
+  typeWrapperLayers,
+} from './ast-utils.mjs';
 import {
   buildImportFixes,
   getNamedImports,
@@ -84,20 +89,28 @@ export const preferNumSafeParseInt: TSESLint.RuleModule<MessageIds, Options> = {
           callee.property.type === AST_NODE_TYPES.Identifier &&
           callee.property.name === 'parseInt';
 
-        if (!isGlobalParseInt && !isNumberParseInt) return;
+        if (!isGlobalParseInt && !isNumberParseInt) {
+          return;
+        }
 
         const args = node.arguments;
 
         const firstArg = args[0];
 
-        if (firstArg === undefined) return;
+        if (firstArg === undefined) {
+          return;
+        }
 
         // Spread argument (`parseInt(...rest)`) cannot be rewritten safely.
-        if (firstArg.type === AST_NODE_TYPES.SpreadElement) return;
+        if (firstArg.type === AST_NODE_TYPES.SpreadElement) {
+          return;
+        }
 
-        // Only base 10: accept a missing radix or an explicit literal `10`.
+        // Only base 10: accept a missing radix or an explicit literal `10`,
+        // under any type wrapper (`10 as const`).
         if (args.length >= 2) {
-          const radix = args[1];
+          const radix =
+            args[1] === undefined ? undefined : skipTypeWrappers(args[1]);
 
           if (radix?.type !== AST_NODE_TYPES.Literal || radix.value !== 10) {
             return;
@@ -105,18 +118,31 @@ export const preferNumSafeParseInt: TSESLint.RuleModule<MessageIds, Options> = {
         }
 
         // The argument must be a `string` so the autofix is type-safe against
-        // `Num.safeParseInt(s: string)`. Without type information, skip.
-        if (services?.program == null) return;
+        // `Num.safeParseInt(s: string)`. Without type information, skip. Every
+        // layer of type wrappers is asked (see typeWrapperLayers): a cast
+        // does not make a number a string.
+        if (services?.program == null) {
+          return;
+        }
 
         const checker = services.program.getTypeChecker();
 
-        const tsNode = services.esTreeNodeToTSNodeMap?.get(firstArg);
-
-        if (tsNode === undefined) return;
-
-        const argType = checker.getTypeAtLocation(tsNode);
-
-        if (!isStringType(argType)) return;
+        const isString = (
+          // AST nodes hold mutable child arrays, so they are not deeply readonly.
+          // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+          expression: TSESTree.Node,
+        ): boolean => {
+          const tsNode = services.esTreeNodeToTSNodeMap?.get(expression);
+
+          return (
+            tsNode !== undefined &&
+            isStringType(checker.getTypeAtLocation(tsNode))
+          );
+        };
+
+        if (!typeWrapperLayers(firstArg).every(isString)) {
+          return;
+        }
 
         mut_nodesToFix.push({ node, argExpression: firstArg });
       },
@@ -131,7 +157,7 @@ export const preferNumSafeParseInt: TSESLint.RuleModule<MessageIds, Options> = {
           index,
           { node, argExpression },
         ] of mut_nodesToFix.entries()) {
-          const argText = sourceCode.getText(argExpression);
+          const argText = toArgumentText(argExpression, sourceCode);
 
           const originalText = sourceCode.getText(node);
 

package/src/rules/prefer-num-safe-parse-int.test.mts

@@ -135,3 +135,67 @@ describe('prefer-num-safe-parse-int', () => {
     ],
   });
 }, 20000);
+
+describe('prefer-num-safe-parse-int through type wrappers', () => {
+  tester.run('prefer-num-safe-parse-int', preferNumSafeParseInt, {
+    valid: [
+      {
+        name: 'a number cast to string',
+        code: dedent`
+          declare const n: number;
+          const a = parseInt(n as unknown as string, 10);
+        `,
+      },
+      {
+        name: 'a wrapped radix other than 10',
+        code: dedent`
+          declare const s: string;
+          const a = parseInt(s, 16 as const);
+        `,
+      },
+    ],
+    invalid: [
+      {
+        name: 'a radix wrapped in `as const` or `satisfies`',
+        code: dedent`
+          declare const s: string;
+          const a = parseInt(s, 10 as const);
+          const b = Number.parseInt(s!, 10 satisfies number);
+        `,
+        output: dedent`
+          import { Num, Result } from 'ts-data-forge';
+          declare const s: string;
+          const a = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN);
+          const b = Result.unwrapOkOr(Num.safeParseInt(s!), Number.NaN);
+        `,
+        errors: [
+          { messageId: 'useSafeParseInt' },
+          { messageId: 'useSafeParseInt' },
+        ],
+      },
+    ],
+  });
+}, 20000);
+
+describe('prefer-num-safe-parse-int with parenthesized operands', () => {
+  tester.run('prefer-num-safe-parse-int', preferNumSafeParseInt, {
+    valid: [],
+    invalid: [
+      {
+        name: 'a sequence argument keeps its parentheses',
+        code: dedent`
+          declare const s: string;
+          declare const log: () => void;
+          const a = parseInt((log(), s), 10);
+        `,
+        output: dedent`
+          import { Num, Result } from 'ts-data-forge';
+          declare const s: string;
+          declare const log: () => void;
+          const a = Result.unwrapOkOr(Num.safeParseInt((log(), s)), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeParseInt' }],
+      },
+    ],
+  });
+}, 20000);

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

@@ -4,7 +4,7 @@ import {
   type TSESTree,
 } from '@typescript-eslint/utils';
 import { Arr } from 'ts-data-forge';
-import { type ReadonlyRecord } from 'ts-type-forge';
+import type { ReadonlyRecord } from 'ts-type-forge';
 import {
   buildImportFixes,
   getImportedLocalName,
@@ -159,7 +159,9 @@ export const preferObjOverEntriesRoundTrip: TSESLint.RuleModule<
       CallExpression: (node) => {
         const roundTrip = parseEntriesRoundTrip(node);
 
-        if (roundTrip === undefined) return;
+        if (roundTrip === undefined) {
+          return;
+        }
 
         mut_roundTrips.push({ node, roundTrip });
       },
@@ -225,13 +227,19 @@ export const preferObjOverEntriesRoundTrip: TSESLint.RuleModule<
 const parseEntriesRoundTrip = (
   node: TSESTree.CallExpression,
 ): RoundTrip | undefined => {
-  if (!isObjectStaticCall(node, 'fromEntries')) return undefined;
+  if (!isObjectStaticCall(node, 'fromEntries')) {
+    return undefined;
+  }
 
-  if (!Arr.isFixedLengthTuple(1, node.arguments)) return undefined;
+  if (!Arr.isFixedLengthTuple(1, node.arguments)) {
+    return undefined;
+  }
 
   const [transform] = node.arguments;
 
-  if (transform.type !== AST_NODE_TYPES.CallExpression) return undefined;
+  if (transform.type !== AST_NODE_TYPES.CallExpression) {
+    return undefined;
+  }
 
   const { callee } = transform;
 
@@ -265,11 +273,15 @@ const parseEntriesRoundTrip = (
 
   const [record] = entriesCall.arguments;
 
-  if (record.type === AST_NODE_TYPES.SpreadElement) return undefined;
+  if (record.type === AST_NODE_TYPES.SpreadElement) {
+    return undefined;
+  }
 
   // A second argument (`thisArg`) or a callback that also takes the entry index
   // has no counterpart in `Obj`.
-  if (!Arr.isFixedLengthTuple(1, transform.arguments)) return undefined;
+  if (!Arr.isFixedLengthTuple(1, transform.arguments)) {
+    return undefined;
+  }
 
   const [callback] = transform.arguments;
 
@@ -287,11 +299,15 @@ const parseEntriesRoundTrip = (
 
   const [entryPattern] = callback.params;
 
-  if (entryPattern.type !== AST_NODE_TYPES.ArrayPattern) return undefined;
+  if (entryPattern.type !== AST_NODE_TYPES.ArrayPattern) {
+    return undefined;
+  }
 
   const entryParams = parseEntryPattern(entryPattern);
 
-  if (entryParams === undefined) return undefined;
+  if (entryParams === undefined) {
+    return undefined;
+  }
 
   const body = callback.body;
 
@@ -320,7 +336,9 @@ const parseEntriesRoundTrip = (
     }
 
     case 'flatMap': {
-      if (body.type !== AST_NODE_TYPES.ConditionalExpression) return undefined;
+      if (body.type !== AST_NODE_TYPES.ConditionalExpression) {
+        return undefined;
+      }
 
       const onTrue = parseSingletonEntry(body.consequent, entryParams.keyParam);
 
@@ -365,7 +383,9 @@ type EntryParams = Readonly<{
 const parseEntryPattern = (
   pattern: TSESTree.ArrayPattern,
 ): EntryParams | undefined => {
-  if (pattern.elements.length > 2) return undefined;
+  if (pattern.elements.length > 2) {
+    return undefined;
+  }
 
   const [keyElement, valueElement] = pattern.elements;
 
@@ -399,7 +419,9 @@ const parseKeptEntry = (
   node: TSESTree.Expression,
   keyParam: TSESTree.Identifier | undefined,
 ): KeptEntry | undefined => {
-  if (keyParam === undefined) return undefined;
+  if (keyParam === undefined) {
+    return undefined;
+  }
 
   const tuple = stripTypeWrappers(node);
 

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;
         }
@@ -81,7 +91,9 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
         const endExpr = node.test.right;
 
         // Check update: ++i, i++, i += 1, or i += step
-        if (node.update === null) return;
+        if (node.update === null) {
+          return;
+        }
 
         let mut_step: string | undefined;
 
@@ -103,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;
@@ -116,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>;