ts-codemod-lib 3.5.1 → 4.0.1

package/src/functions/ast-transformers/append-as-const.test.mts

@@ -8,6 +8,12 @@ import * as prettier from 'prettier/standalone';
 import { appendAsConstTransformer } from './append-as-const.mjs';
 import { transformSourceCode } from './transform-source-code.mjs';
 
+const formatter = (code: string): Promise<string> =>
+  prettier.format(code, {
+    parser: 'typescript',
+    plugins: [prettierPluginTypeScript, prettierPluginEstree],
+  });
+
 const testFn = async ({
   source,
   expected,
@@ -38,12 +44,6 @@ const testFn = async ({
   expect(transformed).toBe(expectedFormatted);
 };
 
-const formatter = (code: string): Promise<string> =>
-  prettier.format(code, {
-    parser: 'typescript',
-    plugins: [prettierPluginTypeScript, prettierPluginEstree],
-  });
-
 describe(appendAsConstTransformer, () => {
   describe('Primitive types (should not add as const)', () => {
     test.each([
@@ -794,6 +794,39 @@ describe(appendAsConstTransformer, () => {
           const m = h([1], [2] as const);
         `,
       },
+      {
+        name: 'a declared this parameter should not shift arguments onto the parameter to their left',
+        source: dedent`
+          declare function f<const T, U>(this: void, a: T, b: U): U;
+          const r = f(1, [1, 2] as const);
+        `,
+        expected: dedent`
+          declare function f<const T, U>(this: void, a: T, b: U): U;
+          const r = f(1, [1, 2] as const);
+        `,
+      },
+      {
+        name: 'a declared this parameter should still let the matching argument lose as const',
+        source: dedent`
+          declare function f<const T, U>(this: void, a: T, b: U): T;
+          const r = f([1, 2] as const, [3] as const);
+        `,
+        expected: dedent`
+          declare function f<const T, U>(this: void, a: T, b: U): T;
+          const r = f([1, 2], [3] as const);
+        `,
+      },
+      {
+        name: 'a this parameter in a function type should be skipped too',
+        source: dedent`
+          declare const g: <const T>(this: void, x: T) => T;
+          const r = g([1] as const);
+        `,
+        expected: dedent`
+          declare const g: <const T>(this: void, x: T) => T;
+          const r = g([1]);
+        `,
+      },
       {
         name: 'non-const type parameter should keep as const',
         source: dedent`
@@ -1013,7 +1046,25 @@ describe(appendAsConstTransformer, () => {
     ])('$name', testFn);
   });
 
-  describe('ignorePrefixes option (mut_ prefix)', () => {
+  describe('mutableVariablePrefixes option (mut_ prefix)', () => {
+    test('the removed ignorePrefixes option is refused', () => {
+      expect(() =>
+        appendAsConstTransformer(
+          // @ts-expect-error removed in 4.0.0
+          { ignorePrefixes: ['mut_'] },
+        ),
+      ).toThrow('mutableVariablePrefixes');
+    });
+
+    test('an unset ignorePrefixes option is accepted', () => {
+      expect(() =>
+        appendAsConstTransformer(
+          // @ts-expect-error removed in 4.0.0
+          { ignorePrefixes: undefined },
+        ),
+      ).not.toThrow();
+    });
+
     test.each([
       {
         name: 'single variable with mut_ prefix',
@@ -1025,6 +1076,66 @@ describe(appendAsConstTransformer, () => {
         source: 'const mut_a = [1, 2], mut_b = { c: 3 };',
         expected: 'const mut_a = [1, 2], mut_b = { c: 3 };',
       },
+      {
+        name: '"draft" and "_mut_" are not default prefixes',
+        source: 'const draft = { a: [1] }, _mut_b = [2];',
+        expected: 'const draft = { a: [1] } as const, _mut_b = [2] as const;',
+      },
+      {
+        name: 'a variable annotated with a mutable type gets no as const',
+        source: dedent`
+          const a: MutableFoo = { b: [1] };
+          const c: ns.MutableFoo | undefined = { b: [1] };
+          const d: readonly MutableFoo[] = [{ b: [1] }];
+          const f: mut_Foo = { b: [1] };
+          const g: import('./m').MutableFoo = { b: [1] };
+          const h = { b: [1] } satisfies MutableFoo;
+          const i = (): MutableFoo => ({ b: [1] });
+          const j: typeof mut_x = [1];
+          const k: typeof mut_y.items = [1];
+          const l: typeof import('./m').mut_z = [1];
+          const m: InstanceType<typeof MutableStore> = { items: [] };
+          const n: InstanceType<typeof import('./m').MutableStore> = { items: [] };
+          const o = ((): MutableFoo => ({ b: [1] }));
+          const p = cond ? ({ b: [1] } satisfies MutableFoo) : q;
+          const e: Foo = { b: [1] };
+        `,
+        expected: dedent`
+          const a: MutableFoo = { b: [1] };
+          const c: ns.MutableFoo | undefined = { b: [1] };
+          const d: readonly MutableFoo[] = [{ b: [1] }];
+          const f: mut_Foo = { b: [1] };
+          const g: import('./m').MutableFoo = { b: [1] };
+          const h = { b: [1] } satisfies MutableFoo;
+          const i = (): MutableFoo => ({ b: [1] });
+          const j: typeof mut_x = [1];
+          const k: typeof mut_y.items = [1];
+          const l: typeof import('./m').mut_z = [1];
+          const m: InstanceType<typeof MutableStore> = { items: [] };
+          const n: InstanceType<typeof import('./m').MutableStore> = { items: [] };
+          const o = ((): MutableFoo => ({ b: [1] }));
+          const p = cond ? ({ b: [1] } satisfies MutableFoo) : q;
+          const e: Foo = { b: [1] } as const;
+        `,
+      },
+      {
+        name: 'mutableTypePrefixes replaces the default',
+        source: dedent`
+          const a: MutableFoo = { b: [1] };
+          const c: MyFoo = { b: [1] };
+        `,
+        expected: dedent`
+          const a: MutableFoo = { b: [1] } as const;
+          const c: MyFoo = { b: [1] };
+        `,
+        options: { mutableTypePrefixes: ['My'] },
+      },
+      {
+        name: 'the prefixes named in the option replace the default',
+        source: 'const draft = { a: [1] }, mut_b = [2];',
+        expected: 'const draft = { a: [1] }, mut_b = [2] as const;',
+        options: { mutableVariablePrefixes: ['draft'] },
+      },
     ])('$name', testFn);
   });