ts-codemod-lib 3.3.3 → 3.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-codemod-lib",
-  "version": "3.3.3",
+  "version": "3.4.1",
   "private": false,
   "keywords": [
     "typescript",
@@ -43,39 +43,39 @@
     "ts-type-forge": "^9.2.2"
   },
   "devDependencies": {
-    "@types/node": "26.6.1",
-    "@vitest/browser-playwright": "5.0.1",
-    "@vitest/coverage-v8": "5.0.1",
-    "@vitest/ui": "5.0.1",
-    "cspell": "10.3.3",
+    "@types/node": "26.6.3",
+    "@vitest/browser-playwright": "5.0.2",
+    "@vitest/coverage-v8": "5.0.2",
+    "@vitest/ui": "5.0.2",
+    "cspell": "10.3.5",
     "dedent": "1.7.2",
     "esbuild": "0.28.2",
-    "eslint": "10.10.0",
-    "eslint-config-typed": "5.14.0",
-    "eslint-plugin-ts-data-forge": "0.8.1",
-    "eslint-plugin-ts-fortress": "1.2.3",
-    "eslint-plugin-ts-type-forge": "0.8.4",
+    "eslint": "10.11.0",
+    "eslint-config-typed": "5.17.0",
+    "eslint-plugin-ts-data-forge": "0.8.3",
+    "eslint-plugin-ts-fortress": "1.3.0",
+    "eslint-plugin-ts-type-forge": "0.8.5",
     "jiti": "2.7.0",
     "npm-run-all2": "9.0.3",
     "playwright": "1.63.0",
-    "prettier": "3.9.7",
+    "prettier": "3.9.9",
     "prettier-plugin-organize-imports": "4.3.0",
     "prettier-plugin-packagejson": "3.0.2",
     "ts-repo-utils": "10.7.1",
-    "tsx": "4.23.13",
+    "tsx": "4.23.15",
     "typedoc": "0.28.20",
     "typedoc-github-theme": "0.4.0",
     "typescript": "6.0.3",
     "typescript-native": "npm:typescript@7.0.2",
-    "vite": "8.3.0",
-    "vitest": "5.0.1"
+    "vite": "8.3.1",
+    "vitest": "5.0.2"
   },
   "engines": {
     "node": ">=22.22.2",
     "pnpm": ">=9.0.0"
   },
   "volta": {
-    "node": "26.9.0"
+    "node": "26.10.0"
   },
   "publishConfig": {
     "access": "public",

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

@@ -1,12 +1,12 @@
 import { Arr, ISet } 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,
   isAsConstNode,
 } from '../functions/index.mjs';
 import { replaceNodeWithDebugPrint } from '../utils/index.mjs';
-import { type TsMorphTransformer } from './types.mjs';
+import type { TsMorphTransformer } from './types.mjs';
 
 const TRANSFORMER_NAME = 'append-as-const';
 
@@ -423,7 +423,9 @@ const removeAsConstInConstTypeParameterArgs = (
     const args = call.getArguments();
 
     // Cheap syntactic pre-check before touching the type checker
-    if (!args.some(isAsConstNode)) {
+    if (
+      args.every((arg) => !isAsConstNode(skipParenthesizedExpressions(arg)))
+    ) {
       continue;
     }
 
@@ -478,7 +480,14 @@ const removeAsConstArgsOfCall = (
       return;
     }
 
-    if (argument.wasForgotten() || !isAsConstNode(argument)) {
+    if (argument.wasForgotten()) {
+      continue;
+    }
+
+    // `f(([1] as const))` is the same argument as `f([1] as const)`.
+    const asConst = skipParenthesizedExpressions(argument);
+
+    if (!isAsConstNode(asConst)) {
       continue;
     }
 
@@ -503,10 +512,17 @@ const removeAsConstArgsOfCall = (
       argument.getText(),
     );
 
-    options.replaceNode(argument, argument.getExpression().getText());
+    // The parentheses go with it: an argument needs none of its own.
+    options.replaceNode(argument, asConst.getExpression().getText());
   }
 };
 
+/** `node` with the parentheses written around it taken off. */
+const skipParenthesizedExpressions = (node: tsm.Node): tsm.Node =>
+  tsm.Node.isParenthesizedExpression(node)
+    ? skipParenthesizedExpressions(node.getExpression())
+    : node;
+
 type ResolvedCallTarget = Readonly<{
   parameters: readonly tsm.ParameterDeclaration[];
   constTypeParameterNames: ISet<string>;

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

@@ -759,6 +759,30 @@ describe(appendAsConstTransformer, () => {
           const r = rest(1, [2, 3]);
         `,
       },
+      {
+        name: 'const type parameter should remove a parenthesized as const',
+        source: dedent`
+          function f<const T>(x: T): T { return x; }
+          const a = f(([1, 2] as const));
+          const b = f(((({ x: 1 }) as const)));
+        `,
+        expected: dedent`
+          function f<const T>(x: T): T { return x; }
+          const a = f([1, 2]);
+          const b = f({ x: 1 });
+        `,
+      },
+      {
+        name: 'non-const type parameter should keep a parenthesized as const',
+        source: dedent`
+          function g<T>(x: T): T { return x; }
+          const b = g(([1, 2] as const));
+        `,
+        expected: dedent`
+          function g<T>(x: T): T { return x; }
+          const b = g([1, 2] as const);
+        `,
+      },
       {
         name: 'mixed const and non-const type parameters should only remove for const ones',
         source: dedent`

package/src/functions/ast-transformers/convert-interface-to-type.mts

@@ -3,7 +3,7 @@
 import { Arr } from 'ts-data-forge';
 import type * as tsm from 'ts-morph';
 import { hasDisableNextLineComment } from '../functions/index.mjs';
-import { type TsMorphTransformer } from './types.mjs';
+import type { TsMorphTransformer } from './types.mjs';
 
 const TRANSFORMER_NAME = 'convert-interface-to-type';
 

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

@@ -8,11 +8,11 @@ import {
   pipe,
 } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
-import {
-  type DeepReadonly,
-  type SafeUintWithSmallInt,
-  type StrictExclude,
-  type StrictExtract,
+import type {
+  DeepReadonly,
+  SafeUintWithSmallInt,
+  StrictExclude,
+  StrictExtract,
 } from 'ts-type-forge';
 import {
   hasCallOrConstructSignature,
@@ -36,7 +36,7 @@ import {
   nextReadonlyContext,
   type ReadonlyContext,
 } from './readonly-transformer-helpers/index.mjs';
-import { type TsMorphTransformer } from './types.mjs';
+import type { TsMorphTransformer } from './types.mjs';
 
 const TRANSFORMER_NAME = 'convert-to-readonly';
 
@@ -1303,6 +1303,7 @@ const transformIntersectionTypeNode = (
 /**
  * - `tr(A | B) |-> tr(A) | tr(B)`
  * - `tr(Readonly<A> | Readonly<B>) |-> Readonly<tr(A) | tr(B)>`
+ * - `tr(DeepReadonly<A> | DeepReadonly<B>) |-> DeepReadonly<tr(A) | tr(B)>`
  */
 const transformUnionTypeNode = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
@@ -1416,7 +1417,14 @@ const transformUnionOrIntersectionTypeNodeImpl = (
       others,
       (a) =>
         [
-          a.nodes.map((n) => wrapWithParentheses(n.getFullText())),
+          // `&` is deliberately not merged, unlike `Readonly<A> & Readonly<B>`
+          // above. See `mergeDeepReadonlyUnionMembers` for why.
+          operator === '|'
+            ? mergeDeepReadonlyUnionMembers(
+                a.nodes,
+                options.DeepReadonly.typeName,
+              )
+            : a.nodes.map((n) => wrapWithParentheses(n.getFullText())),
           a.firstPosition,
         ] as const,
     ),
@@ -1450,6 +1458,93 @@ const transformUnionOrIntersectionTypeNodeImpl = (
   );
 };
 
+/**
+ * - `tr(DeepReadonly<A> | B | DeepReadonly<C>) |-> DeepReadonly<A | C> | B`
+ *
+ * The merged member takes the place of the first `DeepReadonly` member.
+ *
+ * Only a union is merged, although `Readonly<A> & Readonly<B>` is merged into
+ * `Readonly<A & B>`. The two differ in kind:
+ *
+ * - `Readonly` is a homomorphic mapped type, and over type literals
+ *   `Readonly<A & B>` and `Readonly<A> & Readonly<B>` have the same properties
+ *   with the same modifiers. (That merge also takes `Readonly<T>` with any
+ *   `T`, where this does not hold for an array `T`; it is not relied on here.)
+ * - `DeepReadonly` is a conditional type that picks a branch by what `T` is
+ *   (primitive, function, Map, Set, array, object). It distributes over a union
+ *   because each member is tested on its own, but an intersection is tested as
+ *   a whole and matches every branch any one member matches: with
+ *   `F = () => void`, `F & { x: number[] }` extends a function type because `F`
+ *   does, so `DeepReadonly<F & { x: number[] }>` hits that branch and returns
+ *   the intersection unchanged, leaving `x` mutable, while `DeepReadonly<F> &
+ *   DeepReadonly<{ x: number[] }>` is `F & { readonly x: readonly number[] }`.
+ *   The codemod cannot tell whether a type argument is such a member, so it
+ *   merges no intersection.
+ *
+ * The test "premises of merging DeepReadonly members" pins both facts against
+ * ts-type-forge's `DeepReadonly`.
+ */
+const mergeDeepReadonlyUnionMembers = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  nodes: readonly tsm.TypeNode[],
+  deepReadonlyTypeName: string,
+): readonly string[] => {
+  const typeArgsOfDeepReadonly = nodes.map((n) =>
+    getDeepReadonlyTypeArg(n, deepReadonlyTypeName),
+  );
+
+  const typeArgs = typeArgsOfDeepReadonly.filter((t) => t !== undefined);
+
+  if (typeArgs.length < 2) {
+    return nodes.map((n) => wrapWithParentheses(n.getFullText()));
+  }
+
+  const firstIndex = typeArgsOfDeepReadonly.findIndex((t) => t !== undefined);
+
+  const merged = unionToString({
+    types: typeArgs.map((t_) => {
+      const t = removeParentheses(t_);
+
+      // NOTE: DeepReadonly<A | B> | DeepReadonly<C> -> DeepReadonly<A | B | C>
+      // NOTE: DeepReadonly<() => void> | DeepReadonly<B> -> DeepReadonly<(() => void) | B>
+      return t.isKind(tsm.SyntaxKind.UnionType)
+        ? t.getFullText()
+        : wrapWithParentheses(t.getFullText());
+    }),
+    op: '|',
+    wrapWithReadonly: deepReadonlyTypeName,
+  });
+
+  return nodes.flatMap((n, i) =>
+    typeArgsOfDeepReadonly[i] === undefined
+      ? [wrapWithParentheses(n.getFullText())]
+      : i === firstIndex
+        ? [merged]
+        : [],
+  );
+};
+
+/** `DeepReadonly<T>` |-> `T`, anything else |-> `undefined` */
+const getDeepReadonlyTypeArg = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: tsm.TypeNode,
+  deepReadonlyTypeName: string,
+): tsm.TypeNode | undefined => {
+  if (!node.isKind(tsm.SyntaxKind.TypeReference)) {
+    return undefined;
+  }
+
+  const typeName = node.getTypeName();
+
+  const typeArguments = node.getTypeArguments();
+
+  return typeName.isKind(tsm.SyntaxKind.Identifier) &&
+    typeName.getText() === deepReadonlyTypeName &&
+    Arr.isFixedLengthArray(1, typeArguments)
+    ? typeArguments[0]
+    : undefined;
+};
+
 const unionToString = ({
   types: typesRaw,
   op,

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

@@ -6,6 +6,10 @@ import dedent from 'dedent';
 import * as prettierPluginEstree from 'prettier/plugins/estree';
 import * as prettierPluginTypeScript from 'prettier/plugins/typescript';
 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 {
   convertToReadonlyTransformer,
   type ReadonlyTransformerOptions,
@@ -2831,6 +2835,205 @@ describe(convertToReadonlyTransformer, () => {
     ])('$name', testFn);
   });
 
+  describe('Union of DeepReadonly members', () => {
+    test.each([
+      {
+        name: 'DeepReadonly<A> | DeepReadonly<B> -> DeepReadonly<A | B>',
+        source: dedent`
+          type T = DeepReadonly<{ a: number[] }> | DeepReadonly<{ b: string[] }>;
+        `,
+        expected: dedent`
+          type T = DeepReadonly<{ a: number[] } | { b: string[] }>;
+        `,
+      },
+      {
+        name: 'Three DeepReadonly members',
+        source: dedent`
+          type T<A, B> = DeepReadonly<A> | DeepReadonly<B> | DeepReadonly<{ c: boolean[] }>;
+        `,
+        expected: dedent`
+          type T<A, B> = DeepReadonly<A | B | { c: boolean[] }>;
+        `,
+      },
+      {
+        name: 'DeepReadonly members separated by other members',
+        source: dedent`
+          type T = DeepReadonly<{ a: number[] }> | string | Map<string, number> | DeepReadonly<{ b: string[] }>;
+        `,
+        expected: dedent`
+          type T = DeepReadonly<{ a: number[] } | { b: string[] }> | ReadonlyMap<string, number> | string;
+        `,
+      },
+      {
+        name: 'A DeepReadonly member whose argument is itself a union',
+        source: dedent`
+          type T = DeepReadonly<{ a: number[] } | { b: string[] }> | DeepReadonly<{ c: boolean[] }>;
+        `,
+        expected: dedent`
+          type T = DeepReadonly<{ a: number[] } | { b: string[] } | { c: boolean[] }>;
+        `,
+      },
+      {
+        // `() => void | X` would parse as a function returning `void | X`.
+        name: 'A function type argument keeps its parentheses',
+        source: dedent`
+          type T = DeepReadonly<() => void> | DeepReadonly<{ b: string[] }>;
+        `,
+        expected: dedent`
+          type T = DeepReadonly<(() => void) | { b: string[] }>;
+        `,
+      },
+      {
+        name: 'Nested in a type literal',
+        source: dedent`
+          type T = { x: DeepReadonly<{ a: number[] }> | DeepReadonly<{ b: string[] }> };
+        `,
+        expected: dedent`
+          type T = Readonly<{ x: DeepReadonly<{ a: number[] } | { b: string[] }> }>;
+        `,
+      },
+      {
+        name: 'A single DeepReadonly member is left as written',
+        source: dedent`
+          type T = DeepReadonly<{ a: number[] }> | { b: string[] };
+        `,
+        expected: dedent`
+          type T = DeepReadonly<{ a: number[] }> | Readonly<{ b: readonly string[] }>;
+        `,
+      },
+      {
+        name: 'DeepReadonly and Readonly members are not merged',
+        source: dedent`
+          type T = DeepReadonly<{ a: number[] }> | Readonly<{ b: string[] }>;
+        `,
+        expected: dedent`
+          type T = DeepReadonly<{ a: number[] }> | Readonly<{ b: readonly string[] }>;
+        `,
+      },
+      // Unlike `Readonly<A> & Readonly<B>`, an intersection of DeepReadonly
+      // members is never merged; see `mergeDeepReadonlyUnionMembers` and the
+      // premises test below.
+      {
+        name: 'An intersection of DeepReadonly members is left as written',
+        source: dedent`
+          type T = DeepReadonly<{ a: number[] }> & DeepReadonly<{ b: string[] }>;
+        `,
+        expected: dedent`
+          type T = DeepReadonly<{ a: number[] }> & DeepReadonly<{ b: string[] }>;
+        `,
+      },
+      {
+        // The case merging would get wrong: `DeepReadonly<F & X>` is `F & X`.
+        name: 'An intersection with a function type argument is left as written',
+        source: dedent`
+          type T = DeepReadonly<() => void> & DeepReadonly<{ x: number[] }>;
+        `,
+        expected: dedent`
+          type T = DeepReadonly<() => void> & DeepReadonly<{ x: number[] }>;
+        `,
+      },
+      {
+        name: 'An intersection of generic DeepReadonly members is left as written',
+        source: dedent`
+          type T<A, B> = DeepReadonly<A> & DeepReadonly<B>;
+        `,
+        expected: dedent`
+          type T<A, B> = DeepReadonly<A> & DeepReadonly<B>;
+        `,
+      },
+      {
+        name: 'An intersection under a custom typeName is left as written',
+        source: dedent`
+          type T = DeepRO<{ a: number[] }> & DeepRO<{ b: string[] }>;
+        `,
+        expected: dedent`
+          type T = DeepRO<{ a: number[] }> & DeepRO<{ b: string[] }>;
+        `,
+        options: { DeepReadonly: { typeName: 'DeepRO' } },
+      },
+      {
+        // The union around it has one DeepReadonly member, so nothing merges.
+        name: 'An intersection of DeepReadonly members inside a union is left as written',
+        source: dedent`
+          type T = (DeepReadonly<{ a: number[] }> & DeepReadonly<{ b: string[] }>) | DeepReadonly<{ c: boolean[] }>;
+        `,
+        expected: dedent`
+          type T = (DeepReadonly<{ a: number[] }> & DeepReadonly<{ b: string[] }>) | DeepReadonly<{ c: boolean[] }>;
+        `,
+      },
+      {
+        name: 'Custom DeepReadonly typeName',
+        source: dedent`
+          type T = DeepRO<{ a: number[] }> | DeepRO<{ b: string[] }>;
+        `,
+        expected: dedent`
+          type T = DeepRO<{ a: number[] } | { b: string[] }>;
+        `,
+        options: { DeepReadonly: { typeName: 'DeepRO' } },
+      },
+      {
+        name: 'Other generic types are not merged',
+        source: dedent`
+          type T<A, B> = Partial<A> | Partial<B>;
+        `,
+        expected: dedent`
+          type T<A, B> = Partial<A> | Partial<B>;
+        `,
+      },
+    ])('$name', testFn);
+
+    // What `mergeDeepReadonlyUnionMembers` relies on. If ts-type-forge's
+    // `DeepReadonly` changes so that one of these no longer holds, revisit
+    // which operators the codemod merges.
+    test('premises of merging DeepReadonly members', () => {
+      type F = () => void;
+
+      type X = Readonly<{ x: number[] }>;
+
+      type A = Readonly<{ a: number[] }>;
+
+      type B = Readonly<{ b: string[] }>;
+
+      // `|` commutes with DeepReadonly, so merging a union is safe.
+      expectType<
+        TsTypeForgeDeepReadonly<A | B>,
+        TsTypeForgeDeepReadonly<A> | TsTypeForgeDeepReadonly<B>
+      >('=');
+
+      expectType<
+        TsTypeForgeDeepReadonly<F | X>,
+        TsTypeForgeDeepReadonly<F> | TsTypeForgeDeepReadonly<X>
+      >('=');
+
+      expectType<
+        TsTypeForgeDeepReadonly<readonly string[] | X>,
+        TsTypeForgeDeepReadonly<readonly string[]> | TsTypeForgeDeepReadonly<X>
+      >('=');
+
+      // `&` does not: an intersection is tested as a whole and matches every
+      // branch any one member matches. `F & X` hits the function branch and
+      // comes back unchanged, leaving `x` mutable.
+      expectType<TsTypeForgeDeepReadonly<F & X>, F & X>('=');
+
+      expectType<
+        TsTypeForgeDeepReadonly<F & X>,
+        TsTypeForgeDeepReadonly<F> & TsTypeForgeDeepReadonly<X>
+      >('!=');
+
+      expectType<
+        TsTypeForgeDeepReadonly<readonly string[] & X>,
+        TsTypeForgeDeepReadonly<readonly string[]> & TsTypeForgeDeepReadonly<X>
+      >('!=');
+
+      // `Readonly` over type literals does commute with `&`, which is what
+      // merging `{ a: A } & Readonly<{ b: B }>` into one `Readonly` relies on.
+      expectType<
+        Readonly<{ a: number[] } & { b: string[] }>,
+        Readonly<{ a: number[] }> & Readonly<{ b: string[] }>
+      >('~=');
+    });
+  });
+
   describe('Parenthesized types', () => {
     test.each([
       {

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
   );
 };