ts-codemod-lib 4.0.0 → 4.0.1

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

@@ -12,8 +12,8 @@ const UNKNOWN_RECORD_MODULE = 'ts-type-forge';
 const UNKNOWN_RECORD_NAME = 'UnknownRecord';
 
 /**
- * Replaces `Readonly<Record<string, unknown>>`, `Record<string, unknown>`,
- * and index signatures `[k: string]: unknown` with `UnknownRecord`.
+ * Replaces `Readonly<Record<string, unknown>>`, `Record<string, unknown>`, and
+ * index signatures `[k: string]: unknown` with `UnknownRecord`.
  *
  * When a replacement occurs, also inserts
  * `import { type UnknownRecord } from 'ts-type-forge';` at the top of the
@@ -35,77 +35,14 @@ export const replaceRecordWithUnknownRecordTransformer =
       },
     }) as const;
 
-const processDeclarations = (
-  container: tsm.SourceFile | tsm.ModuleDeclaration,
-): boolean => {
-  const typeAliasModifications = container.getTypeAliases().map((typeAlias) => {
-    if (hasDisableNextLineComment(typeAlias, TRANSFORMER_NAME)) {
-      return false;
-    }
-
-    const typeNode = typeAlias.getTypeNode();
-
-    return typeNode !== undefined && visitTypeNode(typeNode);
-  });
-
-  const interfaceModifications = container
-    .getInterfaces()
-    .map(processInterfaceDeclaration);
-
-  return [...typeAliasModifications, ...interfaceModifications].includes(true);
-};
-
-const processInterfaceDeclaration = (
-  interfaceDecl: tsm.InterfaceDeclaration,
+const isStringUnknownIndexSignature = (
+  sig: tsm.IndexSignatureDeclaration,
 ): boolean => {
-  if (hasDisableNextLineComment(interfaceDecl, TRANSFORMER_NAME)) {
-    return false;
-  }
-
-  // Check if interface has index signature [k: string]: unknown
-  const indexSignatures = interfaceDecl.getIndexSignatures();
-
-  const hasStringUnknownSignature = indexSignatures.some((sig) => {
-    const keyType = sig.getKeyType();
-
-    const returnType = sig.getReturnType();
-
-    return keyType.getText() === 'string' && returnType.getText() === 'unknown';
-  });
-
-  // If it has the signature and no other members, replace entire interface with type alias.
-  // Skip when the interface carries semantics that a plain type alias would lose
-  // (type parameters, extends clauses, declare modifier, default export).
-  if (
-    hasStringUnknownSignature &&
-    Arr.isEmpty(interfaceDecl.getProperties()) &&
-    Arr.isFixedLengthArray(1, indexSignatures) &&
-    Arr.isEmpty(interfaceDecl.getTypeParameters()) &&
-    Arr.isEmpty(interfaceDecl.getExtends()) &&
-    !interfaceDecl.hasDeclareKeyword() &&
-    !interfaceDecl.hasDefaultKeyword()
-  ) {
-    const exportPrefix = interfaceDecl.hasExportKeyword() ? 'export ' : '';
-
-    const interfaceName = interfaceDecl.getName();
-
-    replaceNodeWithText(
-      interfaceDecl,
-      `${exportPrefix}type ${interfaceName} = UnknownRecord;`,
-    );
-
-    return true;
-  }
+  const keyType = sig.getKeyTypeNode();
 
-  // Otherwise, check properties for Record types
-  return interfaceDecl
-    .getProperties()
-    .map((property) => {
-      const typeNode = property.getTypeNode();
+  const returnType = sig.getReturnTypeNode();
 
-      return typeNode !== undefined && visitTypeNode(typeNode);
-    })
-    .includes(true);
+  return keyType.getText() === 'string' && returnType?.getText() === 'unknown';
 };
 
 const visitTypeNode = (node: tsm.TypeNode): boolean => {
@@ -208,14 +145,77 @@ const visitTypeNode = (node: tsm.TypeNode): boolean => {
   );
 };
 
-const isStringUnknownIndexSignature = (
-  sig: tsm.IndexSignatureDeclaration,
+const processInterfaceDeclaration = (
+  interfaceDecl: tsm.InterfaceDeclaration,
 ): boolean => {
-  const keyType = sig.getKeyTypeNode();
+  if (hasDisableNextLineComment(interfaceDecl, TRANSFORMER_NAME)) {
+    return false;
+  }
 
-  const returnType = sig.getReturnTypeNode();
+  // Check if interface has index signature [k: string]: unknown
+  const indexSignatures = interfaceDecl.getIndexSignatures();
 
-  return keyType.getText() === 'string' && returnType?.getText() === 'unknown';
+  const hasStringUnknownSignature = indexSignatures.some((sig) => {
+    const keyType = sig.getKeyType();
+
+    const returnType = sig.getReturnType();
+
+    return keyType.getText() === 'string' && returnType.getText() === 'unknown';
+  });
+
+  // If it has the signature and no other members, replace entire interface with type alias.
+  // Skip when the interface carries semantics that a plain type alias would lose
+  // (type parameters, extends clauses, declare modifier, default export).
+  if (
+    hasStringUnknownSignature &&
+    Arr.isEmpty(interfaceDecl.getProperties()) &&
+    Arr.isFixedLengthArray(1, indexSignatures) &&
+    Arr.isEmpty(interfaceDecl.getTypeParameters()) &&
+    Arr.isEmpty(interfaceDecl.getExtends()) &&
+    !interfaceDecl.hasDeclareKeyword() &&
+    !interfaceDecl.hasDefaultKeyword()
+  ) {
+    const exportPrefix = interfaceDecl.hasExportKeyword() ? 'export ' : '';
+
+    const interfaceName = interfaceDecl.getName();
+
+    replaceNodeWithText(
+      interfaceDecl,
+      `${exportPrefix}type ${interfaceName} = UnknownRecord;`,
+    );
+
+    return true;
+  }
+
+  // Otherwise, check properties for Record types
+  return interfaceDecl
+    .getProperties()
+    .map((property) => {
+      const typeNode = property.getTypeNode();
+
+      return typeNode !== undefined && visitTypeNode(typeNode);
+    })
+    .includes(true);
+};
+
+const processDeclarations = (
+  container: tsm.SourceFile | tsm.ModuleDeclaration,
+): boolean => {
+  const typeAliasModifications = container.getTypeAliases().map((typeAlias) => {
+    if (hasDisableNextLineComment(typeAlias, TRANSFORMER_NAME)) {
+      return false;
+    }
+
+    const typeNode = typeAlias.getTypeNode();
+
+    return typeNode !== undefined && visitTypeNode(typeNode);
+  });
+
+  const interfaceModifications = container
+    .getInterfaces()
+    .map(processInterfaceDeclaration);
+
+  return [...typeAliasModifications, ...interfaceModifications].includes(true);
 };
 
 const replaceIfRecordUnknown = (node: tsm.TypeReferenceNode): boolean => {

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

@@ -7,6 +7,12 @@ import * as prettier from 'prettier/standalone';
 import { replaceRecordWithUnknownRecordTransformer } from './replace-record-with-unknown-record.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,
@@ -25,12 +31,6 @@ const testFn = async ({
   expect(transformed).toBe(expectedFormatted);
 };
 
-const formatter = (code: string): Promise<string> =>
-  prettier.format(code, {
-    parser: 'typescript',
-    plugins: [prettierPluginTypeScript, prettierPluginEstree],
-  });
-
 describe(replaceRecordWithUnknownRecordTransformer, () => {
   test.each([
     {

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

@@ -9,94 +9,47 @@ const fileIgnorePrefixes = [
   'transform-ignore',
 ] as const;
 
-/**
- * Finds the file-level ignore comment `/* <prefix> name, name *\/` and returns
- * the transformer names it lists (empty for all transformers), or `undefined`
- * when the file has none. Whitespace, line breaks included, may surround the
- * prefix and the names, but the names themselves must stay on one line. The
- * prefixes are tried in order, each against the whole file.
- *
- * The scan runs in time linear in the length of `code`, whatever it contains.
- */
-const findFileIgnoreTransformers = (
+export const transformSourceCode = (
   code: string,
-): readonly string[] | undefined => {
-  for (const prefix of fileIgnorePrefixes) {
-    const names = findFileIgnoreComment(code, prefix);
-
-    if (names !== undefined) {
-      return names;
-    }
-  }
-
-  return undefined;
-};
+  isTsx: boolean,
+  transformers: readonly TsMorphTransformer[],
+  debug: boolean = false,
+): string => {
+  const project = new tsm.Project({
+    useInMemoryFileSystem: true,
+    compilerOptions: {
+      jsx: isTsx ? tsm.ts.JsxEmit.React : undefined,
+      target: tsm.ts.ScriptTarget.ESNext,
+      module: tsm.ts.ModuleKind.ESNext,
+    },
+  });
 
-const findFileIgnoreComment = (
-  code: string,
-  prefix: string,
-): readonly string[] | undefined => {
-  // Queries into these searches only move forward, so each part of `code` is
-  // scanned a bounded number of times.
-  const findCommentEnd = createForwardSearch((from) =>
-    code.indexOf('*/', from),
+  const sourceAst = project.createSourceFile(
+    `source.${isTsx ? 'tsx' : 'ts'}`,
+    code,
   );
 
-  const findLineTerminator = createForwardSearch((from) =>
-    indexOfLineTerminator(code, from),
-  );
+  const ignoredTransformers = findFileIgnoreTransformers(code);
 
-  const trimEndBefore = createLastValueCache((commentEnd: number) =>
-    skipWhitespaceBackward(code, commentEnd),
-  );
+  for (const transformer of transformers) {
+    const transformerName = transformer.name;
 
-  for (
-    let mut_open = code.indexOf('/*');
-    mut_open !== -1;
-    mut_open = code.indexOf('/*', mut_open + 2)
-  ) {
-    const prefixStart = skipWhitespace(code, mut_open + 2);
+    if (shouldSkipFile(ignoredTransformers, transformerName)) {
+      if (debug) {
+        console.debug(
+          `skipped by ignore-file comment for transformer: ${transformerName}`,
+        );
+      }
 
-    if (!code.startsWith(prefix, prefixStart)) {
       continue;
     }
 
-    const namesStart = skipWhitespace(code, prefixStart + prefix.length);
-
-    const commentEnd = findCommentEnd(namesStart);
-
-    // Nothing after this point is closed, so no later comment can match.
-    if (commentEnd === -1) {
-      return undefined;
-    }
-
-    const namesEnd = Math.max(namesStart, trimEndBefore(commentEnd));
-
-    const lineTerminator = findLineTerminator(namesStart);
-
-    if (lineTerminator === -1 || lineTerminator >= namesEnd) {
-      const names = code.slice(namesStart, namesEnd);
-
-      // Empty means ignore all transformers; otherwise parse comma-separated
-      // transformer names
-      return names === '' ? [] : names.split(',').map((name) => name.trim());
-    }
+    transformer.transform(sourceAst);
   }
 
-  return undefined;
+  return sourceAst.getFullText();
 };
 
-const shouldSkipFile = (
-  ignoredTransformers: readonly string[] | undefined,
-  transformerName: string,
-): boolean =>
-  ignoredTransformers !== undefined &&
-  // Empty array means ignore all transformers (file-level ignore without
-  // specific transformers); otherwise check if the transformer is in the
-  // ignore list
-  (Arr.isEmpty(ignoredTransformers) ||
-    ignoredTransformers.includes(transformerName));
-
 /**
  * Wraps a search returning the first index at or after `from` (or -1), reusing
  * the previous answer while it still holds for a later `from`.
@@ -137,6 +90,10 @@ const createLastValueCache = (
   };
 };
 
+// Same set as `\s` and `String.prototype.trim`
+const isWhitespace = (char: string | undefined): boolean =>
+  char !== undefined && /^\s$/u.test(char);
+
 const skipWhitespace = (code: string, from: number): number => {
   let mut_index = from;
 
@@ -157,6 +114,10 @@ const skipWhitespaceBackward = (code: string, end: number): number => {
   return mut_index;
 };
 
+// The characters `.` does not match
+const isLineTerminator = (char: string | undefined): boolean =>
+  char !== undefined && /^[\n\r\u{2028}\u{2029}]$/u.test(char);
+
 const indexOfLineTerminator = (code: string, from: number): number => {
   let mut_index = from;
 
@@ -167,51 +128,90 @@ const indexOfLineTerminator = (code: string, from: number): number => {
   return mut_index < code.length ? mut_index : -1;
 };
 
-// Same set as `\s` and `String.prototype.trim`
-const isWhitespace = (char: string | undefined): boolean =>
-  char !== undefined && /^\s$/u.test(char);
-
-// The characters `.` does not match
-const isLineTerminator = (char: string | undefined): boolean =>
-  char !== undefined && /^[\n\r\u{2028}\u{2029}]$/u.test(char);
-
-export const transformSourceCode = (
+const findFileIgnoreComment = (
   code: string,
-  isTsx: boolean,
-  transformers: readonly TsMorphTransformer[],
-  debug: boolean = false,
-): string => {
-  const project = new tsm.Project({
-    useInMemoryFileSystem: true,
-    compilerOptions: {
-      jsx: isTsx ? tsm.ts.JsxEmit.React : undefined,
-      target: tsm.ts.ScriptTarget.ESNext,
-      module: tsm.ts.ModuleKind.ESNext,
-    },
-  });
-
-  const sourceAst = project.createSourceFile(
-    `source.${isTsx ? 'tsx' : 'ts'}`,
-    code,
+  prefix: string,
+): readonly string[] | undefined => {
+  // Queries into these searches only move forward, so each part of `code` is
+  // scanned a bounded number of times.
+  const findCommentEnd = createForwardSearch((from) =>
+    code.indexOf('*/', from),
   );
 
-  const ignoredTransformers = findFileIgnoreTransformers(code);
+  const findLineTerminator = createForwardSearch((from) =>
+    indexOfLineTerminator(code, from),
+  );
 
-  for (const transformer of transformers) {
-    const transformerName = transformer.name;
+  const trimEndBefore = createLastValueCache((commentEnd: number) =>
+    skipWhitespaceBackward(code, commentEnd),
+  );
 
-    if (shouldSkipFile(ignoredTransformers, transformerName)) {
-      if (debug) {
-        console.debug(
-          `skipped by ignore-file comment for transformer: ${transformerName}`,
-        );
-      }
+  for (
+    let mut_open = code.indexOf('/*');
+    mut_open !== -1;
+    mut_open = code.indexOf('/*', mut_open + 2)
+  ) {
+    const prefixStart = skipWhitespace(code, mut_open + 2);
 
+    if (!code.startsWith(prefix, prefixStart)) {
       continue;
     }
 
-    transformer.transform(sourceAst);
+    const namesStart = skipWhitespace(code, prefixStart + prefix.length);
+
+    const commentEnd = findCommentEnd(namesStart);
+
+    // Nothing after this point is closed, so no later comment can match.
+    if (commentEnd === -1) {
+      return undefined;
+    }
+
+    const namesEnd = Math.max(namesStart, trimEndBefore(commentEnd));
+
+    const lineTerminator = findLineTerminator(namesStart);
+
+    if (lineTerminator === -1 || lineTerminator >= namesEnd) {
+      const names = code.slice(namesStart, namesEnd);
+
+      // Empty means ignore all transformers; otherwise parse comma-separated
+      // transformer names
+      return names === '' ? [] : names.split(',').map((name) => name.trim());
+    }
   }
 
-  return sourceAst.getFullText();
+  return undefined;
+};
+
+/**
+ * Finds the file-level ignore comment `/* <prefix> name, name *\/` and returns
+ * the transformer names it lists (empty for all transformers), or `undefined`
+ * when the file has none. Whitespace, line breaks included, may surround the
+ * prefix and the names, but the names themselves must stay on one line. The
+ * prefixes are tried in order, each against the whole file.
+ *
+ * The scan runs in time linear in the length of `code`, whatever it contains.
+ */
+const findFileIgnoreTransformers = (
+  code: string,
+): readonly string[] | undefined => {
+  for (const prefix of fileIgnorePrefixes) {
+    const names = findFileIgnoreComment(code, prefix);
+
+    if (names !== undefined) {
+      return names;
+    }
+  }
+
+  return undefined;
 };
+
+const shouldSkipFile = (
+  ignoredTransformers: readonly string[] | undefined,
+  transformerName: string,
+): boolean =>
+  ignoredTransformers !== undefined &&
+  // Empty array means ignore all transformers (file-level ignore without
+  // specific transformers); otherwise check if the transformer is in the ignore
+  // list
+  (Arr.isEmpty(ignoredTransformers) ||
+    ignoredTransformers.includes(transformerName));

package/src/functions/ast-transformers/transformer-specific-ignore.test.mts

@@ -9,6 +9,12 @@ import { convertToReadonlyTransformer } from './convert-to-readonly.mjs';
 import { replaceAnyWithUnknownTransformer } from './replace-any-with-unknown.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,
@@ -39,12 +45,6 @@ const testFn = async ({
   expect(transformed).toBe(expectedFormatted);
 };
 
-const formatter = (code: string): Promise<string> =>
-  prettier.format(code, {
-    parser: 'typescript',
-    plugins: [prettierPluginTypeScript, prettierPluginEstree],
-  });
-
 describe('Transformer-specific ignore comments (Integration)', () => {
   test.each([
     {

package/src/functions/constants/mutable-prefixes.mts

@@ -1,11 +1,11 @@
 /**
  * The default `mutableVariablePrefixes` and `mutablePropertyPrefixes` of the
- * transformers: a name that starts with one of these is left mutable. A
- * private name (`#mut_x`) is matched with or after its `#`.
+ * transformers: a name that starts with one of these is left mutable. A private
+ * name (`#mut_x`) is matched with or after its `#`.
  *
- * The ESLint counterpart is `ignoredMutablePattern` in
- * `libs/eslint-config-typed/src/rules/eslint-functional-rules.mts` (and, for a
- * property, the `ignoreAccessorPattern` of `functional/immutable-data` there);
+ * The ESLint counterpart is `mutablePrefix` in
+ * `libs/eslint-config-typed/src/constants/mutable-prefix.mts`, from which
+ * `eslint-functional-rules.mts` there builds its name and property patterns;
  * `libs/eslint-config-typed/src/rules/eslint-functional-rules.test.mts` fails
  * when the two differ; it reads this package's `dist/`, so build first.
  */
@@ -15,9 +15,9 @@ export const DEFAULT_MUTABLE_PREFIXES: readonly string[] = Object.freeze([
 
 /**
  * The default `mutableTypePrefixes` of the transformers: a type alias, an
- * interface or a class whose name starts with one of these is left mutable,
- * and `append-as-const` adds no `as const` where the value has to be
- * assignable to it (an annotated variable, `satisfies`, an arrow's return).
+ * interface or a class whose name starts with one of these is left mutable, and
+ * `append-as-const` adds no `as const` where the value has to be assignable to
+ * it (an annotated variable, `satisfies`, an arrow's return).
  * `Mutable` suits the PascalCase of type names; `mut_` is accepted as for
  * variables. No ESLint rule reads type names, so there is no counterpart to
  * keep in step.

package/src/functions/functions/has-disable-next-line-comment.mts

@@ -84,9 +84,9 @@ export const hasDisableNextLineComment = (
         }
       }
 
-      // If we found *any* comment on the preceding line, but it wasn't
-      // the correct ignore comment, then the node is not ignored by
-      // a comment on the *immediately* preceding line. Stop checking further back.
+      // If we found *any* comment on the preceding line, but it wasn't the
+      // correct ignore comment, then the node is not ignored by a comment on
+      // the *immediately* preceding line. Stop checking further back.
       return false;
     }
 
@@ -99,38 +99,6 @@ export const hasDisableNextLineComment = (
   return false;
 };
 
-/**
- * The 1-based line number of a position in `sourceFile`, counted the way
- * ts-morph's `getStartLineNumber` and `getLineAndColumnAtPos` count it: one
- * plus the number of `\n` before the position (a lone `\r` starts no line,
- * unlike in the compiler's own line map).
- *
- * ts-morph scans the text from its start on every call, which made this
- * check, asked of every node a transformer visits, quadratic in the size of
- * the file. The newline positions are collected once per compiler source file
- * instead. ts-morph replaces that object whenever the file is edited, so an
- * entry never outlives the text it was collected from.
- */
-const lineNumberLookup = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  sourceFile: tsm.ts.SourceFile,
-): ((pos: number) => number) => {
-  const cached = newlinePositionsCache.get(sourceFile);
-
-  const newlinePositions = cached ?? newlinePositionsOf(sourceFile.text);
-
-  if (cached === undefined) {
-    newlinePositionsCache.set(sourceFile, newlinePositions);
-  }
-
-  return (pos) => countLessThan(newlinePositions, pos) + 1;
-};
-
-const newlinePositionsCache = new WeakMap<
-  tsm.ts.SourceFile,
-  readonly number[]
->();
-
 const newlinePositionsOf = (text: string): readonly number[] => {
   const mut_positions: number[] = [];
 
@@ -164,3 +132,35 @@ const countLessThan = (sorted: readonly number[], value: number): number => {
 
   return mut_low;
 };
+
+/**
+ * The 1-based line number of a position in `sourceFile`, counted the way
+ * ts-morph's `getStartLineNumber` and `getLineAndColumnAtPos` count it: one
+ * plus the number of `\n` before the position (a lone `\r` starts no line,
+ * unlike in the compiler's own line map).
+ *
+ * ts-morph scans the text from its start on every call, which made this
+ * check, asked of every node a transformer visits, quadratic in the size of the
+ * file. The newline positions are collected once per compiler source file
+ * instead. ts-morph replaces that object whenever the file is edited, so an
+ * entry never outlives the text it was collected from.
+ */
+const lineNumberLookup = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  sourceFile: tsm.ts.SourceFile,
+): ((pos: number) => number) => {
+  const cached = newlinePositionsCache.get(sourceFile);
+
+  const newlinePositions = cached ?? newlinePositionsOf(sourceFile.text);
+
+  if (cached === undefined) {
+    newlinePositionsCache.set(sourceFile, newlinePositions);
+  }
+
+  return (pos) => countLessThan(newlinePositions, pos) + 1;
+};
+
+const newlinePositionsCache = new WeakMap<
+  tsm.ts.SourceFile,
+  readonly number[]
+>();

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

@@ -30,6 +30,31 @@ export const isReadonlyArrayTypeNode = (
   node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword &&
   node.getTypeNode().isKind(tsm.SyntaxKind.ArrayType);
 
+export const isReadonlyTupleTypeNode = (
+  node: DeepReadonly<tsm.Node>,
+): node is ReadonlyTupleTypeNode =>
+  node.isKind(tsm.SyntaxKind.TypeOperator) &&
+  node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword &&
+  node.getTypeNode().isKind(tsm.SyntaxKind.TupleType);
+
+export const isReadonlyTypeReferenceNode = (
+  node: DeepReadonly<tsm.Node>,
+): node is ReadonlyTypeReferenceNode => {
+  if (!node.isKind(tsm.SyntaxKind.TypeReference)) {
+    return false;
+  }
+
+  const typeName = node.getTypeName();
+
+  const typeArguments = node.getTypeArguments();
+
+  return (
+    typeName.isKind(tsm.SyntaxKind.Identifier) &&
+    typeName.getText() === 'Readonly' &&
+    Arr.isFixedLengthArray(1, typeArguments)
+  );
+};
+
 // Helper to get a specific type node from source code
 const getTypeNodeFromSource = (
   sourceCode: string,
@@ -97,13 +122,6 @@ export type ReadonlyTupleTypeNode = tsm.TypeNode &
     getTypeNode: () => tsm.TupleTypeNode;
   }>;
 
-export const isReadonlyTupleTypeNode = (
-  node: DeepReadonly<tsm.Node>,
-): node is ReadonlyTupleTypeNode =>
-  node.isKind(tsm.SyntaxKind.TypeOperator) &&
-  node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword &&
-  node.getTypeNode().isKind(tsm.SyntaxKind.TupleType);
-
 if (import.meta.vitest !== undefined) {
   describe('isReadonlyTupleTypeNode', () => {
     test('should return true for readonly tuple type', () => {
@@ -162,24 +180,6 @@ export type ReadonlyTypeReferenceNode = tsm.TypeNode &
     getTypeArguments: () => readonly [tsm.TypeNode];
   }>;
 
-export const isReadonlyTypeReferenceNode = (
-  node: DeepReadonly<tsm.Node>,
-): node is ReadonlyTypeReferenceNode => {
-  if (!node.isKind(tsm.SyntaxKind.TypeReference)) {
-    return false;
-  }
-
-  const typeName = node.getTypeName();
-
-  const typeArguments = node.getTypeArguments();
-
-  return (
-    typeName.isKind(tsm.SyntaxKind.Identifier) &&
-    typeName.getText() === 'Readonly' &&
-    Arr.isFixedLengthArray(1, typeArguments)
-  );
-};
-
 if (import.meta.vitest !== undefined) {
   describe('isReadonlyTypeReferenceNode', () => {
     test('should return true for Readonly<T>', () => {