ts-codemod-lib 3.5.0 → 4.0.0

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

@@ -1980,6 +1980,7 @@ describe(convertToReadonlyTransformer, () => {
               }
             }
           `,
+          options: { mutablePropertyPrefixes: ['_mut_'] },
         },
         {
           name: 'Method with "draft" prefix',
@@ -1997,6 +1998,7 @@ describe(convertToReadonlyTransformer, () => {
               }
             }
           `,
+          options: { mutablePropertyPrefixes: ['draft'] },
         },
         {
           name: 'Method without mut_ prefix should be transformed',
@@ -3926,6 +3928,418 @@ describe(convertToReadonlyTransformer, () => {
     ])('$name', testFn);
   });
 
+  describe('Type literals with a property of an ignored prefix', () => {
+    // `Readonly<T>` would make the ignored property readonly too, so such a
+    // literal is left unwrapped and its other members are marked readonly in
+    // place, as an interface's are.
+    test.each([
+      {
+        name: 'Members other than the ignored one are marked readonly in place',
+        source: dedent`
+          type T = { mut_a: number[]; b: string[]; readonly c: number };
+        `,
+        expected: dedent`
+          type T = { mut_a: number[]; readonly b: readonly string[]; readonly c: number };
+        `,
+      },
+      {
+        name: 'An ignored property already marked readonly is left as written',
+        source: dedent`
+          type T = { readonly mut_a: number[]; b: string[] };
+        `,
+        expected: dedent`
+          type T = { readonly mut_a: number[]; readonly b: readonly string[] };
+        `,
+      },
+      {
+        name: 'A string literal name or a computed name of a literal is recognized',
+        source: dedent`
+          type T = { "mut_a": number[]; ['mut_b']: number[]; [\`mut_c\`]: number[]; d: string[] };
+        `,
+        expected: dedent`
+          type T = { "mut_a": number[]; ['mut_b']: number[]; [\`mut_c\`]: number[]; readonly d: readonly string[] };
+        `,
+      },
+      {
+        name: 'An index signature alongside is marked readonly in place',
+        source: dedent`
+          type T = { mut_a: number[]; [key: string]: unknown };
+        `,
+        expected: dedent`
+          type T = { mut_a: number[]; readonly [key: string]: unknown };
+        `,
+      },
+      {
+        name: 'Every configured prefix is recognized',
+        source: dedent`
+          type T = { draftItems: number[]; b: string[] };
+          type U = { mutable_items: number[]; b: string[] };
+        `,
+        expected: dedent`
+          type T = { draftItems: number[]; readonly b: readonly string[] };
+          type U = { mutable_items: number[]; readonly b: readonly string[] };
+        `,
+        options: {
+          mutableVariablePrefixes: ['draft', 'mutable_'],
+          mutablePropertyPrefixes: ['draft', 'mutable_'],
+        },
+      },
+      {
+        name: '"mut_" alone is the default: it covers "#mut_" and no longer "_mut_"',
+        source: dedent`
+          type T = { _mut_items: number[]; b: string[] };
+          class C { #mut_items: number[] = []; c: string[] = []; }
+        `,
+        expected: dedent`
+          type T = Readonly<{ _mut_items: readonly number[]; b: readonly string[] }>;
+          class C { #mut_items: number[] = []; readonly c: readonly string[] = []; }
+        `,
+      },
+      {
+        name: 'Ancestors are wrapped with the shallow Readonly only',
+        source: dedent`
+          type T = {
+            a: {
+              b: {
+                mut_c: number[];
+                d: string[];
+              };
+            };
+          };
+        `,
+        expected: dedent`
+          type T = Readonly<{
+            a: Readonly<{
+              b: {
+                mut_c: number[];
+                readonly d: readonly string[];
+              };
+            }>;
+          }>;
+        `,
+      },
+      {
+        name: 'Nested in an interface',
+        source: dedent`
+          interface I {
+            a: { mut_b: number[]; c: string[] };
+          }
+        `,
+        expected: dedent`
+          interface I {
+            readonly a: { mut_b: number[]; readonly c: readonly string[] };
+          }
+        `,
+      },
+      {
+        name: 'As an array element',
+        source: dedent`
+          type T = { mut_a: number[] }[];
+        `,
+        expected: dedent`
+          type T = readonly { mut_a: number[] }[];
+        `,
+      },
+      {
+        name: 'In a union, it is not merged into the Readonly of the others',
+        source: dedent`
+          type T = { mut_a: number[]; b: string } | { c: number[] } | { d: string };
+        `,
+        expected: dedent`
+          type T = { mut_a: number[]; readonly b: string } | Readonly<{ c: readonly number[] } | { d: string }>;
+        `,
+      },
+      {
+        name: 'In an intersection, it is not merged into the Readonly of the others',
+        source: dedent`
+          type T = { mut_a: number[]; b: string } & { c: number[] };
+        `,
+        expected: dedent`
+          type T = { mut_a: number[]; readonly b: string } & Readonly<{ c: readonly number[] }>;
+        `,
+      },
+      {
+        name: 'In an intersection under Readonly, it is taken out',
+        source: dedent`
+          type T = Readonly<{ mut_a: number[]; b: string } & { c: string }>;
+        `,
+        expected: dedent`
+          type T = { mut_a: number[]; readonly b: string } & Readonly<{ c: string }>;
+        `,
+      },
+      {
+        // Such a `Readonly` is also what earlier versions wrote.
+        name: 'A Readonly written around it is taken off',
+        source: dedent`
+          type T = Readonly<{ mut_a: number[]; b: string[] }>;
+        `,
+        expected: dedent`
+          type T = { mut_a: number[]; readonly b: readonly string[] };
+        `,
+      },
+      {
+        name: 'Nested Readonly written around it are taken off',
+        source: dedent`
+          type T = Readonly<Readonly<{ mut_a: number[]; b: string }>>;
+        `,
+        expected: dedent`
+          type T = { mut_a: number[]; readonly b: string };
+        `,
+      },
+      {
+        name: 'A Readonly written around it in a union is taken off',
+        source: dedent`
+          type T = Readonly<{ mut_a: number[]; b: string }> | { c: string };
+        `,
+        expected: dedent`
+          type T = { mut_a: number[]; readonly b: string } | Readonly<{ c: string }>;
+        `,
+      },
+      {
+        name: 'A Readonly written around it under a Readonly union is taken off',
+        source: dedent`
+          type T = Readonly<Readonly<{ mut_a: number[] }> | { c: string }>;
+        `,
+        expected: dedent`
+          type T = { mut_a: number[] } | Readonly<{ c: string }>;
+        `,
+      },
+      {
+        // That member gets no `readonly` of its own, so the wrapper stays.
+        name: 'A member skipped by the ignore comment keeps the Readonly',
+        source: dedent`
+          type T = Readonly<{
+            // transformer-ignore-next-line
+            b: string[];
+            mut_a: number[];
+          }>;
+        `,
+        expected: dedent`
+          type T = Readonly<{
+            // transformer-ignore-next-line
+            b: string[];
+            mut_a: number[];
+          }>;
+        `,
+      },
+      {
+        name: 'A literal skipped by the ignore comment keeps the Readonly',
+        source: dedent`
+          type T = Readonly<
+            // transformer-ignore-next-line
+            { mut_a: number[]; b: string[] }
+          >;
+        `,
+        expected: dedent`
+          type T = Readonly<
+            // transformer-ignore-next-line
+            { mut_a: number[]; b: string[] }
+          >;
+        `,
+      },
+      {
+        name: 'A literal skipped by the ignore comment in an intersection under Readonly stays under it',
+        source: dedent`
+          type T = Readonly<
+            { c: string } &
+            // transformer-ignore-next-line
+            { mut_a: number[]; b: string[] }
+          >;
+        `,
+        expected: dedent`
+          type T = Readonly<
+            { c: string } &
+            // transformer-ignore-next-line
+            { mut_a: number[]; b: string[] }
+          >;
+        `,
+      },
+      {
+        name: 'An ignored property skipped by the ignore comment does not keep the Readonly',
+        source: dedent`
+          type T = {
+            // transformer-ignore-next-line
+            mut_a: number[];
+            b: string[];
+          };
+        `,
+        expected: dedent`
+          type T = {
+            // transformer-ignore-next-line
+            mut_a: number[];
+            readonly b: readonly string[];
+          };
+        `,
+      },
+      {
+        // `Readonly` is what makes a method or an accessor readonly, and
+        // neither takes a `readonly` modifier.
+        name: 'A literal with a method signature or an accessor is wrapped as before',
+        source: dedent`
+          type T = { mut_a: number[]; f(): void; b: string[] };
+          type U = Readonly<{ mut_a: number[]; get g(): string; set g(v: string) }>;
+        `,
+        expected: dedent`
+          type T = Readonly<{ mut_a: number[]; f(): void; b: readonly string[] }>;
+          type U = Readonly<{ mut_a: number[]; get g(): string; set g(v: string) }>;
+        `,
+      },
+      {
+        // `Readonly<A> & { ... }` would make an array `A` readonly.
+        name: 'In an intersection under Readonly beside a type that may be an array, it stays under it',
+        source: dedent`
+          type T<A> = Readonly<A & { mut_a: number[]; b: string }>;
+        `,
+        expected: dedent`
+          type T<A> = Readonly<A & { mut_a: number[]; readonly b: string }>;
+        `,
+      },
+      {
+        name: 'In an intersection under Readonly beside a primitive, it is taken out',
+        source: dedent`
+          type T = Readonly<string & { mut_a: number[]; b: string }>;
+        `,
+        expected: dedent`
+          type T = string & { mut_a: number[]; readonly b: string };
+        `,
+      },
+      {
+        name: 'An accessor or a method of an ignored prefix is left as written',
+        source: dedent`
+          type T = { get mut_x(): number[]; set mut_x(v: number[]); mut_f(a: string[]): void; b: string[] };
+        `,
+        expected: dedent`
+          type T = { get mut_x(): number[]; set mut_x(v: number[]); mut_f(a: string[]): void; readonly b: readonly string[] };
+        `,
+      },
+      {
+        name: 'A comment after the literal is kept when the Readonly is taken off',
+        source: dedent`
+          type T = Readonly<{ mut_a: number[]; b: string } /* note */>;
+          type U = Readonly<{ mut_a: number[] } // note
+          >[];
+        `,
+        expected: dedent`
+          type T = /* note */ { mut_a: number[]; readonly b: string };
+          type U =
+            // note
+            readonly { mut_a: number[] }[];
+        `,
+      },
+      {
+        name: 'A Readonly written around a single-member union of a literal with a call signature is kept',
+        source: dedent`
+          type T = Readonly<| { (): void; mut_a: number[] }>;
+        `,
+        expected: dedent`
+          type T = Readonly<{ (): void; mut_a: number[] }>;
+        `,
+      },
+      {
+        name: 'A Readonly written around a literal with a call signature is kept',
+        source: dedent`
+          type T = Readonly<{ (): void; mut_a: number[]; b: string }>;
+        `,
+        expected: dedent`
+          type T = Readonly<{ (): void; mut_a: number[]; b: string }>;
+        `,
+      },
+      {
+        name: 'A member that needs no wrapper does not keep the Readonly',
+        source: dedent`
+          type T = {
+            mut_a: number[];
+            mut_f(): void;
+            // transformer-ignore-next-line
+            readonly b: string;
+          };
+        `,
+        expected: dedent`
+          type T = {
+            mut_a: number[];
+            mut_f(): void;
+            // transformer-ignore-next-line
+            readonly b: string;
+          };
+        `,
+      },
+      {
+        name: 'A Readonly written around it under an indexed access is taken off',
+        source: dedent`
+          type T = Readonly<{ mut_a: number[]; b: string[] }>['b'];
+        `,
+        expected: dedent`
+          type T = { mut_a: number[]; b: readonly string[] }['b'];
+        `,
+      },
+      {
+        name: 'A DeepReadonly written explicitly is kept',
+        source: dedent`
+          type T = DeepReadonly<{ a: { mut_b: number[]; c: string[] } }>;
+        `,
+        expected: dedent`
+          type T = DeepReadonly<{ a: { mut_b: number[]; c: string[] } }>;
+        `,
+      },
+      {
+        name: 'Under an indexed access',
+        source: dedent`
+          type T = { mut_a: number[]; b: string[] }['b'];
+        `,
+        expected: dedent`
+          type T = { mut_a: number[]; b: readonly string[] }['b'];
+        `,
+      },
+      {
+        name: 'Without the prefix configured, the literal is wrapped',
+        source: dedent`
+          type T = { mut_a: number[]; b: string[] };
+        `,
+        expected: dedent`
+          type T = Readonly<{ mut_a: readonly number[]; b: readonly string[] }>;
+        `,
+        options: { mutableVariablePrefixes: [], mutablePropertyPrefixes: [] },
+      },
+    ])('$name', testFn);
+
+    test.each([
+      dedent`
+        type T = {
+          a: { mut_b: number[]; c: string[] } | { d: number[] };
+          mut_e: { f: string[] };
+        };
+      `,
+      'type T = Readonly<{ mut_a: number[]; b: string }> | { c: string };',
+      'type T = Readonly<{ mut_a: number[]; b: string }> & { c: string };',
+      'type T = Readonly<{ mut_a: number[] }> | Readonly<{ c: string }>;',
+      'type T = Readonly<Readonly<{ mut_a: number[] }> | { c: string }>;',
+      'type T = Readonly<{ mut_a: number[]; b: string } & { c: string }>;',
+      'type T = { a: string } | { mut_b: number[] } | { c: string };',
+      'type T<A> = Readonly<A & { mut_a: number[]; b: string }>;',
+      'type T = Readonly<string & { mut_a: number[]; b: string }>;',
+      'type T = Readonly<string[] & { mut_a: number[]; b: string }>;',
+      'type T = Readonly<(() => void) & { mut_a: number[]; b: string }>;',
+      'type T = Readonly<{ mut_a: number[] } & { c: string } & string>;',
+      'type T = Readonly<{ mut_a: number[]; b: string } /* note */>;',
+      'type T = Readonly<{ mut_a: number[] } // note\n>[];',
+      'type T = Readonly<{ mut_a: number[] } /* c */> | { d: string };',
+      'type T = Readonly<\n  // transformer-ignore-next-line\n  { mut_a: number[]; b: string[] }\n>;',
+    ])(
+      'a type literal with an ignored property reaches a fixed point: %s',
+      (code) => {
+        const once = transformSourceCode(code, false, [
+          convertToReadonlyTransformer(),
+        ]);
+
+        const twice = transformSourceCode(once, false, [
+          convertToReadonlyTransformer(),
+        ]);
+
+        expect(twice).toBe(once);
+      },
+    );
+  });
+
   describe('Call and construct signatures', () => {
     // `Readonly<T>` is a mapped type over `keyof T`, and a call or construct
     // signature is not a property, so wrapping a type literal that carries one
@@ -4442,7 +4856,7 @@ describe(convertToReadonlyTransformer, () => {
     ])('$name', testFn);
   });
 
-  describe('ignorePrefixes option', () => {
+  describe('mutableVariablePrefixes and mutablePropertyPrefixes options', () => {
     test.each([
       {
         name: 'Variable declarations',
@@ -4465,10 +4879,10 @@ describe(convertToReadonlyTransformer, () => {
       {
         name: 'Type aliases',
         source: dedent`
-          type mut_Foo = number[]
+          type MutableFoo = number[]
         `,
         expected: dedent`
-          type mut_Foo = number[]
+          type MutableFoo = number[]
         `,
       },
       {
@@ -4477,12 +4891,15 @@ describe(convertToReadonlyTransformer, () => {
           type T = { mut_value: number[]; normalValue: string[] }
         `,
         expected: dedent`
-          type T = Readonly<{
+          type T = {
             mut_value: number[];
-            normalValue: readonly string[];
-          }>;
+            readonly normalValue: readonly string[];
+          };
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Multiple ignore prefixes',
@@ -4490,13 +4907,16 @@ describe(convertToReadonlyTransformer, () => {
           type T = { mut_value: number[]; mutable_data: string[]; normalValue: boolean[] };
         `,
         expected: dedent`
-          type T = Readonly<{
+          type T = {
             mut_value: number[];
             mutable_data: string[];
-            normalValue: readonly boolean[];
-          }>;
+            readonly normalValue: readonly boolean[];
+          };
         `,
-        options: { ignorePrefixes: ['mut_', 'mutable_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_', 'mutable_'],
+          mutablePropertyPrefixes: ['mut_', 'mutable_'],
+        },
       },
       {
         name: 'Ignore prefix in nested properties',
@@ -4510,13 +4930,16 @@ describe(convertToReadonlyTransformer, () => {
         `,
         expected: dedent`
           type T = Readonly<{
-            data: Readonly<{
+            data: {
               mut_items: number[];
-              items: readonly string[];
-            }>;
+              readonly items: readonly string[];
+            };
           }>;
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Ignore prefix in interface',
@@ -4532,7 +4955,10 @@ describe(convertToReadonlyTransformer, () => {
             readonly roles: readonly string[];
           }
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Ignore prefixes for various name node types in interface',
@@ -4554,7 +4980,10 @@ describe(convertToReadonlyTransformer, () => {
             readonly ['mu'  + 't_d']: readonly string[]; // ComputedPropertyName
           }
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Ignore prefix with index signature',
@@ -4566,13 +4995,16 @@ describe(convertToReadonlyTransformer, () => {
           };
         `,
         expected: dedent`
-          type T = Readonly<{
+          type T = {
             mut_items: {
               [key: string]: number[];
             };
-          }>;
+          };
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Index signature in ignored property',
@@ -4590,21 +5022,27 @@ describe(convertToReadonlyTransformer, () => {
             };
           }
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Type alias with ignored prefix',
         source: dedent`
-          type mut_Config = {
+          type MutableConfig = {
             items: string[];
           };
         `,
         expected: dedent`
-          type mut_Config = {
+          type MutableConfig = {
             items: string[];
           };
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Function with ignored prefix',
@@ -4614,21 +5052,27 @@ describe(convertToReadonlyTransformer, () => {
         expected: dedent`
           function mut_process(data: string[]): number[] { return []; }
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Class with ignored prefix',
         source: dedent`
-          class mut_Store {
+          class MutableStore {
             items: string[] = [];
           }
         `,
         expected: dedent`
-          class mut_Store {
+          class MutableStore {
             items: string[] = [];
           }
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Variable declaration with ignored prefix',
@@ -4638,37 +5082,46 @@ describe(convertToReadonlyTransformer, () => {
         expected: dedent`
           const mut_items: string[] = []
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Generic type with ignored prefix',
         source: dedent`
-          type mut_List<T> = {
+          type MutableList<T> = {
             items: T[]
           }
         `,
         expected: dedent`
-          type mut_List<T> = {
+          type MutableList<T> = {
             items: T[];
           };
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Union type with ignored prefix members',
         source: dedent`
-          type Result = mut_Success | Error;
-          type mut_Success = {
+          type Result = MutableSuccess | Error;
+          type MutableSuccess = {
             data: string[]
           };
         `,
         expected: dedent`
-          type Result = mut_Success | Error;
-          type mut_Success = {
+          type Result = MutableSuccess | Error;
+          type MutableSuccess = {
             data: string[];
           };
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Property with ignored prefix in class',
@@ -4684,7 +5137,10 @@ describe(convertToReadonlyTransformer, () => {
             readonly items: readonly number[] = [];
           }
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Method parameter with ignored prefix',
@@ -4698,7 +5154,10 @@ describe(convertToReadonlyTransformer, () => {
             process(mut_data: string[], data: readonly number[]) {}
           }
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Function expression with ignored prefix',
@@ -4708,7 +5167,10 @@ describe(convertToReadonlyTransformer, () => {
         expected: dedent`
           const fn = function mut_process(data: string[]): number[] { return []; }
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Array binding pattern in variable declaration (not implemented)',
@@ -4718,17 +5180,25 @@ describe(convertToReadonlyTransformer, () => {
         expected: dedent`
           const [mut_first, mut_second]: readonly [readonly string[], readonly number[]] = [[], []];
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
+        // The binding pattern itself is not looked at (see the TODO in
+        // `transformNode`); the type literal is left as is for its properties.
         name: 'Object binding pattern in variable declaration (not implemented)',
         source: dedent`
           const { mut_arr, mut_obj }: { mut_arr: string[], mut_obj: number[] } = { mut_arr: [], mut_obj: [] };
         `,
         expected: dedent`
-          const { mut_arr, mut_obj }: Readonly<{ mut_arr: string[], mut_obj: number[] }> = { mut_arr: [], mut_obj: [] };
+          const { mut_arr, mut_obj }: { mut_arr: string[], mut_obj: number[] } = { mut_arr: [], mut_obj: [] };
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Parameter with ignored prefix in class constructor',
@@ -4742,7 +5212,10 @@ describe(convertToReadonlyTransformer, () => {
             constructor(mut_config: string[]) {}
           }
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Parameter with ignored prefix in type literal method',
@@ -4756,7 +5229,10 @@ describe(convertToReadonlyTransformer, () => {
             process(mut_data: string[]): void;
           }>;
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Multiple parameters with ignored prefix',
@@ -4770,7 +5246,10 @@ describe(convertToReadonlyTransformer, () => {
             update(mut_id: string, mut_data: object[], data: readonly string[]): void;
           }
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Arrow function with ignored prefix parameters',
@@ -4780,18 +5259,228 @@ describe(convertToReadonlyTransformer, () => {
         expected: dedent`
           const handler = (mut_event: Event[], event: readonly CustomEvent[]) => {};
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
-        name: 'Arrow function parameters with "draft" prefix (default)',
+        name: '"draft" is not a default prefix',
         source: dedent`
           const handler = (draft: Event[], event: CustomEvent[]) => {};
+          type T = { draft: boolean; items: string[] };
+        `,
+        expected: dedent`
+          const handler = (draft: readonly Event[], event: readonly CustomEvent[]) => {};
+          type T = Readonly<{ draft: boolean; items: readonly string[] }>;
+        `,
+      },
+      {
+        name: '"Mutable" and "mut_" are the default type prefixes',
+        source: dedent`
+          type MutableFoo = { a: string[] };
+          interface MutableBar { a: string[] }
+          class MutableBaz { a: string[] = []; }
+          const Q = class MutableQ { a: string[] = []; };
+          type mut_Qux = { a: string[] };
+          type Foo = { a: MutableFoo[] };
         `,
         expected: dedent`
-          const handler = (draft: Event[], event: readonly CustomEvent[]) => {};
+          type MutableFoo = { a: string[] };
+          interface MutableBar { a: string[] }
+          class MutableBaz { a: string[] = []; }
+          const Q = class MutableQ { a: string[] = []; };
+          type mut_Qux = { a: string[] };
+          type Foo = Readonly<{ a: readonly MutableFoo[] }>;
         `,
       },
+      {
+        name: 'Variable and property prefixes are separate',
+        source: dedent`
+          const handler = (draft: Event[]) => {};
+          type T = { draft: boolean; items: string[] };
+        `,
+        expected: dedent`
+          const handler = (draft: Event[]) => {};
+          type T = Readonly<{ draft: boolean; items: readonly string[] }>;
+        `,
+        options: { mutableVariablePrefixes: ['draft'] },
+      },
+      {
+        name: 'Each kind of name is matched against its own list: variables',
+        source: dedent`
+          type mut_T = { a: string[] };
+          interface mut_I { a: string[] }
+          class mut_C { a: string[] = []; }
+          function mut_f(a: string[]): void {}
+          const mut_x: string[] = [];
+          type U = [mut_a: string[], b: string[]];
+          class D { #mut_p: string[] = []; 'mut_q': string[] = []; }
+          type V = { mut_r: string[]; s: string[] };
+          interface J { mut_a: string[]; f(mut_p: string[]): void }
+          type W = { mut_m(): string[]; b: string[] };
+          class E { mut_m(x: string[]): string[] { return []; } get mut_g(): string[] { return []; } }
+        `,
+        expected: dedent`
+          type mut_T = Readonly<{ a: readonly string[] }>;
+          interface mut_I { readonly a: readonly string[] }
+          class mut_C { readonly a: readonly string[] = []; }
+          function mut_f(a: string[]): void {}
+          const mut_x: string[] = [];
+          type U = readonly [mut_a: readonly string[], b: readonly string[]];
+          class D { readonly #mut_p: readonly string[] = []; readonly 'mut_q': readonly string[] = []; }
+          type V = Readonly<{ mut_r: readonly string[]; s: readonly string[] }>;
+          interface J { readonly mut_a: readonly string[]; f(mut_p: string[]): void }
+          type W = Readonly<{ mut_m(): readonly string[]; b: readonly string[] }>;
+          class E { mut_m(x: readonly string[]): readonly string[] { return []; } get mut_g(): readonly string[] { return []; } }
+        `,
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutableTypePrefixes: [],
+          mutablePropertyPrefixes: [],
+        },
+      },
+      {
+        name: 'Each kind of name is matched against its own list: types',
+        source: dedent`
+          type mut_T = { a: string[] };
+          interface mut_I { a: string[] }
+          class mut_C { a: string[] = []; }
+          function mut_f(a: string[]): void {}
+          const mut_x: string[] = [];
+          type U = [mut_a: string[], b: string[]];
+          class D { #mut_p: string[] = []; 'mut_q': string[] = []; }
+          type V = { mut_r: string[]; s: string[] };
+          interface J { mut_a: string[]; f(mut_p: string[]): void }
+          type W = { mut_m(): string[]; b: string[] };
+          class E { mut_m(x: string[]): string[] { return []; } get mut_g(): string[] { return []; } }
+        `,
+        expected: dedent`
+          type mut_T = { a: string[] };
+          interface mut_I { a: string[] }
+          class mut_C { a: string[] = []; }
+          function mut_f(a: readonly string[]): void {}
+          const mut_x: readonly string[] = [];
+          type U = readonly [mut_a: readonly string[], b: readonly string[]];
+          class D { readonly #mut_p: readonly string[] = []; readonly 'mut_q': readonly string[] = []; }
+          type V = Readonly<{ mut_r: readonly string[]; s: readonly string[] }>;
+          interface J { readonly mut_a: readonly string[]; f(mut_p: readonly string[]): void }
+          type W = Readonly<{ mut_m(): readonly string[]; b: readonly string[] }>;
+          class E { mut_m(x: readonly string[]): readonly string[] { return []; } get mut_g(): readonly string[] { return []; } }
+        `,
+        options: {
+          mutableVariablePrefixes: [],
+          mutableTypePrefixes: ['mut_'],
+          mutablePropertyPrefixes: [],
+        },
+      },
+      {
+        name: 'Each kind of name is matched against its own list: properties',
+        source: dedent`
+          type mut_T = { a: string[] };
+          interface mut_I { a: string[] }
+          class mut_C { a: string[] = []; }
+          function mut_f(a: string[]): void {}
+          const mut_x: string[] = [];
+          type U = [mut_a: string[], b: string[]];
+          class D { #mut_p: string[] = []; 'mut_q': string[] = []; }
+          type V = { mut_r: string[]; s: string[] };
+          interface J { mut_a: string[]; f(mut_p: string[]): void }
+          type W = { mut_m(): string[]; b: string[] };
+          class E { mut_m(x: string[]): string[] { return []; } get mut_g(): string[] { return []; } }
+        `,
+        expected: dedent`
+          type mut_T = Readonly<{ a: readonly string[] }>;
+          interface mut_I { readonly a: readonly string[] }
+          class mut_C { readonly a: readonly string[] = []; }
+          function mut_f(a: readonly string[]): void {}
+          const mut_x: readonly string[] = [];
+          type U = readonly [mut_a: string[], b: readonly string[]];
+          class D { #mut_p: string[] = []; 'mut_q': string[] = []; }
+          type V = { mut_r: string[]; readonly s: readonly string[] };
+          interface J { mut_a: string[]; f(mut_p: readonly string[]): void }
+          type W = { mut_m(): string[]; readonly b: readonly string[] };
+          class E { mut_m(x: string[]): string[] { return []; } get mut_g(): string[] { return []; } }
+        `,
+        options: {
+          mutableVariablePrefixes: [],
+          mutableTypePrefixes: [],
+          mutablePropertyPrefixes: ['mut_'],
+        },
+      },
+      {
+        name: 'A property prefix with a "#" covers private names only',
+        source: dedent`
+          class C { #mut_a: string[] = []; mut_b: string[] = []; }
+        `,
+        expected: dedent`
+          class C { #mut_a: string[] = []; readonly mut_b: readonly string[] = []; }
+        `,
+        options: { mutablePropertyPrefixes: ['#mut_'] },
+      },
+      {
+        name: 'A property prefix does not apply to variables',
+        source: dedent`
+          const handler = (draft: Event[]) => {};
+          type T = { draft: boolean; items: string[] };
+        `,
+        expected: dedent`
+          const handler = (draft: readonly Event[]) => {};
+          type T = { draft: boolean; readonly items: readonly string[] };
+        `,
+        options: { mutablePropertyPrefixes: ['draft'] },
+      },
+      {
+        name: 'A constructor parameter property is a property',
+        source: dedent`
+          class C {
+            draftA: string[] = [];
+            constructor(private draftB: string[], readonly draftD: string[], draftC: string[]) {}
+          }
+        `,
+        expected: dedent`
+          class C {
+            draftA: string[] = [];
+            constructor(private draftB: string[], readonly draftD: string[], draftC: readonly string[]) {}
+          }
+        `,
+        options: { mutablePropertyPrefixes: ['draft'] },
+      },
+      {
+        name: 'A constructor parameter that is not a property is a variable',
+        source: dedent`
+          class C {
+            draftA: string[] = [];
+            constructor(private draftB: string[], draftC: string[]) {}
+          }
+        `,
+        expected: dedent`
+          class C {
+            readonly draftA: readonly string[] = [];
+            constructor(private readonly draftB: readonly string[], draftC: string[]) {}
+          }
+        `,
+        options: { mutableVariablePrefixes: ['draft'] },
+      },
     ])('$name', testFn);
+
+    test('the removed ignorePrefixes option is refused', () => {
+      expect(() =>
+        convertToReadonlyTransformer(
+          // @ts-expect-error removed in 4.0.0
+          { ignorePrefixes: ['mut_'] },
+        ),
+      ).toThrow('mutableVariablePrefixes');
+    });
+
+    test('an unset ignorePrefixes option is accepted', () => {
+      expect(() =>
+        convertToReadonlyTransformer(
+          // @ts-expect-error removed in 4.0.0
+          { ignorePrefixes: undefined },
+        ),
+      ).not.toThrow();
+    });
   });
 
   describe('Disable comment handling', () => {