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

package/src/rules/prefer-comparison-over-nullish-guard.test.mts

@@ -169,3 +169,139 @@ describe('prefer-comparison-over-nullish-guard', () => {
     },
   );
 });
+
+describe('prefer-comparison-over-nullish-guard through type wrappers', () => {
+  tester.run(
+    'prefer-comparison-over-nullish-guard',
+    preferComparisonOverNullishGuard,
+    {
+      valid: [],
+      invalid: [
+        {
+          name: 'the call wrapped in `satisfies`, `as` or `<T>`',
+          code: dedent`
+            import { isNull, isNotUndefined } from 'ts-data-forge';
+            declare const x: string | null | undefined;
+            const a = isNull(x) satisfies boolean;
+            const b = isNotUndefined(x) as boolean;
+            const c = <boolean>isNull(x);
+          `,
+          output: dedent`
+            import { isNull, isNotUndefined } from 'ts-data-forge';
+            declare const x: string | null | undefined;
+            const a = (x === null) satisfies boolean;
+            const b = (x !== undefined) as boolean;
+            const c = <boolean>(x === null);
+          `,
+          errors: [
+            { messageId: 'preferComparison' },
+            { messageId: 'preferComparison' },
+            { messageId: 'preferComparison' },
+          ],
+        },
+        {
+          name: 'a wrapped argument is parenthesized under `===`',
+          code: dedent`
+            import { isNull } from 'ts-data-forge';
+            declare const x: unknown;
+            const a = isNull(x as string | null);
+            const b = isNull(x satisfies unknown);
+            const c = isNull(x!);
+          `,
+          output: dedent`
+            import { isNull } from 'ts-data-forge';
+            declare const x: unknown;
+            const a = (x as string | null) === null;
+            const b = (x satisfies unknown) === null;
+            const c = x! === null;
+          `,
+          errors: [
+            { messageId: 'preferComparison' },
+            { messageId: 'preferComparison' },
+            { messageId: 'preferComparison' },
+          ],
+        },
+        {
+          name: 'the guard itself reached through a wrapper',
+          code: dedent`
+            import { isNull } from 'ts-data-forge';
+            declare const x: string | null | undefined;
+            const a = (isNull as (u: unknown) => boolean)(x);
+          `,
+          output: dedent`
+            import { isNull } from 'ts-data-forge';
+            declare const x: string | null | undefined;
+            const a = x === null;
+          `,
+          errors: [{ messageId: 'preferComparison' }],
+        },
+        {
+          name: 'the namespace reached through a wrapper',
+          code: dedent`
+            import * as tf from 'ts-data-forge';
+            declare const x: string | null | undefined;
+            const b = (tf as typeof tf).isNotUndefined(x);
+          `,
+          output: dedent`
+            import * as tf from 'ts-data-forge';
+            declare const x: string | null | undefined;
+            const b = x !== undefined;
+          `,
+          errors: [{ messageId: 'preferComparison' }],
+        },
+      ],
+    },
+  );
+});
+
+describe('prefer-comparison-over-nullish-guard with parenthesized operands', () => {
+  tester.run(
+    'prefer-comparison-over-nullish-guard',
+    preferComparisonOverNullishGuard,
+    {
+      valid: [],
+      invalid: [
+        {
+          name: 'bitwise operators bind looser than `===`',
+          code: dedent`
+            import { isNull } from 'ts-data-forge';
+            declare const a: number;
+            declare const b: number;
+            const p = isNull(a | b);
+            const q = isNull(a ^ b);
+            const r = isNull((a & b));
+          `,
+          output: dedent`
+            import { isNull } from 'ts-data-forge';
+            declare const a: number;
+            declare const b: number;
+            const p = (a | b) === null;
+            const q = (a ^ b) === null;
+            const r = (a & b) === null;
+          `,
+          errors: [
+            { messageId: 'preferComparison' },
+            { messageId: 'preferComparison' },
+            { messageId: 'preferComparison' },
+          ],
+        },
+        {
+          name: 'an equality argument is parenthesized for readability',
+          code: dedent`
+            import { isNotUndefined } from 'ts-data-forge';
+            declare const a: unknown;
+            declare const b: unknown;
+            const p = isNotUndefined(a === b);
+          `,
+          output: dedent`
+            import { isNotUndefined } from 'ts-data-forge';
+            declare const a: unknown;
+            declare const b: unknown;
+            const p = (a === b) !== undefined;
+          `,
+          errors: [{ messageId: 'preferComparison' }],
+        },
+      ],
+    },
+  );
+});

package/src/rules/prefer-is-non-null-object.mts

@@ -3,7 +3,7 @@ import {
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
-import { type DeepReadonly } from 'ts-type-forge';
+import { skipTypeWrappers } from './ast-utils.mjs';
 import {
   buildImportFixes,
   getNamedImports,
@@ -88,8 +88,15 @@ export const preferIsNonNullObject: TSESLint.RuleModule<MessageIds, Options> = {
   defaultOptions: [],
 } as const;
 
+/**
+ * The name of the value checked by `typeof u === 'object' && u !== null`, or
+ * `undefined`. Every operand is read through type wrappers:
+ * `(u satisfies unknown) !== null` and `u! !== null` check the same `u`.
+ */
 const getNonNullObjectIdentifierName = (
-  node: DeepReadonly<TSESTree.LogicalExpression>,
+  // AST nodes hold mutable child arrays, so they are not deeply readonly.
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: TSESTree.LogicalExpression,
 ): string | undefined => {
   if (node.operator !== '&&') {
     return undefined;
@@ -107,7 +114,8 @@ const getNonNullObjectIdentifierName = (
 };
 
 const getTypeofObjectIdentifierName = (
-  node: DeepReadonly<TSESTree.Expression>,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: TSESTree.Expression,
 ): string | undefined => {
   if (node.type !== AST_NODE_TYPES.BinaryExpression) {
     return undefined;
@@ -117,19 +125,29 @@ const getTypeofObjectIdentifierName = (
     return undefined;
   }
 
-  const { left, right } = node;
+  const left = skipTypeWrappers(node.left);
 
-  return left.type !== AST_NODE_TYPES.UnaryExpression ||
+  const right = skipTypeWrappers(node.right);
+
+  if (
+    left.type !== AST_NODE_TYPES.UnaryExpression ||
     left.operator !== 'typeof' ||
     right.type !== AST_NODE_TYPES.Literal ||
-    right.value !== 'object' ||
-    left.argument.type !== AST_NODE_TYPES.Identifier
-    ? undefined
-    : left.argument.name;
+    right.value !== 'object'
+  ) {
+    return undefined;
+  }
+
+  const argument = skipTypeWrappers(left.argument);
+
+  return argument.type === AST_NODE_TYPES.Identifier
+    ? argument.name
+    : undefined;
 };
 
 const getNonNullCheckIdentifierName = (
-  node: DeepReadonly<TSESTree.Expression>,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: TSESTree.Expression,
 ): string | undefined => {
   if (node.type !== AST_NODE_TYPES.BinaryExpression) {
     return undefined;
@@ -139,7 +157,9 @@ const getNonNullCheckIdentifierName = (
     return undefined;
   }
 
-  const { left, right } = node;
+  const left = skipTypeWrappers(node.left);
+
+  const right = skipTypeWrappers(node.right);
 
   return left.type !== AST_NODE_TYPES.Identifier ||
     right.type !== AST_NODE_TYPES.Literal ||

package/src/rules/prefer-is-non-null-object.test.mts

@@ -154,3 +154,45 @@ describe('prefer-is-non-null-object', () => {
     ],
   });
 }, 20000);
+
+describe('prefer-is-non-null-object through type wrappers', () => {
+  tester.run('prefer-is-non-null-object', preferIsNonNullObject, {
+    valid: [
+      {
+        name: 'checks on two different values, one wrapped',
+        code: dedent`
+          declare const u: unknown;
+          declare const v: unknown;
+          const ok = typeof u === 'object' && (v satisfies unknown) !== null;
+        `,
+      },
+    ],
+    invalid: [
+      {
+        name: 'the value wrapped on either side',
+        code: dedent`
+          import { isNonNullObject } from 'ts-data-forge';
+          declare const u: unknown;
+          const a = typeof u === 'object' && (u satisfies unknown) !== null;
+          const b = typeof u === 'object' && u! !== null;
+          const c = typeof (u satisfies unknown) === 'object' && u !== null;
+          const d = typeof u === ('object' as const) && u !== (null as null);
+        `,
+        output: dedent`
+          import { isNonNullObject } from 'ts-data-forge';
+          declare const u: unknown;
+          const a = isNonNullObject(u);
+          const b = isNonNullObject(u);
+          const c = isNonNullObject(u);
+          const d = isNonNullObject(u);
+        `,
+        errors: [
+          { messageId: 'useIsNonNullObject' },
+          { messageId: 'useIsNonNullObject' },
+          { messageId: 'useIsNonNullObject' },
+          { messageId: 'useIsNonNullObject' },
+        ],
+      },
+    ],
+  });
+}, 20000);

package/src/rules/prefer-is-record-and-has-key.mts

@@ -5,6 +5,7 @@ import {
 } from '@typescript-eslint/utils';
 import { Arr } from 'ts-data-forge';
 import * as ts from 'typescript';
+import { typeWrapperLayers } from './ast-utils.mjs';
 import {
   buildImportFixes,
   getNamedImports,
@@ -58,12 +59,16 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
           return false;
         }
 
-        const tsNode = services?.esTreeNodeToTSNodeMap?.get(expression);
+        // At every layer of type wrappers (see typeWrapperLayers): an array
+        // cast to `Record<string, unknown>` still needs its `isRecord`.
+        return typeWrapperLayers(expression).every((layer) => {
+          const tsNode = services?.esTreeNodeToTSNodeMap?.get(layer);
 
-        return (
-          tsNode !== undefined &&
-          isAlreadyRecordType(checker, checker.getTypeAtLocation(tsNode))
-        );
+          return (
+            tsNode !== undefined &&
+            isAlreadyRecordType(checker, checker.getTypeAtLocation(tsNode))
+          );
+        });
       };
 
       const mut_nodesToFix: {

package/src/rules/prefer-is-record-and-has-key.test.mts

@@ -289,3 +289,37 @@ describe('prefer-is-record-and-has-key', () => {
     ],
   });
 }, 20000);
+
+describe('prefer-is-record-and-has-key through type wrappers', () => {
+  tester.run('prefer-is-record-and-has-key', preferIsRecordAndHasKey, {
+    valid: [],
+    invalid: [
+      {
+        name: 'keeps isRecord for an array cast to a record: the value is still an array',
+        code: dedent`
+          declare const arr: readonly string[];
+          const ok = Object.hasOwn(arr as unknown as Record<string, unknown>, '0');
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-data-forge';
+          declare const arr: readonly string[];
+          const ok = (isRecord(arr as unknown as Record<string, unknown>) && hasKey(arr as unknown as Record<string, unknown>, '0'));
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'keeps isRecord for a record widened to include an array: the author says it may be one',
+        code: dedent`
+          declare const obj: Readonly<Record<string, unknown>>;
+          const ok = Object.hasOwn(obj as Readonly<Record<string, unknown>> | readonly unknown[], 'a');
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-data-forge';
+          declare const obj: Readonly<Record<string, unknown>>;
+          const ok = (isRecord(obj as Readonly<Record<string, unknown>> | readonly unknown[]) && hasKey(obj as Readonly<Record<string, unknown>> | readonly unknown[], 'a'));
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+    ],
+  });
+});

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> =
   {
@@ -117,15 +120,25 @@ export const preferNumSafeParseFloat: TSESLint.RuleModule<MessageIds, Options> =
 
           const checker = services.program.getTypeChecker();
 
-          const tsNode = services.esTreeNodeToTSNodeMap?.get(firstArg);
-
-          if (tsNode === undefined) {
-            return;
-          }
-
-          const argType = checker.getTypeAtLocation(tsNode);
-
-          if (!isStringType(argType)) {
+          // 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;
           }
 
@@ -142,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,
@@ -101,9 +106,11 @@ export const preferNumSafeParseInt: TSESLint.RuleModule<MessageIds, Options> = {
           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;
@@ -111,22 +118,29 @@ 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.
+        // `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 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);
 
-        const argType = checker.getTypeAtLocation(tsNode);
+          return (
+            tsNode !== undefined &&
+            isStringType(checker.getTypeAtLocation(tsNode))
+          );
+        };
 
-        if (!isStringType(argType)) {
+        if (!typeWrapperLayers(firstArg).every(isString)) {
           return;
         }
 
@@ -143,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,