ts-codemod-lib 3.3.2 → 3.4.0

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

@@ -6,7 +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 { isString } from 'ts-data-forge';
+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,
@@ -64,15 +67,8 @@ const normalizeWhitespaceForComparison = (code: string): string => {
   // 1. Protect newlines immediately following line comments
   const protectedCode = code.replaceAll(
     /(\/\/.*?)\r?\n/gu,
-    // The strict standard library types a capture group as `unknown`: an
-    // optional group is `undefined` when it does not participate, so `string`
-    // is not something the signature can promise. This group is not optional,
-    // so the narrowing never actually fails — it just has to be written.
-    (match: string, ...args: readonly unknown[]): string => {
-      const comment = args[0];
-
-      return isString(comment) ? `${comment}${placeholder}` : match;
-    },
+    (match: string, comment: string | undefined): string =>
+      comment === undefined ? match : `${comment}${placeholder}`,
   );
 
   // 2. Collapse multiple whitespace characters (including unprotected newlines) into a single space
@@ -2839,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.test.mts

@@ -84,7 +84,7 @@ const transformInProject = (
  * off. A case that went through it therefore paid for the whole default
  * library, `lib.esnext.full.d.ts` with the DOM inside it, being parsed and
  * checked from scratch: ~300 ms a case, of which the file under test was a
- * fraction of a millisecond. Sixty of those took `test:cov` past Vitest's
+ * fraction of a millisecond. Sixty of those took `check:test:cov` past Vitest's
  * timeout on CI.
  *
  * Reusing the project is half of the answer and the smaller half — measured,

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

@@ -44,9 +44,7 @@ const processDeclarations = (
 
     const typeNode = typeAlias.getTypeNode();
 
-    if (typeNode === undefined) return false;
-
-    return visitTypeNode(typeNode);
+    return typeNode !== undefined && visitTypeNode(typeNode);
   });
 
   const interfaceModifications = container
@@ -103,9 +101,7 @@ const processInterfaceDeclaration = (
     .map((property) => {
       const typeNode = property.getTypeNode();
 
-      if (typeNode === undefined) return false;
-
-      return visitTypeNode(typeNode);
+      return typeNode !== undefined && visitTypeNode(typeNode);
     })
     .includes(true);
 };
@@ -170,13 +166,13 @@ const visitTypeNode = (node: tsm.TypeNode): boolean => {
         if (tsm.Node.isPropertySignature(member)) {
           const typeNode = member.getTypeNode();
 
-          return typeNode === undefined ? false : visitTypeNode(typeNode);
+          return typeNode !== undefined && visitTypeNode(typeNode);
         }
 
         if (tsm.Node.isIndexSignatureDeclaration(member)) {
           const typeNode = member.getReturnTypeNode();
 
-          return typeNode === undefined ? false : visitTypeNode(typeNode);
+          return typeNode !== undefined && visitTypeNode(typeNode);
         }
 
         return false;
@@ -202,19 +198,12 @@ const visitTypeNode = (node: tsm.TypeNode): boolean => {
   }
 
   // Handles `readonly T[]`, `readonly [...]`, `keyof T`
-  if (tsm.Node.isTypeOperatorTypeNode(node)) {
-    return visitTypeNode(node.getTypeNode());
-  }
-
-  if (tsm.Node.isRestTypeNode(node)) {
-    return visitTypeNode(node.getTypeNode());
-  }
-
-  if (tsm.Node.isNamedTupleMember(node)) {
-    return visitTypeNode(node.getTypeNode());
-  }
-
-  return false;
+  return (
+    (tsm.Node.isTypeOperatorTypeNode(node) ||
+      tsm.Node.isRestTypeNode(node) ||
+      tsm.Node.isNamedTupleMember(node)) &&
+    visitTypeNode(node.getTypeNode())
+  );
 };
 
 const isStringUnknownIndexSignature = (
@@ -305,7 +294,9 @@ const ensureUnknownRecordImport = (sourceFile: tsm.SourceFile): void => {
     .getNamedImports()
     .some((ni) => ni.getName() === UNKNOWN_RECORD_NAME);
 
-  if (alreadyImported) return;
+  if (alreadyImported) {
+    return;
+  }
 
   existingImport.addNamedImport({
     name: UNKNOWN_RECORD_NAME,

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

@@ -2,80 +2,179 @@ import { Arr } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
 import { type TsMorphTransformer } from './types.mjs';
 
-const extractFileIgnoreTransformers = (code: string): readonly string[] => {
-  // Try to find any of the supported file-level ignore comment prefixes
-  const patterns = [
-    {
-      prefix: 'transformer-ignore',
-      regex: /\/\*\s*transformer-ignore\s*(.*?)\s*\*\//u,
-    },
-    {
-      prefix: 'ts-codemod-ignore',
-      regex: /\/\*\s*ts-codemod-ignore\s*(.*?)\s*\*\//u,
-    },
-    {
-      prefix: 'codemod-ignore',
-      regex: /\/\*\s*codemod-ignore\s*(.*?)\s*\*\//u,
-    },
-    {
-      prefix: 'transform-ignore',
-      regex: /\/\*\s*transform-ignore\s*(.*?)\s*\*\//u,
-    },
-  ] as const;
+const fileIgnorePrefixes = [
+  'transformer-ignore',
+  'ts-codemod-ignore',
+  'codemod-ignore',
+  '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 = (
+  code: string,
+): readonly string[] | undefined => {
+  for (const prefix of fileIgnorePrefixes) {
+    const names = findFileIgnoreComment(code, prefix);
+
+    if (names !== undefined) {
+      return names;
+    }
+  }
 
-  for (const { regex } of patterns) {
-    const match = regex.exec(code);
+  return undefined;
+};
 
-    if (match !== null) {
-      const targetTransformers = match[1]?.trim() ?? '';
+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),
+  );
 
-      // Empty means ignore all transformers
-      if (targetTransformers === '') {
-        return [];
-      }
+  const findLineTerminator = createForwardSearch((from) =>
+    indexOfLineTerminator(code, from),
+  );
+
+  const trimEndBefore = createLastValueCache((commentEnd: number) =>
+    skipWhitespaceBackward(code, commentEnd),
+  );
+
+  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;
+    }
+
+    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));
 
-      // Parse comma-separated transformer names
-      return targetTransformers.split(',').map((name) => name.trim());
+    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 [];
+  return undefined;
 };
 
 const shouldSkipFile = (
-  code: string,
-  transformerName: string | undefined,
-): boolean => {
-  const ignoredTransformers = extractFileIgnoreTransformers(code);
-
-  // If no file-level ignore comment found, don't skip
-  const patterns = [
-    /\/\*\s*transformer-ignore\s*.*?\s*\*\//u,
-    /\/\*\s*ts-codemod-ignore\s*.*?\s*\*\//u,
-    /\/\*\s*codemod-ignore\s*.*?\s*\*\//u,
-    /\/\*\s*transform-ignore\s*.*?\s*\*\//u,
-  ] as const;
-
-  const hasFileIgnoreComment = patterns.some((regex) => regex.test(code));
-
-  if (!hasFileIgnoreComment && Arr.isEmpty(ignoredTransformers)) {
-    return false;
+  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`.
+ */
+const createForwardSearch = (
+  search: (from: number) => number,
+): ((from: number) => number) => {
+  let mut_from = Number.POSITIVE_INFINITY;
+
+  let mut_found = -1;
+
+  return (from) => {
+    if (from < mut_from || (mut_found !== -1 && from > mut_found)) {
+      mut_from = from;
+
+      mut_found = search(from);
+    }
+
+    return mut_found;
+  };
+};
+
+const createLastValueCache = (
+  fn: (arg: number) => number,
+): ((arg: number) => number) => {
+  let mut_arg: number | undefined = undefined;
+
+  let mut_value = 0;
+
+  return (arg) => {
+    if (arg !== mut_arg) {
+      mut_arg = arg;
+
+      mut_value = fn(arg);
+    }
+
+    return mut_value;
+  };
+};
+
+const skipWhitespace = (code: string, from: number): number => {
+  let mut_index = from;
+
+  while (mut_index < code.length && isWhitespace(code[mut_index])) {
+    mut_index += 1;
   }
 
-  // Empty array means ignore all transformers (file-level ignore without specific transformers)
-  if (Arr.isEmpty(ignoredTransformers)) {
-    return true;
+  return mut_index;
+};
+
+const skipWhitespaceBackward = (code: string, end: number): number => {
+  let mut_index = end;
+
+  while (mut_index > 0 && isWhitespace(code[mut_index - 1])) {
+    mut_index -= 1;
   }
 
-  // If transformer name is not specified, don't skip
-  if (transformerName === undefined) {
-    return false;
+  return mut_index;
+};
+
+const indexOfLineTerminator = (code: string, from: number): number => {
+  let mut_index = from;
+
+  while (mut_index < code.length && !isLineTerminator(code[mut_index])) {
+    mut_index += 1;
   }
 
-  // Check if the transformer is in the ignore list
-  return ignoredTransformers.includes(transformerName);
+  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 = (
   code: string,
   isTsx: boolean,
@@ -96,10 +195,12 @@ export const transformSourceCode = (
     code,
   );
 
+  const ignoredTransformers = findFileIgnoreTransformers(code);
+
   for (const transformer of transformers) {
     const transformerName = transformer.name;
 
-    if (shouldSkipFile(code, transformerName)) {
+    if (shouldSkipFile(ignoredTransformers, transformerName)) {
       if (debug) {
         console.debug(
           `skipped by ignore-file comment for transformer: ${transformerName}`,