ts-codemod-lib 3.4.0 → 3.4.2

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

@@ -11,9 +11,30 @@ import {
   type ReadonlyTypeReferenceNode,
 } from '../../functions/index.mjs';
 
+/**
+ * Sorts the members of a union or intersection into the groups
+ * `convert-to-readonly` writes back separately.
+ *
+ * `typeLiterals` is the group joined and wrapped in a single `Readonly<...>`.
+ * It takes type literals, the `Readonly<...>` members that may be merged (see
+ * `isMergeableReadonlyTypeReferenceNode`), and, when the union or intersection
+ * is itself the argument of a `Readonly<...>` (`underReadonly`), every other
+ * member that `Readonly` still means something to (see `staysOutsideReadonly`):
+ * taking such a member out of the `Readonly` it was written under would drop
+ * its readonly-ness.
+ */
 export const groupUnionIntersectionTypes = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   types: readonly tsm.TypeNode[],
+  {
+    operator,
+    underReadonly,
+    deepReadonlyTypeName,
+  }: Readonly<{
+    operator: '&' | '|';
+    underReadonly: boolean;
+    deepReadonlyTypeName: string;
+  }>,
 ): Readonly<{
   primitives:
     | Readonly<{
@@ -37,7 +58,7 @@ export const groupUnionIntersectionTypes = (
   typeLiterals:
     | Readonly<{
         firstPosition: number;
-        nodes: readonly (tsm.TypeLiteralNode | ReadonlyTypeReferenceNode)[];
+        nodes: readonly tsm.TypeNode[];
       }>
     | undefined;
 
@@ -71,7 +92,7 @@ export const groupUnionIntersectionTypes = (
     typeLiterals:
       | Readonly<{
           firstPosition: number;
-          nodes: (tsm.TypeLiteralNode | ReadonlyTypeReferenceNode)[];
+          nodes: tsm.TypeNode[];
         }>
       | undefined;
 
@@ -130,7 +151,8 @@ export const groupUnionIntersectionTypes = (
     if (
       (t.isKind(tsm.SyntaxKind.TypeLiteral) &&
         !hasCallOrConstructSignature(t)) ||
-      isReadonlyTypeReferenceNode(t)
+      isMergeableReadonlyTypeReferenceNode(t, operator) ||
+      (underReadonly && !staysOutsideReadonly(t, deepReadonlyTypeName))
     ) {
       if (mut_grouped.typeLiterals === undefined) {
         mut_grouped.typeLiterals = {
@@ -157,3 +179,102 @@ export const groupUnionIntersectionTypes = (
 
   return mut_grouped;
 };
+
+/**
+ * Whether a `Readonly<T>` member of a union or intersection may be merged with
+ * the others into one `Readonly<...>`.
+ *
+ * - In a union, any `T`: `Readonly` distributes over `|`, so `Readonly<A> |
+ *   Readonly<B>` and `Readonly<A | B>` are the same type.
+ * - In an intersection, only a `T` known to be an object type (see
+ *   `isObjectTypeLiteral`). Over object types `Readonly<A> & Readonly<B>` and
+ *   `Readonly<A & B>` agree, but `Readonly` maps an array to a readonly array
+ *   only when its argument _is_ an array, so `Readonly<string[] & X>` leaves the
+ *   array mutable where `Readonly<string[]> & Readonly<X>` does not. A type
+ *   parameter or an alias may be such an array.
+ */
+export const isMergeableReadonlyTypeReferenceNode = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: tsm.TypeNode,
+  operator: '&' | '|',
+): node is ReadonlyTypeReferenceNode =>
+  isReadonlyTypeReferenceNode(node) &&
+  (operator === '|' || isObjectTypeLiteral(node.getTypeArguments()[0]));
+
+/**
+ * A type literal or a mapped type known to be an object type, or a union,
+ * intersection or `Readonly<...>` of them.
+ */
+const isObjectTypeLiteral = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: tsm.TypeNode,
+): boolean => {
+  const t = removeParentheses(node);
+
+  if (t.isKind(tsm.SyntaxKind.TypeLiteral)) {
+    return true;
+  }
+
+  // A mapped type is an object type unless it maps over `keyof T`, which maps
+  // an array `T` to an array.
+  if (t.isKind(tsm.SyntaxKind.MappedType)) {
+    const constraint = t.getTypeParameter().getConstraint();
+
+    return !(
+      constraint?.isKind(tsm.SyntaxKind.TypeOperator) === true &&
+      constraint.getOperator() === tsm.SyntaxKind.KeyOfKeyword
+    );
+  }
+
+  if (isReadonlyTypeReferenceNode(t)) {
+    return isObjectTypeLiteral(t.getTypeArguments()[0]);
+  }
+
+  if (
+    t.isKind(tsm.SyntaxKind.UnionType) ||
+    t.isKind(tsm.SyntaxKind.IntersectionType)
+  ) {
+    return t.getTypeNodes().every(isObjectTypeLiteral);
+  }
+
+  return false;
+};
+
+/**
+ * Whether a member of a union or intersection under `Readonly<...>` may be
+ * taken out of it as it is.
+ *
+ * - A function or constructor type, or a type literal with a call or construct
+ *   signature, loses its signatures under `Readonly`; see
+ *   `hasCallOrConstructSignature`.
+ * - `keyof T` and `unique symbol` are not object types.
+ * - `DeepReadonly<T>`, `ReadonlyMap`, `ReadonlySet` and `ReadonlyRecord` are
+ *   readonly already.
+ */
+const staysOutsideReadonly = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: tsm.TypeNode,
+  deepReadonlyTypeName: string,
+): boolean => {
+  if (
+    node.isKind(tsm.SyntaxKind.FunctionType) ||
+    node.isKind(tsm.SyntaxKind.ConstructorType) ||
+    node.isKind(tsm.SyntaxKind.TypeLiteral) ||
+    node.isKind(tsm.SyntaxKind.TypeOperator)
+  ) {
+    return true;
+  }
+
+  if (node.isKind(tsm.SyntaxKind.TypeReference)) {
+    const typeName = node.getTypeName().getText();
+
+    return (
+      typeName === deepReadonlyTypeName ||
+      typeName === 'ReadonlyMap' ||
+      typeName === 'ReadonlySet' ||
+      typeName === 'ReadonlyRecord'
+    );
+  }
+
+  return false;
+};

package/src/functions/ast-transformers/readonly-transformer-helpers/readonly-context.mts

@@ -1,5 +1,5 @@
 import { SafeUint, match } from 'ts-data-forge';
-import { type SafeUintWithSmallInt, type StrictExtract } from 'ts-type-forge';
+import type { SafeUintWithSmallInt, StrictExtract } from 'ts-type-forge';
 
 /**
  * Controls whether to make a layer mutable during recursive transformation

package/src/functions/ast-transformers/replace-any-with-unknown.mts

@@ -4,7 +4,7 @@ import {
   isSpreadNamedTupleMemberNode,
   isSpreadParameterNode,
 } from '../functions/index.mjs';
-import { type TsMorphTransformer } from './types.mjs';
+import type { TsMorphTransformer } from './types.mjs';
 
 const TRANSFORMER_NAME = 'replace-any-with-unknown';
 

package/src/functions/ast-transformers/replace-record-with-unknown-record.mts

@@ -2,7 +2,7 @@
 import { Arr } from 'ts-data-forge';
 import * 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 = 'replace-record-with-unknown-record';
 

package/src/functions/ast-transformers/transform-source-code.mts

@@ -1,6 +1,6 @@
 import { Arr } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
-import { type TsMorphTransformer } from './types.mjs';
+import type { TsMorphTransformer } from './types.mjs';
 
 const fileIgnorePrefixes = [
   'transformer-ignore',

package/src/functions/functions/is-atomic-type-node.mts

@@ -1,6 +1,6 @@
 import { 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';
 
 // Define the set of SyntaxKinds that represent primitive type keywords
 const atomicTypeKeywordKinds = ISet.create<tsm.SyntaxKind>([

package/src/functions/functions/is-readonly-node.mts

@@ -1,6 +1,6 @@
 import { Arr, expectType } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
-import { type DeepReadonly, type StrictOmit } from 'ts-type-forge';
+import type { DeepReadonly, StrictOmit } from 'ts-type-forge';
 import { isAtomicTypeNode } from './is-atomic-type-node.mjs';
 
 export const isShallowReadonlyTypeNode = (node: tsm.Node): boolean =>

package/src/functions/functions/unwrap-readonly.mts

@@ -1,4 +1,4 @@
-import { type ReadonlyTypeReferenceNode } from './is-readonly-node.mjs';
+import type { ReadonlyTypeReferenceNode } from './is-readonly-node.mjs';
 import { wrapWithParentheses } from './wrap-with-parentheses.mjs';
 
 export const unwrapReadonlyTypeArgText = (