ts-codemod-lib 3.3.0 → 3.3.2

package/src/functions/ast-transformers/enable-no-unchecked-indexed-access.test.mts

@@ -12,8 +12,12 @@ import { transformSourceCode } from './transform-source-code.mjs';
  * Declarations every case is prefixed with, so that each `source` can be a
  * single expression statement. `declare const` keeps them free of index
  * accesses of their own.
+ *
+ * `console` is among them because {@link project} loads only the libraries
+ * these cases need, and the one that declares `console` is not one of them.
  */
 const preamble = dedent`
+  declare const console: { log: (...args: readonly unknown[]) => void };
   declare const xs: readonly number[];
   declare const mut_ys: number[];
   declare const pair: readonly [number, number];
@@ -47,9 +51,7 @@ const testFn = async ({
   }
 
   const transformed = await formatter(
-    transformSourceCode(`${preamble}\n\n${source}`, false, [
-      enableNoUncheckedIndexedAccessTransformer({ ...options, debug }),
-    ]),
+    transformInProject(`${preamble}\n\n${source}`, { ...options, debug }),
   );
 
   const expectedFormatted = await formatter(`${preamble}\n\n${expected}`);
@@ -57,6 +59,54 @@ const testFn = async ({
   expect(transformed).toBe(expectedFormatted);
 };
 
+/**
+ * Runs the transformer over `code` in {@link project}, and returns what it
+ * made of it.
+ */
+const transformInProject = (
+  code: string,
+  options?: Parameters<typeof enableNoUncheckedIndexedAccessTransformer>[0],
+): string => {
+  const sourceAst = project.createSourceFile('source.ts', code, {
+    overwrite: true,
+  });
+
+  enableNoUncheckedIndexedAccessTransformer(options).transform(sourceAst);
+
+  return sourceAst.getFullText();
+};
+
+/**
+ * The one project every case is checked in, rather than one project per case.
+ *
+ * `transformSourceCode` builds a project per call, and this transformer checks
+ * the file twice — once with `noUncheckedIndexedAccess` on and once with it
+ * 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
+ * timeout on CI.
+ *
+ * Reusing the project is half of the answer and the smaller half — measured,
+ * it takes a case from ~300 ms to ~260 ms, because what an edit invalidates is
+ * the program, not the parsed library behind it. Naming the libraries the
+ * cases actually need is the rest: together they bring a case to ~25 ms.
+ *
+ * What that leaves out — `transformSourceCode` itself, and the transformer
+ * against the full library — is what the tests at the bottom of this file
+ * still cover.
+ */
+const project = new tsm.Project({
+  useInMemoryFileSystem: true,
+  compilerOptions: {
+    target: tsm.ts.ScriptTarget.ESNext,
+    module: tsm.ts.ModuleKind.ESNext,
+    // `es2015` rather than `es5` for `Symbol.iterator`, which the spread and
+    // `for-of` cases need at this target.
+    lib: ['lib.es2015.d.ts'],
+  },
+});
+
 const formatter = (code: string): Promise<string> =>
   prettier.format(code, {
     parser: 'typescript',
@@ -456,6 +506,8 @@ describe(enableNoUncheckedIndexedAccessTransformer, () => {
 
   test('the errors the option introduces are gone from the result', () => {
     const source = dedent`
+      declare const console: { log: (...args: readonly unknown[]) => void };
+
       const parseRoute = (path: string): string => {
         const parts = path.split('/');
 
@@ -484,11 +536,7 @@ describe(enableNoUncheckedIndexedAccessTransformer, () => {
     expect(diagnosticsUnderTheOption(source).length).toBeGreaterThan(0);
 
     assert.deepStrictEqual(
-      diagnosticsUnderTheOption(
-        transformSourceCode(source, false, [
-          enableNoUncheckedIndexedAccessTransformer(),
-        ]),
-      ),
+      diagnosticsUnderTheOption(transformInProject(source)),
       [],
     );
   });
@@ -542,19 +590,9 @@ describe(enableNoUncheckedIndexedAccessTransformer, () => {
 });
 
 /** The compiler's own verdict on the code, with the option this transformer prepares for turned on. */
-const diagnosticsUnderTheOption = (code: string): readonly string[] => {
-  const project = new tsm.Project({
-    useInMemoryFileSystem: true,
-    compilerOptions: {
-      target: tsm.ts.ScriptTarget.ESNext,
-      module: tsm.ts.ModuleKind.ESNext,
-      strict: true,
-      noUncheckedIndexedAccess: true,
-    },
-  });
-
-  return project
-    .createSourceFile('source.ts', code)
+const diagnosticsUnderTheOption = (code: string): readonly string[] =>
+  diagnosticsProject
+    .createSourceFile('source.ts', code, { overwrite: true })
     .getPreEmitDiagnostics()
     .map((diagnostic) => diagnostic.getMessageText())
     .map((messageText) =>
@@ -562,4 +600,20 @@ const diagnosticsUnderTheOption = (code: string): readonly string[] => {
         ? messageText
         : messageText.getMessageText(),
     );
-};
+
+/**
+ * A second project, because {@link project} has to start with the option off,
+ * and reused for the reason that one is. `getPreEmitDiagnostics` checks the
+ * whole program rather than one expression, so the library it is pointed at
+ * costs more here than anywhere else in this file.
+ */
+const diagnosticsProject = new tsm.Project({
+  useInMemoryFileSystem: true,
+  compilerOptions: {
+    target: tsm.ts.ScriptTarget.ESNext,
+    module: tsm.ts.ModuleKind.ESNext,
+    lib: ['lib.es2015.d.ts'],
+    strict: true,
+    noUncheckedIndexedAccess: true,
+  },
+});

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

@@ -1,5 +1,6 @@
 import * as tsm from 'ts-morph';
 import {
+  hasCallOrConstructSignature,
   isAtomicTypeNode,
   isReadonlyTupleOrArrayTypeNode,
   isReadonlyTypeReferenceNode,
@@ -121,8 +122,14 @@ export const groupUnionIntersectionTypes = (
       continue;
     }
 
+    // A type literal that declares a call or construct signature is deliberately
+    // not grouped here: this group is joined and wrapped in a single
+    // `Readonly<...>`, which such a literal does not survive. It falls through
+    // to `others`, which leaves it as written. See
+    // `hasCallOrConstructSignature`.
     if (
-      t.isKind(tsm.SyntaxKind.TypeLiteral) ||
+      (t.isKind(tsm.SyntaxKind.TypeLiteral) &&
+        !hasCallOrConstructSignature(t)) ||
       isReadonlyTypeReferenceNode(t)
     ) {
       if (mut_grouped.typeLiterals === undefined) {

package/src/functions/functions/has-call-or-construct-signature.mts

@@ -0,0 +1,120 @@
+import * as tsm from 'ts-morph';
+
+/**
+ * Determines whether a node is a type literal or an interface that declares a
+ * call or construct signature.
+ *
+ * `Readonly<T>` is a mapped type over `keyof T`, and neither signature kind is a
+ * property, so neither survives the mapping: wrapping `{ (x: string): void }`
+ * with `Readonly` produces a type that is no longer callable. A type mixing
+ * properties with a call signature is worse still — the properties come through
+ * and only the signature disappears. So a type literal carrying one must not be
+ * wrapped; its members are marked `readonly` in place instead.
+ *
+ * @param node - The node to check
+ * @returns true if the node declares at least one call or construct signature,
+ *   false for any other node kind
+ */
+export const hasCallOrConstructSignature = (node: tsm.Node): boolean =>
+  (node.isKind(tsm.SyntaxKind.TypeLiteral) ||
+    node.isKind(tsm.SyntaxKind.InterfaceDeclaration)) &&
+  node
+    .getMembers()
+    .some(
+      (member) =>
+        member.isKind(tsm.SyntaxKind.CallSignature) ||
+        member.isKind(tsm.SyntaxKind.ConstructSignature),
+    );
+
+if (import.meta.vitest !== undefined) {
+  const getFirstNodeOfKind = (
+    sourceCode: string,
+    kind: tsm.SyntaxKind,
+  ): tsm.Node => {
+    const project = new tsm.Project({ useInMemoryFileSystem: true });
+
+    const sourceFile = project.createSourceFile('test.ts', sourceCode);
+
+    return sourceFile.getFirstDescendantByKindOrThrow(kind);
+  };
+
+  const getTypeLiteral = (sourceCode: string): tsm.Node =>
+    getFirstNodeOfKind(sourceCode, tsm.SyntaxKind.TypeLiteral);
+
+  describe('hasCallOrConstructSignature', () => {
+    test.each([
+      { name: 'call signature', code: 'type T = { (a: string): void };' },
+      { name: 'construct signature', code: 'type T = { new (a: string): X };' },
+      {
+        name: 'call signature mixed with a property',
+        code: 'type T = { (a: string): void; b: number };',
+      },
+      {
+        name: 'overloaded call signatures',
+        code: 'type T = { (a: string): void; (a: number): void };',
+      },
+    ])('is true for a type literal with a $name', ({ code }) => {
+      assert.isTrue(hasCallOrConstructSignature(getTypeLiteral(code)));
+    });
+
+    test.each([
+      { name: 'properties only', code: 'type T = { a: number; b: string };' },
+      { name: 'an index signature', code: 'type T = { [k: string]: number };' },
+      {
+        name: 'a method signature',
+        code: 'type T = { a(b: string): void };',
+      },
+      {
+        name: 'a function-typed property',
+        code: 'type T = { a: (b: string) => void };',
+      },
+      { name: 'no members', code: 'type T = {};' },
+    ])('is false for a type literal with $name', ({ code }) => {
+      assert.isFalse(hasCallOrConstructSignature(getTypeLiteral(code)));
+    });
+
+    test('is true for an interface with a call signature', () => {
+      assert.isTrue(
+        hasCallOrConstructSignature(
+          getFirstNodeOfKind(
+            'interface I { (a: string): void }',
+            tsm.SyntaxKind.InterfaceDeclaration,
+          ),
+        ),
+      );
+    });
+
+    test('is false for an interface without one', () => {
+      assert.isFalse(
+        hasCallOrConstructSignature(
+          getFirstNodeOfKind(
+            'interface I { a: string }',
+            tsm.SyntaxKind.InterfaceDeclaration,
+          ),
+        ),
+      );
+    });
+
+    test.each([
+      {
+        name: 'a function type',
+        code: 'type T = (a: string) => void;',
+        kind: tsm.SyntaxKind.FunctionType,
+      },
+      {
+        name: 'a constructor type',
+        code: 'type T = new (a: string) => X;',
+        kind: tsm.SyntaxKind.ConstructorType,
+      },
+      {
+        name: 'a class declaration',
+        code: 'class C { constructor(a: string) {} }',
+        kind: tsm.SyntaxKind.ClassDeclaration,
+      },
+    ])('is false for $name', ({ code, kind }) => {
+      assert.isFalse(
+        hasCallOrConstructSignature(getFirstNodeOfKind(code, kind)),
+      );
+    });
+  });
+}

package/src/functions/functions/index.mts

@@ -1,3 +1,4 @@
+export * from './has-call-or-construct-signature.mjs';
 export * from './has-disable-next-line-comment.mjs';
 export * from './is-as-const-node.mjs';
 export * from './is-atomic-type-node.mjs';

package/src/functions/functions/wrap-with-parentheses.mts

@@ -1,16 +1,6 @@
-/**
- * Checks if a string is already wrapped with a single pair of balanced parentheses
- * that encompasses the entire expression.
- *
- * @example
- * isWrappedWithParentheses('(A)') // true
- * isWrappedWithParentheses('((A))') // true (outer pair wraps everything)
- * isWrappedWithParentheses('(A) | (B)') // false (outer parens don't wrap everything)
- * isWrappedWithParentheses('A') // false
- */
 import { asUint32, range } from 'ts-data-forge';
 
-const parenDepthDelta = (char: string): number => {
+const parenDepthDelta = (char: string | undefined): number => {
   switch (char) {
     case '(':
       return 1;
@@ -18,11 +8,27 @@ const parenDepthDelta = (char: string): number => {
     case ')':
       return -1;
 
+    // `at` returns `undefined` past the end of the string. The loop below
+    // never asks for such an index, but the type says it can.
+    case undefined:
     default:
       return 0;
   }
 };
 
+/**
+ * Checks if a string is already wrapped with a single pair of balanced
+ * parentheses that encompasses the entire expression.
+ *
+ * `'(A)'` and `'((A))'` are wrapped — in the second the outer pair still spans
+ * everything — while `'A'` is not, and neither is `'(A) | (B)'`, whose first
+ * parenthesis closes before the end.
+ *
+ * Module-local, so `samples/` — which imports the package the way a consumer
+ * does — cannot reach it, and it therefore carries no `@example`. See
+ * {@link wrapWithParentheses}, the exported form, whose example covers the
+ * same cases.
+ */
 const isWrappedWithParentheses = (str: string): boolean => {
   const trimmed = str.trim();
 
@@ -35,7 +41,7 @@ const isWrappedWithParentheses = (str: string): boolean => {
   let mut_depth = 0;
 
   for (const mut_i of range(0, asUint32(trimmed.length))) {
-    mut_depth += parenDepthDelta(trimmed.charAt(mut_i));
+    mut_depth += parenDepthDelta(trimmed.at(mut_i));
 
     // If we reach depth 0 before the end, the outer parentheses don't wrap everything
     if (mut_depth === 0 && mut_i < trimmed.length - 1) {
@@ -52,11 +58,20 @@ const isWrappedWithParentheses = (str: string): boolean => {
  * fully wrapped with balanced parentheses.
  *
  * @example
- * wrapWithParentheses('A') // '(A)'
- * wrapWithParentheses('(A)') // '(A)' (not '((A))')
- * wrapWithParentheses('A | B') // '(A | B)'
- * wrapWithParentheses('(A | B)') // '(A | B)' (not '((A | B))')
- * wrapWithParentheses('(A) | (B)') // '((A) | (B))' (needs outer parens)
+ *
+ * ```ts
+ * assert.deepStrictEqual(wrapWithParentheses('A'), '(A)');
+ *
+ * // already wrapped, so not '((A))'
+ * assert.deepStrictEqual(wrapWithParentheses('(A)'), '(A)');
+ *
+ * assert.deepStrictEqual(wrapWithParentheses('A | B'), '(A | B)');
+ *
+ * assert.deepStrictEqual(wrapWithParentheses('(A | B)'), '(A | B)');
+ *
+ * // the outer parentheses do not span everything, so a pair is added
+ * assert.deepStrictEqual(wrapWithParentheses('(A) | (B)'), '((A) | (B))');
+ * ```
  */
 export const wrapWithParentheses = (nodeStr: string): string => {
   const trimmed = nodeStr.trim();