eslint-plugin-ts-std-forge 0.1.8 → 0.1.10

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

@@ -12,7 +12,7 @@ import {
 } from 'eslint-rule-forge';
 import { SafeArray } from 'ts-std-forge';
 import * as ts from 'typescript';
-import { getValueType, isIdentifierNamed } from './ast-utils.mjs';
+import { isIdentifierNamed, typeHoldsAtEveryLayer } from './ast-utils.mjs';
 import { TS_STD_FORGE_MODULE } from './constants.mjs';
 
 type Options = readonly [];
@@ -47,27 +47,40 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
         TS_STD_FORGE_MODULE,
       );
 
-      const checker = sourceCode.parserServices?.program?.getTypeChecker();
-
       /**
        * Whether the `isRecord(...)` half of the rewrite would be dead code
        * because the object already satisfies `hasKey`'s
-       * `R extends UnknownRecord` constraint. Without type information nothing
-       * is known, so the guard is kept. The type is the value's, not a cast's:
-       * an array cast to a record is still rejected by `isRecord`.
+       * `R extends UnknownRecord` constraint, at every layer of type
+       * wrappers: an array cast to a record is still rejected by `isRecord`,
+       * and a record widened to one that may be an array is the author saying
+       * it may need the guard. Without type information nothing is known, so
+       * the guard is kept.
        */
       const isKnownRecord = (
         // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
         expression: TSESTree.Expression,
-      ): boolean => {
-        if (checker === undefined) {
-          return false;
-        }
-
-        const type = getValueType(sourceCode, expression);
+      ): boolean =>
+        typeHoldsAtEveryLayer(sourceCode, expression, (type, checker) =>
+          isAlreadyRecordType(checker, type),
+        );
 
-        return type !== undefined && isAlreadyRecordType(checker, type);
-      };
+      /**
+       * Whether the object may be an array at some layer of type wrappers.
+       * `isRecord` rejects an array, so `'0' in xs` would turn from `true` to
+       * `false`; a widening cast to a type that may be an array is the author
+       * saying it may be one. Without type information nothing is known, and
+       * the rule reports as it always has.
+       */
+      const mayBeArray = (
+        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+        expression: TSESTree.Expression,
+      ): boolean =>
+        sourceCode.parserServices?.program != null &&
+        !typeHoldsAtEveryLayer(
+          sourceCode,
+          expression,
+          (type, checker) => !mayBeArrayType(checker, type),
+        );
 
       const mut_nodesToFix: {
         node: TSESTree.CallExpression | TSESTree.BinaryExpression;
@@ -105,7 +118,8 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
           // Type guard: ensure arguments are Expressions (not SpreadElement)
           if (
             objArg.type === AST_NODE_TYPES.SpreadElement ||
-            keyArg.type === AST_NODE_TYPES.SpreadElement
+            keyArg.type === AST_NODE_TYPES.SpreadElement ||
+            mayBeArray(objArg)
           ) {
             return;
           }
@@ -128,7 +142,10 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
           const objExpression = node.right;
 
           // Type guard: ensure keyExpression is Expression (not PrivateIdentifier)
-          if (keyExpression.type === AST_NODE_TYPES.PrivateIdentifier) {
+          if (
+            keyExpression.type === AST_NODE_TYPES.PrivateIdentifier ||
+            mayBeArray(objExpression)
+          ) {
             return;
           }
 
@@ -142,25 +159,40 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
         'Program:exit': () => {
           const namedImports = getNamedImports(tsStdForgeImports);
 
-          const rewrites = mut_nodesToFix.map((entry) => ({
-            ...entry,
+          const rewrites = mut_nodesToFix.map((entry) => {
             // A record-typed object makes the `isRecord(...)` conjunct always
             // true, so it is left out of the replacement entirely.
-            needsIsRecord: !isKnownRecord(entry.objExpression),
-          }));
-
-          const importsToAdd: readonly string[] = [
-            ...(rewrites.some(({ needsIsRecord }) => needsIsRecord) &&
-            !namedImports.includes('isRecord')
-              ? ['isRecord']
-              : []),
-            ...(namedImports.includes('hasKey') ? [] : ['hasKey']),
-          ];
-
-          for (const [
-            index,
-            { node, objExpression, keyExpression, needsIsRecord },
-          ] of rewrites.entries()) {
+            const needsIsRecord = !isKnownRecord(entry.objExpression);
+
+            return {
+              ...entry,
+              needsIsRecord,
+              // `isRecord(obj) && hasKey(obj, key)` evaluates `obj` twice.
+              fixable: !needsIsRecord || isSideEffectFree(entry.objExpression),
+            };
+          });
+
+          const fixableRewrites = rewrites.filter(({ fixable }) => fixable);
+
+          const importsToAdd: readonly string[] = SafeArray.isEmpty(
+            fixableRewrites,
+          )
+            ? []
+            : [
+                ...(fixableRewrites.some(
+                  ({ needsIsRecord }) => needsIsRecord,
+                ) && !namedImports.includes('isRecord')
+                  ? ['isRecord']
+                  : []),
+                ...(namedImports.includes('hasKey') ? [] : ['hasKey']),
+              ];
+
+          const importCarrier = fixableRewrites[0];
+
+          for (const rewrite of rewrites) {
+            const { node, objExpression, keyExpression, needsIsRecord } =
+              rewrite;
+
             const objText = getArgumentText(sourceCode, objExpression);
 
             const keyText = getArgumentText(sourceCode, keyExpression);
@@ -175,26 +207,32 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
                 objName: objText,
                 keyName: keyText,
               },
-              fix: (fixer) => {
-                const replacement = needsIsRecord
-                  ? `(isRecord(${objText}) && hasKey(${objText}, ${keyText}))`
-                  : `hasKey(${objText}, ${keyText})`;
-
-                // All import fixes have to live on the first report:
-                // `insertTextBefore(program, …)` produces overlapping ranges
-                // otherwise and only one of them would survive a pass.
-                const importFixes =
-                  index === 0 && importsToAdd.length > 0
-                    ? buildNamedImportFix(
-                        fixer,
-                        program,
-                        TS_STD_FORGE_MODULE,
-                        importsToAdd,
-                      )
-                    : [];
-
-                return [...importFixes, fixer.replaceText(node, replacement)];
-              },
+              fix: !rewrite.fixable
+                ? undefined
+                : (fixer) => {
+                    const replacement = needsIsRecord
+                      ? `(isRecord(${objText}) && hasKey(${objText}, ${keyText}))`
+                      : `hasKey(${objText}, ${keyText})`;
+
+                    // All import fixes have to live on the first fixable
+                    // report: `insertTextBefore(program, …)` produces
+                    // overlapping ranges otherwise and only one of them would
+                    // survive a pass.
+                    const importFixes =
+                      rewrite === importCarrier && importsToAdd.length > 0
+                        ? buildNamedImportFix(
+                            fixer,
+                            program,
+                            TS_STD_FORGE_MODULE,
+                            importsToAdd,
+                          )
+                        : [];
+
+                    return [
+                      ...importFixes,
+                      fixer.replaceText(node, replacement),
+                    ];
+                  },
             });
           }
         },
@@ -203,6 +241,56 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
     defaultOptions: [],
   } as const;
 
+/**
+ * Whether reading `node` again has no side effects: a variable, `this`, or a
+ * non-computed property chain on one, type wrappers aside.
+ */
+const isSideEffectFree = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  wrapped: TSESTree.Node,
+): boolean => {
+  const node = skipTypeWrappers(wrapped);
+
+  return (
+    node.type === AST_NODE_TYPES.Identifier ||
+    node.type === AST_NODE_TYPES.ThisExpression ||
+    (node.type === AST_NODE_TYPES.MemberExpression &&
+      !node.computed &&
+      isSideEffectFree(node.object))
+  );
+};
+
+/**
+ * Whether a value of `type` may be an array or a tuple: some member of a union
+ * or an intersection is one, or the constraint of a deferred type is.
+ * `object` and `unknown` say nothing either way and are not counted.
+ */
+const mayBeArrayType = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  checker: ts.TypeChecker,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  type: ts.Type,
+): boolean => {
+  if (type.isUnionOrIntersection()) {
+    return type.types.some((member) => mayBeArrayType(checker, member));
+  }
+
+  if (
+    (type.flags &
+      (ts.TypeFlags.TypeParameter |
+        ts.TypeFlags.IndexedAccess |
+        ts.TypeFlags.Conditional |
+        ts.TypeFlags.Substitution)) !==
+    0
+  ) {
+    const constraint = checker.getBaseConstraintOfType(type);
+
+    return constraint !== undefined && mayBeArrayType(checker, constraint);
+  }
+
+  return checker.isArrayType(type) || checker.isTupleType(type);
+};
+
 /**
  * Whether `type` already satisfies `hasKey`'s `R extends UnknownRecord`
  * constraint, so that guarding the call with `isRecord` adds nothing.

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

@@ -83,21 +83,6 @@ describe('prefer-is-record-and-has-key through type wrappers', () => {
   tester.run('prefer-is-record-and-has-key', preferIsRecordAndHasKey, {
     valid: [],
     invalid: [
-      {
-        // `isRecord` rejects an array, so dropping it on the cast's word
-        // would turn `false` into `true`.
-        name: 'keeps isRecord for an array cast to a record',
-        code: dedent`
-          declare const arr: string[];
-          const ok = Object.hasOwn(arr as unknown as Record<string, unknown>, '0');
-        `,
-        output: dedent`
-          import { isRecord, hasKey } from 'ts-std-forge';
-          declare const arr: 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 an unknown value cast to a record in `in`',
         code: dedent`
@@ -125,15 +110,29 @@ describe('prefer-is-record-and-has-key through type wrappers', () => {
         errors: [{ messageId: 'useHasKey' }],
       },
       {
-        name: 'reads `!` on an optional record as the record it asserts',
+        // `Object.hasOwn(undefined, 'a')` throws; `isRecord` answers false.
+        name: 'keeps isRecord for `!` on an optional record, which leaves undefined in place',
         code: dedent`
           declare const obj: Readonly<Record<string, unknown>> | undefined;
           const ok = Object.hasOwn(obj!, 'a');
         `,
         output: dedent`
-          import { hasKey } from 'ts-std-forge';
+          import { isRecord, hasKey } from 'ts-std-forge';
           declare const obj: Readonly<Record<string, unknown>> | undefined;
-          const ok = hasKey(obj!, 'a');
+          const ok = (isRecord(obj!) && hasKey(obj!, 'a'));
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'drops isRecord for a record that is a record at every layer',
+        code: dedent`
+          declare const obj: Readonly<Record<string, unknown>>;
+          const ok = Object.hasOwn(obj! as Readonly<Record<string, unknown>>, 'a');
+        `,
+        output: dedent`
+          import { hasKey } from 'ts-std-forge';
+          declare const obj: Readonly<Record<string, unknown>>;
+          const ok = hasKey(obj! as Readonly<Record<string, unknown>>, 'a');
         `,
         errors: [{ messageId: 'useHasKey' }],
       },
@@ -159,34 +158,39 @@ describe('prefer-is-record-and-has-key with parenthesized operands', () => {
     valid: [],
     invalid: [
       {
-        name: 'keeps the parentheses of a sequence object in `in`',
+        name: 'a sequence object in `in`, read twice by the fix, gets no fix',
         code: dedent`
           declare const a: number;
           declare const o: unknown;
           const ok = 'k' in (a, o);
         `,
-        output: dedent`
-          import { isRecord, hasKey } from 'ts-std-forge';
+        output: null,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'a sequence object in Object.hasOwn, read twice by the fix, gets no fix',
+        code: dedent`
           declare const a: number;
           declare const o: unknown;
-          const ok = (isRecord((a, o)) && hasKey((a, o), 'k'));
+          const ok = Object.hasOwn((a, o), 'k');
         `,
+        output: null,
         errors: [{ messageId: 'useIsRecordAndHasKey' }],
       },
       {
-        name: 'keeps the parentheses of a sequence object in Object.hasOwn',
+        name: 'keeps the parentheses of a sequence object read once',
         code: dedent`
           declare const a: number;
-          declare const o: unknown;
-          const ok = Object.hasOwn((a, o), 'k');
+          declare const o: Readonly<Record<string, unknown>>;
+          const ok = 'k' in (a, o);
         `,
         output: dedent`
-          import { isRecord, hasKey } from 'ts-std-forge';
+          import { hasKey } from 'ts-std-forge';
           declare const a: number;
-          declare const o: unknown;
-          const ok = (isRecord((a, o)) && hasKey((a, o), 'k'));
+          declare const o: Readonly<Record<string, unknown>>;
+          const ok = hasKey((a, o), 'k');
         `,
-        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+        errors: [{ messageId: 'useHasKey' }],
       },
       {
         name: 'keeps the parentheses of a sequence key',
@@ -206,3 +210,86 @@ describe('prefer-is-record-and-has-key with parenthesized operands', () => {
     ],
   });
 });
+
+describe('prefer-is-record-and-has-key where the rewrite would change behavior', () => {
+  tester.run('prefer-is-record-and-has-key', preferIsRecordAndHasKey, {
+    valid: [
+      {
+        // `isRecord` rejects an array, so `'0' in xs` would turn false.
+        name: 'an array',
+        code: dedent`
+          declare const xs: readonly number[];
+          const a = '0' in xs;
+          const b = Object.hasOwn(xs, 'length');
+        `,
+      },
+      {
+        name: 'a union with an array',
+        code: dedent`
+          declare const v: Readonly<Record<string, unknown>> | readonly number[];
+          const ok = 'k' in v;
+        `,
+      },
+      {
+        name: 'an array cast to a record',
+        code: dedent`
+          declare const arr: readonly string[];
+          const ok = Object.hasOwn(arr as unknown as Record<string, unknown>, '0');
+        `,
+      },
+      {
+        name: 'a record widened by `as` to one that may be 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 string[], 'a');
+        `,
+      },
+    ],
+    invalid: [
+      {
+        // `isRecord(…) && hasKey(…)` would evaluate the object twice.
+        name: 'an object with side effects is reported without a fix',
+        code: dedent`
+          declare const getObj: () => object;
+          declare const log: () => void;
+          declare const o: object;
+          const a = 'k' in getObj();
+          const b = Object.hasOwn(getObj(), 'k');
+          const c = 'k' in (log(), o);
+        `,
+        output: null,
+        errors: [
+          { messageId: 'useIsRecordAndHasKey' },
+          { messageId: 'useIsRecordAndHasKey' },
+          { messageId: 'useIsRecordAndHasKey' },
+        ],
+      },
+      {
+        name: 'an object with side effects is fixed when isRecord is dropped: it is read once',
+        code: dedent`
+          declare const getRec: () => Readonly<Record<string, unknown>>;
+          const ok = 'k' in getRec();
+        `,
+        output: dedent`
+          import { hasKey } from 'ts-std-forge';
+          declare const getRec: () => Readonly<Record<string, unknown>>;
+          const ok = hasKey(getRec(), 'k');
+        `,
+        errors: [{ messageId: 'useHasKey' }],
+      },
+      {
+        name: 'a reference read through type wrappers is still read without side effects',
+        code: dedent`
+          declare const o: { readonly p: object };
+          const ok = 'k' in (o.p satisfies object);
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-std-forge';
+          declare const o: { readonly p: object };
+          const ok = (isRecord(o.p satisfies object) && hasKey(o.p satisfies object, 'k'));
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+    ],
+  });
+});

package/src/rules/prefer-safe-array-length-guard.mts

@@ -11,7 +11,7 @@ import {
   skipTypeWrappers,
 } from 'eslint-rule-forge';
 import type { ReadonlyRecord } from 'ts-type-forge';
-import { getValueType } from './ast-utils.mjs';
+import { typeHoldsAtEveryLayer } from './ast-utils.mjs';
 import { TS_STD_FORGE_MODULE } from './constants.mjs';
 
 type Options = readonly [];
@@ -86,29 +86,24 @@ export const preferSafeArrayLengthGuard: TSESLint.RuleModule<
       TS_STD_FORGE_MODULE,
     );
 
-    const checker = sourceCode.parserServices?.program?.getTypeChecker();
-
     /**
      * Whether `expression` is an array or tuple. Without type information the
      * answer is no: `.length` is also a string's, a function's and a
-     * `TypedArray`'s, and none of those can be handed to the guard. The type is
-     * the value's, not a cast's: a string cast to an array is still a string.
+     * `TypedArray`'s, and none of those can be handed to the guard. It has to
+     * be one at every layer of type wrappers: a string cast to an array is
+     * still a string, and the fix, which keeps the wrapper, hands the guard
+     * the type the outermost layer states.
      */
     const isArrayLike = (
       // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
       expression: TSESTree.Expression,
-    ): boolean => {
-      if (checker === undefined) {
-        return false;
-      }
-
-      const type = getValueType(sourceCode, expression);
-
-      return (
-        type !== undefined &&
-        (checker.isArrayType(type) || checker.isTupleType(type))
+    ): boolean =>
+      typeHoldsAtEveryLayer(
+        sourceCode,
+        expression,
+        (type, checker) =>
+          checker.isArrayType(type) || checker.isTupleType(type),
       );
-    };
 
     const mut_nodesToFix: {
       node: TSESTree.BinaryExpression;

package/src/rules/prefer-safe-array-length-guard.test.mts

@@ -168,6 +168,20 @@ describe('prefer-safe-array-length-guard through type wrappers', () => {
           const ok = xs.length > (2 as const);
         `,
       },
+      {
+        name: 'an array widened by `as` to one that may be a string',
+        code: dedent`
+          declare const xs: readonly string[];
+          const ok = (xs as readonly string[] | string).length > 0;
+        `,
+      },
+      {
+        name: '`!` on an optional array, which leaves undefined in place',
+        code: dedent`
+          declare const xs: readonly number[] | undefined;
+          const ok = xs!.length !== 0;
+        `,
+      },
     ],
     invalid: [
       {
@@ -210,15 +224,15 @@ describe('prefer-safe-array-length-guard through type wrappers', () => {
         errors: [{ messageId: 'useIsEmpty' }],
       },
       {
-        name: 'keeps a wrapper on the array and reads `!` as the array it asserts',
+        name: 'keeps a wrapper on an array that is an array at every layer',
         code: dedent`
-          declare const xs: readonly number[] | undefined;
-          const ok = xs!.length !== 0;
+          declare const xs: readonly number[];
+          const ok = (xs! as readonly number[]).length !== 0;
         `,
         output: dedent`
           import { SafeArray } from 'ts-std-forge';
-          declare const xs: readonly number[] | undefined;
-          const ok = SafeArray.isNonEmpty(xs!);
+          declare const xs: readonly number[];
+          const ok = SafeArray.isNonEmpty(xs! as readonly number[]);
         `,
         errors: [{ messageId: 'useIsNonEmpty' }],
       },

package/src/rules/prefer-safe-number-parse-integer.mts

@@ -11,7 +11,7 @@ import {
   skipTypeWrappers,
 } from 'eslint-rule-forge';
 import * as ts from 'typescript';
-import { getValueType, isIdentifierNamed } from './ast-utils.mjs';
+import { isIdentifierNamed, typeHoldsAtEveryLayer } from './ast-utils.mjs';
 import { TS_STD_FORGE_MODULE } from './constants.mjs';
 
 type Options = readonly [];
@@ -118,13 +118,13 @@ export const preferSafeNumberParseInteger: TSESLint.RuleModule<
           }
         }
 
-        // The argument must be a `string` so the autofix is type-safe against
-        // `SafeNumber.parseInteger(value: string)`, and that of the value, not
-        // of a cast: `parseInt(1e21 as unknown as string)` is 1, the rewrite
-        // 1e21. Without type information, skip.
-        const argType = getValueType(sourceCode, firstArg);
-
-        if (argType === undefined || !isStringType(argType)) {
+        // The argument must be a `string` at every layer of type wrappers:
+        // the value's own type is what `parseInt` sees at run time
+        // (`parseInt(1e21 as unknown as string)` is 1, the rewrite 1e21), and
+        // the type a wrapper states is what the fix, which keeps the wrapper,
+        // hands `SafeNumber.parseInteger(value: string)`. Without type
+        // information, skip.
+        if (!typeHoldsAtEveryLayer(sourceCode, firstArg, isStringType)) {
           return;
         }
 

package/src/rules/prefer-safe-number-parse-integer.test.mts

@@ -84,6 +84,20 @@ describe('prefer-safe-number-parse-integer through type wrappers', () => {
           const n = parseInt(s, 16 as const);
         `,
       },
+      {
+        name: 'ignores a string widened by `as` to one that may be a number',
+        code: dedent`
+          declare const s: string;
+          const n = parseInt(s as string | number as string);
+        `,
+      },
+      {
+        name: 'ignores `!` on an optional string, which leaves undefined in place',
+        code: dedent`
+          declare const s: string | undefined;
+          const n = parseInt(s!);
+        `,
+      },
     ],
     invalid: [
       {
@@ -131,15 +145,15 @@ describe('prefer-safe-number-parse-integer through type wrappers', () => {
         ],
       },
       {
-        name: 'reads `!` on an optional string as the string it asserts',
+        name: 'rewrites a string that is a string at every layer',
         code: dedent`
-          declare const s: string | undefined;
-          const n = parseInt(s!);
+          declare const s: string;
+          const n = parseInt(s! as string);
         `,
         output: dedent`
           import { Result, SafeNumber } from 'ts-std-forge';
-          declare const s: string | undefined;
-          const n = Result.unwrapOkOr(SafeNumber.parseInteger(s!), Number.NaN);
+          declare const s: string;
+          const n = Result.unwrapOkOr(SafeNumber.parseInteger(s! as string), Number.NaN);
         `,
         errors: [{ messageId: 'useSafeNumberParseInteger' }],
       },

package/src/rules/prefer-safe-number-parse.mts

@@ -11,7 +11,7 @@ import {
   skipTypeWrappers,
 } from 'eslint-rule-forge';
 import * as ts from 'typescript';
-import { getValueType, isIdentifierNamed } from './ast-utils.mjs';
+import { isIdentifierNamed, typeHoldsAtEveryLayer } from './ast-utils.mjs';
 import { TS_STD_FORGE_MODULE } from './constants.mjs';
 
 type Options = readonly [];
@@ -115,13 +115,13 @@ export const preferSafeNumberParse: TSESLint.RuleModule<MessageIds, Options> = {
           return;
         }
 
-        // The argument must be purely `string` so the autofix is type-safe
-        // against `SafeNumber.parse(value: string)`, and that of the value, not
-        // of a cast: `Number(true as unknown as string)` is 1, the rewrite NaN.
-        // Without type information, skip.
-        const argType = getValueType(sourceCode, firstArg);
-
-        if (argType === undefined || !isStringType(argType)) {
+        // The argument must be purely `string` at every layer of type
+        // wrappers: the value's own type is what `Number` sees at run time
+        // (`Number(true as unknown as string)` is 1, the rewrite NaN), and the
+        // type a wrapper states is what the fix, which keeps the wrapper,
+        // hands `SafeNumber.parse(value: string)`. Without type information,
+        // skip.
+        if (!typeHoldsAtEveryLayer(sourceCode, firstArg, isStringType)) {
           return;
         }