ts-codemod-lib 3.4.0 → 3.4.2

package/src/functions/ast-transformers/convert-to-readonly.test.mts

@@ -9,7 +9,7 @@ import * as prettier from 'prettier/standalone';
 import { expectType } from 'ts-data-forge';
 // Aliased: an import named `DeepReadonly` makes `vitest/prefer-describe-function-title`
 // rewrite `describe('DeepReadonly', ...)` into a reference to this type.
-import { type DeepReadonly as TsTypeForgeDeepReadonly } from 'ts-type-forge';
+import type { DeepReadonly as TsTypeForgeDeepReadonly } from 'ts-type-forge';
 import {
   convertToReadonlyTransformer,
   type ReadonlyTransformerOptions,
@@ -3034,6 +3034,380 @@ describe(convertToReadonlyTransformer, () => {
     });
   });
 
+  describe('Readonly over a union or intersection', () => {
+    test.each(
+      [
+        // A member whose readonly-ness the codemod cannot see stays under the
+        // `Readonly` it was written under.
+        {
+          name: 'An alias in an intersection under Readonly stays under it',
+          source: dedent`
+            type X<A> = Readonly<A & { b: string[] }>;
+          `,
+          expected: dedent`
+            type X<A> = Readonly<A & { b: readonly string[] }>;
+          `,
+        },
+        {
+          name: 'An alias in a union under Readonly stays under it',
+          source: dedent`
+            type X<A> = Readonly<A | { b: string[] }>;
+          `,
+          expected: dedent`
+            type X<A> = Readonly<A | { b: readonly string[] }>;
+          `,
+        },
+        {
+          name: 'An intersection of aliases under Readonly is left as written',
+          source: dedent`
+            type X<A, B> = Readonly<A & B>;
+          `,
+          expected: dedent`
+            type X<A, B> = Readonly<A & B>;
+          `,
+        },
+        {
+          name: 'A nested union under Readonly stays under it',
+          source: dedent`
+            type X<A, B> = Readonly<(A | B) & { c: string[] }>;
+          `,
+          expected: dedent`
+            type X<A, B> = Readonly<(A | B) & { c: readonly string[] }>;
+          `,
+        },
+        {
+          name: 'Members readonly on their own are still taken out',
+          source: dedent`
+            type X<A> = Readonly<number | string[] | DeepReadonly<A> | Map<string, A> | { b: string }>;
+          `,
+          expected: dedent`
+            type X<A> = number | readonly string[] | DeepReadonly<A> | ReadonlyMap<string, A> | Readonly<{ b: string }>;
+          `,
+        },
+        {
+          // `Readonly` would drop the call signature.
+          name: 'A function type is still taken out',
+          source: dedent`
+            type X = Readonly<(() => void) & { b: string }>;
+          `,
+          expected: dedent`
+            type X = (() => void) & Readonly<{ b: string }>;
+          `,
+        },
+
+        // #2231: what replaces `Readonly<…>` keeps the parentheses its
+        // position needs.
+        {
+          name: 'Readonly of an intersection with an alias as an array element under readonly',
+          source: dedent`
+            type A = Readonly<{ a: string }>;
+            export type X = readonly Readonly<A & { b: string }>[];
+          `,
+          expected: dedent`
+            type A = Readonly<{ a: string }>;
+            export type X = readonly Readonly<A & { b: string }>[];
+          `,
+        },
+        {
+          name: 'Readonly of an intersection with an alias as an array element',
+          source: dedent`
+            type A = Readonly<{ a: string }>;
+            export type X = Readonly<A & { b: string }>[];
+          `,
+          expected: dedent`
+            type A = Readonly<{ a: string }>;
+            export type X = readonly Readonly<A & { b: string }>[];
+          `,
+        },
+        {
+          name: 'Readonly of a union with an alias as an array element',
+          source: dedent`
+            type X<A> = Readonly<A | { b: string }>[];
+          `,
+          expected: dedent`
+            type X<A> = readonly Readonly<A | { b: string }>[];
+          `,
+        },
+        {
+          name: 'Readonly of an intersection with an alias in ReadonlyArray',
+          source: dedent`
+            type X<A> = ReadonlyArray<Readonly<A & { b: string }>>;
+          `,
+          expected: dedent`
+            type X<A> = readonly Readonly<A & { b: string }>[];
+          `,
+        },
+        {
+          name: 'A Readonly that is taken off as an array element',
+          source: dedent`
+            type X = Readonly<number | readonly string[]>[];
+          `,
+          expected: dedent`
+            type X = readonly (number | readonly string[])[];
+          `,
+        },
+        {
+          name: 'A Readonly that is taken off under readonly',
+          source: dedent`
+            type X = readonly Readonly<number & { b: string }>[];
+          `,
+          expected: dedent`
+            type X = readonly (number & Readonly<{ b: string }>)[];
+          `,
+        },
+        {
+          name: 'A Readonly that is taken off as an intersection member',
+          source: dedent`
+            type X = { a: string } & Readonly<number | { b: string }>;
+          `,
+          expected: dedent`
+            type X = Readonly<{ a: string }> & (number | Readonly<{ b: string }>);
+          `,
+        },
+
+        // #2169: `Readonly<A> & Readonly<B>` is merged only when both are
+        // object types, because `Readonly<string[] & X>` leaves the array
+        // mutable.
+        {
+          name: 'An intersection of Readonly aliases is not merged',
+          source: dedent`
+            type X<A, B> = Readonly<A> & Readonly<B>;
+          `,
+          expected: dedent`
+            type X<A, B> = Readonly<A> & Readonly<B>;
+          `,
+        },
+        {
+          name: 'A Readonly alias is not merged with a type literal',
+          source: dedent`
+            type X<A> = Readonly<A> & { b: string[] };
+          `,
+          expected: dedent`
+            type X<A> = Readonly<A> & Readonly<{ b: readonly string[] }>;
+          `,
+        },
+        {
+          name: 'Readonly type literals in an intersection are merged',
+          source: dedent`
+            type X = Readonly<{ a: string } | { c: string }> & Readonly<{ b: string }>;
+          `,
+          expected: dedent`
+            type X = Readonly<({ a: string } | { c: string }) & { b: string }>;
+          `,
+        },
+        {
+          // A mapped type over anything but `keyof T` is an object type.
+          name: 'Mapped types in an intersection under Readonly are merged',
+          source: dedent`
+            type X<S, K extends keyof S> = Readonly<{ [k in K]?: S[k] } & { [k in Exclude<keyof S, K>]: S[k] }>;
+          `,
+          expected: dedent`
+            type X<S, K extends keyof S> = Readonly<{ [k in K]?: S[k] } & { [k in Exclude<keyof S, K>]: S[k] }>;
+          `,
+        },
+        {
+          // `{ [k in keyof T]: T[k] }` maps an array `T` to an array.
+          name: 'A homomorphic mapped type in an intersection is not merged',
+          source: dedent`
+            type X<T> = Readonly<{ [k in keyof T]: T[k] }> & Readonly<{ b: string }>;
+          `,
+          expected: dedent`
+            type X<T> = Readonly<{ [k in keyof T]: T[k] }> & Readonly<{ b: string }>;
+          `,
+        },
+        {
+          name: 'A union of Readonly aliases is still merged',
+          source: dedent`
+            type X<A, B> = Readonly<A> | Readonly<B>;
+          `,
+          expected: dedent`
+            type X<A, B> = Readonly<A | B>;
+          `,
+        },
+      ].flatMap((c) => [
+        c,
+        // The output is a fixed point: running the codemod again keeps it,
+        // readonly-ness included.
+        { ...c, name: `${c.name} (fixed point)`, source: c.expected },
+      ]),
+    )('$name', testFn);
+
+    // What merging `Readonly` members relies on.
+    test('premises of merging Readonly members', () => {
+      type X = { x: number };
+
+      // `Readonly` distributes over `|`, so merging a union is safe.
+      expectType<Readonly<string[] | X>, readonly string[] | Readonly<X>>('=');
+
+      // It does not over `&` with an array member: the merged form leaves the
+      // array mutable.
+      expectType<Readonly<string[] & X>, readonly string[] & Readonly<X>>('<=');
+
+      expectType<Readonly<string[] & X>, readonly string[] & Readonly<X>>('!=');
+    });
+  });
+
+  describe('Comments in front of a member', () => {
+    // `replaceWithText` overwrites a node from `getStart()`, so a comment in
+    // front of it stays where it is. Text built for the replacement must carry
+    // the comments after that point — those in front of each member and those
+    // in front of the `|` / `&` separating them — and none before it.
+    test.each([
+      {
+        name: 'JSDoc on each member of a union with a leading `|`',
+        source: dedent`
+          export type ProbeStore =
+            /** Kept until the browser is closed. */
+            | 'session'
+            /** Kept until it is forgotten. */
+            | 'device';
+        `,
+        // Prettier itself moves the second comment to the end of the line
+        // before it; here it stays in front of its member.
+        expected: dedent`
+          export type ProbeStore =
+            | /** Kept until the browser is closed. */ 'session'
+            | /** Kept until it is forgotten. */ 'device';
+        `,
+      },
+      {
+        name: 'Line comments on each member of a union with a leading `|`',
+        source: dedent`
+          type T =
+            // first
+            | 'a'
+            // second
+            | 'b'
+            // third
+            | 'c';
+        `,
+        expected: dedent`
+          type T =
+            // first
+            | 'a'
+            // second
+            | 'b'
+            // third
+            | 'c';
+        `,
+      },
+      {
+        name: 'Comments on each member of a union without a leading `|`',
+        source: dedent`
+          type T = /** a */ 'a' | /** b */ 'b';
+        `,
+        expected: dedent`
+          type T = /** a */ 'a' | /** b */ 'b';
+        `,
+      },
+      {
+        name: 'A comment after `|` stays with the member after it',
+        source: dedent`
+          type T = 'a' | // about b
+            'b';
+        `,
+        expected: dedent`
+          type T = 'a' | // about b
+            'b';
+        `,
+      },
+      ...toUnionAndIntersectionTestCase({
+        title: (op) => `Comments on members of an ${op} that are converted`,
+        testCase: (op) => ({
+          source: dedent`
+            type T =
+              /** list */
+              ${op} number[]
+              /** object */
+              ${op} { a: number[] };
+          `,
+          // The comment on the object moves inside the `Readonly` around it.
+          expected: dedent`
+            type T =
+              /** list */
+              ${op} readonly number[]
+              ${op} Readonly</** object */ { a: readonly number[] }>;
+          `,
+        }),
+      }),
+      ...toUnionAndIntersectionTestCase({
+        title: (op) =>
+          `Comments on Readonly members of an ${op} that are merged`,
+        testCase: (op) => ({
+          source: dedent`
+            type T = /** a */ Readonly<{ a: number }> ${op} /** b */ Readonly<{ b: number }>;
+          `,
+          expected: dedent`
+            type T = /** a */ Readonly<{ a: number } ${op} /** b */ { b: number }>;
+          `,
+        }),
+      }),
+      {
+        name: 'Comments on DeepReadonly members that are merged',
+        source: dedent`
+          type T = /** a */ DeepReadonly<{ a: number[] }> | /** b */ DeepReadonly<{ b: string[] }>;
+        `,
+        expected: dedent`
+          type T = /** a */ DeepReadonly<{ a: number[] } | /** b */ { b: string[] }>;
+        `,
+      },
+      {
+        name: 'A comment in front of a union inside parentheses',
+        source: dedent`
+          type T = (/** a */ 'a' | 'b')[];
+        `,
+        expected: dedent`
+          type T = /** a */ readonly ('a' | 'b')[];
+        `,
+      },
+      {
+        name: 'Comments around parentheses that Readonly<T> unwraps',
+        source: dedent`
+          type T = Readonly</** a */ (/** b */ number[])>;
+        `,
+        expected: dedent`
+          type T = /** a */ /** b */ readonly number[];
+        `,
+      },
+      {
+        name: 'Comments around parentheses in a rest element',
+        source: dedent`
+          type T = [string, ...(/** a */ readonly number[])];
+        `,
+        expected: dedent`
+          type T = readonly [string, .../** a */ number[]];
+        `,
+      },
+      {
+        name: 'A comment in front of an array type',
+        source: dedent`
+          type T = /** c */ number[];
+        `,
+        expected: dedent`
+          type T = /** c */ readonly number[];
+        `,
+      },
+      {
+        name: 'A comment in front of a tuple type',
+        source: dedent`
+          type T = /** c */ [number, string];
+        `,
+        expected: dedent`
+          type T = /** c */ readonly [number, string];
+        `,
+      },
+      {
+        name: 'A comment in front of a type literal',
+        source: dedent`
+          type T = /** c */ { a: number };
+        `,
+        expected: dedent`
+          type T = /** c */ Readonly<{ a: number }>;
+        `,
+      },
+    ])('$name', testFn);
+  });
+
   describe('Parenthesized types', () => {
     test.each([
       {
@@ -3877,7 +4251,7 @@ describe(convertToReadonlyTransformer, () => {
           type /* Block Comment */ WithComments = Readonly<{
             prop1: readonly string[]; // Trailing comment
             /* Another block */
-            prop2: /* member type comment */ readonly /* member type inner comment */ number[];
+            prop2: /* member type comment */ /* member type inner comment */ readonly number[];
             /* End block */
           }>;
         `,
@@ -4678,11 +5052,10 @@ const toUnionAndIntersectionTestCase = ({
 
 describe('idempotency', () => {
   test('a union whose members carry leading whitespace reaches a fixed point', () => {
-    // The members are read with `getFullText()`, which includes the whitespace
-    // in front of each one, and joined with a separator that adds its own. Left
-    // alone the two compound, and a file with `// prettier-ignore` on a long
-    // union grows by one space per member on every run — nothing downstream
-    // normalizes it back.
+    // Whitespace in front of a member, joined with a separator that adds its
+    // own, compounds when left alone, and a file with `// prettier-ignore` on a
+    // long union grows by one space per member on every run — nothing
+    // downstream normalizes it back.
     const code = [
       '// prettier-ignore',
       'export type P = ',
@@ -4700,4 +5073,45 @@ describe('idempotency', () => {
 
     expect(twice).toBe(once);
   });
+
+  test('comments on union members survive rounds of the codemod and Prettier', async () => {
+    // `fix:codemod` runs the codemod and then Prettier, which takes off the
+    // parentheses the codemod puts around a union, so every run starts again
+    // from the unparenthesized form. A comment lost in one round or copied in
+    // the next shows up only across several of them.
+    const code = dedent`
+      export type ProbeStore =
+        /** Kept until the browser is closed. */
+        | 'session'
+        /** Kept until it is forgotten. */
+        | 'device';
+    `;
+
+    const round = async (src: string): Promise<string> =>
+      prettier.format(
+        transformSourceCode(src, false, [convertToReadonlyTransformer()]),
+        {
+          parser: 'typescript',
+          plugins: [prettierPluginTypeScript, prettierPluginEstree],
+        },
+      );
+
+    const round1 = await round(code);
+
+    const round2 = await round(round1);
+
+    const round3 = await round(round2);
+
+    expect(round1).toBe(
+      `${dedent`
+        export type ProbeStore =
+          /** Kept until the browser is closed. */
+          "session" | /** Kept until it is forgotten. */ "device";
+      `}\n`,
+    );
+
+    expect(round2).toBe(round1);
+
+    expect(round3).toBe(round1);
+  });
 });

package/src/functions/ast-transformers/enable-no-unchecked-indexed-access.mts

@@ -1,8 +1,8 @@
 import { Arr } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
-import { type DeepReadonly } from 'ts-type-forge';
+import type { DeepReadonly } from 'ts-type-forge';
 import { hasDisableNextLineComment } from '../functions/index.mjs';
-import { type TsMorphTransformer } from './types.mjs';
+import type { TsMorphTransformer } from './types.mjs';
 
 const TRANSFORMER_NAME = 'enable-no-unchecked-indexed-access';
 
@@ -280,27 +280,49 @@ const isIgnoredByComment = (
  * the target of an assignment the element type without `undefined`, so the
  * type comparison in {@link collectAssertionPositions} already passes them
  * over. The exceptions handled here are the ones it does widen.
+ *
+ * The position is that of the outermost parenthesis around the access:
+ * `(xs[0]) === undefined` tests the value exactly as `xs[0] === undefined`
+ * does, while the `!` still goes right after the access, inside them.
  */
 const isAssertableReadPosition = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   node: IndexReadExpression,
 ): boolean => {
-  const parent = node.getParent();
+  const outer = outermostParenthesized(node);
+
+  const parent = outer.getParent();
 
   if (parent === undefined) {
     return false;
   }
 
   return (
-    !isAlreadyAssertedOrGuarded(node, parent) &&
-    !isWriteTarget(node, parent) &&
-    !isTestedForAbsence(node, parent)
+    !isAlreadyAssertedOrGuarded(node, outer, parent) &&
+    !isWriteTarget(outer, parent) &&
+    !isTestedForAbsence(outer, parent)
   );
 };
 
-/** `xs[0]!`, `xs[0] as T`, `<T>xs[0]`, `xs[0]?.foo`, `xs[0]?.()`, `xs[0]?.[1]`. */
+/** `node`, or the outermost of the parentheses written around it. */
+const outermostParenthesized = (node: tsm.Node): tsm.Node => {
+  const parent = node.getParent();
+
+  return parent?.isKind(tsm.SyntaxKind.ParenthesizedExpression) === true
+    ? outermostParenthesized(parent)
+    : node;
+};
+
+/**
+ * `xs[0]!`, `xs[0] as T`, `<T>xs[0]`, `xs[0]?.foo`, `xs[0]?.()`, `xs[0]?.[1]`.
+ *
+ * `outer` is `node` with its parentheses (see
+ * {@link outermostParenthesized}); a chain continues from the access itself
+ * but is guarded from the outside of the parentheses (`(xs[0])?.foo`).
+ */
 const isAlreadyAssertedOrGuarded = (
   node: tsm.Node,
+  outer: tsm.Node,
   parent: tsm.Node,
 ): boolean => {
   if (
@@ -322,7 +344,7 @@ const isAlreadyAssertedOrGuarded = (
       parent.isKind(tsm.SyntaxKind.ElementAccessExpression) ||
       parent.isKind(tsm.SyntaxKind.CallExpression)) &&
     parent.hasQuestionDotToken() &&
-    parent.getExpression() === node
+    parent.getExpression() === outer
   );
 };
 

package/src/functions/ast-transformers/enable-no-unchecked-indexed-access.test.mts

@@ -391,6 +391,96 @@ describe(enableNoUncheckedIndexedAccessTransformer, () => {
     ])('$name', testFn);
   });
 
+  describe('positions judged through parentheses and type wrappers', () => {
+    test.each([
+      {
+        name: 'a parenthesized read is still asserted',
+        source: 'console.log((xs[0]).toFixed());',
+        expected: 'console.log((xs[0]!).toFixed());',
+      },
+      {
+        name: 'parenthesized equality against undefined',
+        source: 'console.log((xs[0]) === undefined);',
+        expected: 'console.log((xs[0]) === undefined);',
+      },
+      {
+        name: 'parenthesized nullish coalescing',
+        source: 'console.log((xs[0]) ?? 0);',
+        expected: 'console.log((xs[0]) ?? 0);',
+      },
+      {
+        name: 'parenthesized optional property access',
+        source: 'console.log((xs[0])?.toFixed());',
+        expected: 'console.log((xs[0])?.toFixed());',
+      },
+      {
+        name: 'parenthesized if condition',
+        source: 'if ((xs[0])) { console.log(1); }',
+        expected: 'if ((xs[0])) { console.log(1); }',
+      },
+      {
+        name: 'parenthesized typeof operand',
+        source: 'console.log(typeof (xs[0]));',
+        expected: 'console.log(typeof (xs[0]));',
+      },
+      {
+        name: 'parenthesized negation operand',
+        source: 'console.log(!((xs[0])));',
+        expected: 'console.log(!((xs[0])));',
+      },
+      {
+        name: 'parenthesized existing non-null assertion',
+        source: 'console.log((xs[0])!.toFixed());',
+        expected: 'console.log((xs[0])!.toFixed());',
+      },
+      {
+        name: 'parenthesized type assertion',
+        source: 'console.log(((xs[0]) as number).toFixed());',
+        expected: 'console.log(((xs[0]) as number).toFixed());',
+      },
+      {
+        name: 'satisfies a type without undefined, which needs the assertion',
+        source: 'console.log(xs[0] satisfies number);',
+        expected: 'console.log(xs[0]! satisfies number);',
+      },
+      {
+        name: 'parenthesized satisfies a type without undefined',
+        source: 'console.log((xs[0]) satisfies number);',
+        expected: 'console.log((xs[0]!) satisfies number);',
+      },
+      {
+        name: 'satisfies a type with undefined, where the assertion is harmless',
+        source: 'console.log(xs[0] satisfies number | undefined);',
+        expected: 'console.log(xs[0]! satisfies number | undefined);',
+      },
+      {
+        name: 'parenthesized satisfies a type with undefined',
+        source: 'console.log((xs[0]) satisfies number | undefined);',
+        expected: 'console.log((xs[0]!) satisfies number | undefined);',
+      },
+      {
+        name: 'parenthesized compound assignment target',
+        source: '(mut_ys[0]) += 1;',
+        expected: '(mut_ys[0]) += 1;',
+      },
+      {
+        name: 'parenthesized assignment target',
+        source: '(mut_ys[0]) = 1;',
+        expected: '(mut_ys[0]) = 1;',
+      },
+      {
+        name: 'parenthesized delete target',
+        source: "delete (rec['a']);",
+        expected: "delete (rec['a']);",
+      },
+      {
+        name: 'parenthesized for-of loop target',
+        source: 'for ((mut_ys[0]) of xs) { break; }',
+        expected: 'for ((mut_ys[0]) of xs) { break; }',
+      },
+    ])('$name', testFn);
+  });
+
   describe('applyLevel: "avoidWhereUndefinedIsAllowed"', () => {
     test.each([
       {
@@ -541,6 +631,27 @@ describe(enableNoUncheckedIndexedAccessTransformer, () => {
     );
   });
 
+  test('an access under `satisfies` or in parentheses compiles once transformed', () => {
+    const source = dedent`
+      declare const xs: readonly number[];
+
+      export const a = xs[0] satisfies number;
+
+      export const b = (xs[0]) satisfies number;
+
+      export const c = (xs[0]).toFixed();
+
+      export const d = (xs[0]) === undefined ? 0 : (xs[0]) ?? 1;
+    `;
+
+    expect(diagnosticsUnderTheOption(source).length).toBeGreaterThan(0);
+
+    assert.deepStrictEqual(
+      diagnosticsUnderTheOption(transformInProject(source)),
+      [],
+    );
+  });
+
   test('array destructuring is left alone, since `!` has nowhere to go there', () => {
     const source = dedent`
       declare const xs: readonly number[];

package/src/functions/ast-transformers/readonly-transformer-helpers/compare-union-types.mts

@@ -1,5 +1,5 @@
 import * as tsm from 'ts-morph';
-import { type DeepReadonly } from 'ts-type-forge';
+import type { DeepReadonly } from 'ts-type-forge';
 import {
   isAtomicTypeNode,
   isReadonlyTupleOrArrayTypeNode,