ts-codemod-lib 4.0.0 → 4.1.0

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

@@ -14,39 +14,6 @@ import {
 } from './convert-to-readonly.mjs';
 import { transformSourceCode } from './transform-source-code.mjs';
 
-const testFn = async ({
-  source,
-  expected,
-  debug,
-  options,
-  isTsx = false,
-}: Readonly<{
-  source: string;
-  expected: string;
-  debug?: boolean;
-  options?: ReadonlyTransformerOptions;
-  isTsx?: boolean;
-}>): Promise<void> => {
-  if (debug !== true) {
-    // eslint-disable-next-line vitest/no-restricted-vi-methods
-    vi.spyOn(console, 'debug').mockImplementation(() => {});
-
-    // eslint-disable-next-line vitest/no-restricted-vi-methods
-    vi.spyOn(console, 'log').mockImplementation(() => {});
-
-    // eslint-disable-next-line vitest/no-restricted-vi-methods
-    vi.spyOn(console, 'trace').mockImplementation(() => {});
-  }
-
-  const transformedCodeRaw = await formatter(
-    transformSourceCode(source, isTsx, [convertToReadonlyTransformer(options)]),
-  );
-
-  const expectedFormatted = await formatter(expected);
-
-  expect(transformedCodeRaw).toBe(expectedFormatted);
-};
-
 /**
  * Normalizes whitespace in a code string, primarily for comparing AST structure outputs.
  * - Preserves newlines immediately following line comments (`//`).
@@ -93,6 +60,39 @@ const formatter = async (code: string): Promise<string> => {
   });
 };
 
+const testFn = async ({
+  source,
+  expected,
+  debug,
+  options,
+  isTsx = false,
+}: Readonly<{
+  source: string;
+  expected: string;
+  debug?: boolean;
+  options?: ReadonlyTransformerOptions;
+  isTsx?: boolean;
+}>): Promise<void> => {
+  if (debug !== true) {
+    // eslint-disable-next-line vitest/no-restricted-vi-methods
+    vi.spyOn(console, 'debug').mockImplementation(() => {});
+
+    // eslint-disable-next-line vitest/no-restricted-vi-methods
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    // eslint-disable-next-line vitest/no-restricted-vi-methods
+    vi.spyOn(console, 'trace').mockImplementation(() => {});
+  }
+
+  const transformedCodeRaw = await formatter(
+    transformSourceCode(source, isTsx, [convertToReadonlyTransformer(options)]),
+  );
+
+  const expectedFormatted = await formatter(expected);
+
+  expect(transformedCodeRaw).toBe(expectedFormatted);
+};
+
 describe(convertToReadonlyTransformer, () => {
   describe('TypeReferences', () => {
     describe('Sets', () => {
@@ -215,6 +215,13 @@ describe(convertToReadonlyTransformer, () => {
 
     describe('Records', () => {
       describe('recordStyle: "ReadonlyRecord" (default)', () => {
+        // These sources are scripts, which get `Readonly<Record<K, V>>` unless
+        // the name is in scope; how it is brought into scope is tested in
+        // convert-to-readonly-record-import.test.mts.
+        const options = {
+          importStyle: 'global',
+        } as const satisfies ReadonlyTransformerOptions;
+
         test.each([
           {
             name: 'Type alias',
@@ -224,6 +231,7 @@ describe(convertToReadonlyTransformer, () => {
             expected: dedent`
               type Foo = ReadonlyRecord<string, number>
             `,
+            options,
           },
           {
             name: 'ReadonlyRecord<K, V> is unchanged',
@@ -233,6 +241,7 @@ describe(convertToReadonlyTransformer, () => {
             expected: dedent`
               type Foo = ReadonlyRecord<string, number>
             `,
+            options,
           },
           {
             name: 'Readonly<Record<K, V>> is unified to ReadonlyRecord<K, V>',
@@ -242,6 +251,7 @@ describe(convertToReadonlyTransformer, () => {
             expected: dedent`
               type Foo = ReadonlyRecord<string, number>
             `,
+            options,
           },
           {
             name: 'Redundant Readonly<ReadonlyRecord<K, V>> is normalized',
@@ -251,6 +261,7 @@ describe(convertToReadonlyTransformer, () => {
             expected: dedent`
               type Foo = ReadonlyRecord<string, number>
             `,
+            options,
           },
           {
             name: 'Value type is converted recursively',
@@ -260,6 +271,7 @@ describe(convertToReadonlyTransformer, () => {
             expected: dedent`
               type Foo = ReadonlyRecord<string, readonly number[]>
             `,
+            options,
           },
           {
             name: 'Value type inside Readonly<Record<K, V>> is converted recursively',
@@ -269,6 +281,7 @@ describe(convertToReadonlyTransformer, () => {
             expected: dedent`
               type Foo = ReadonlyRecord<string, readonly number[]>
             `,
+            options,
           },
           {
             name: 'Value type inside ReadonlyRecord<K, V> is converted recursively',
@@ -278,6 +291,7 @@ describe(convertToReadonlyTransformer, () => {
             expected: dedent`
               type Foo = ReadonlyRecord<string, readonly number[]>
             `,
+            options,
           },
           {
             name: 'In type literal member',
@@ -287,6 +301,7 @@ describe(convertToReadonlyTransformer, () => {
             expected: dedent`
               type Foo = Readonly<{ a: ReadonlyRecord<string, number> }>
             `,
+            options,
           },
           {
             name: 'In function args',
@@ -296,6 +311,7 @@ describe(convertToReadonlyTransformer, () => {
             expected: dedent`
               function foo(a: ReadonlyRecord<string, number>, b: Promise<ReadonlyRecord<string, number>>) {}
             `,
+            options,
           },
           {
             name: 'DeepReadonly<Record<K, V>> is unchanged',
@@ -305,6 +321,7 @@ describe(convertToReadonlyTransformer, () => {
             expected: dedent`
               type Foo = DeepReadonly<Record<string, number[]>>
             `,
+            options,
           },
           {
             name: 'DeepReadonly<ReadonlyRecord<K, V>> is unchanged',
@@ -314,6 +331,7 @@ describe(convertToReadonlyTransformer, () => {
             expected: dedent`
               type Foo = DeepReadonly<ReadonlyRecord<string, number>>
             `,
+            options,
           },
           {
             name: 'Record<K, V> under indexed access is kept as is',
@@ -323,6 +341,7 @@ describe(convertToReadonlyTransformer, () => {
             expected: dedent`
               type Foo = Record<string, number>[string]
             `,
+            options,
           },
           {
             name: 'ReadonlyRecord<K, V> under indexed access is unchanged',
@@ -332,6 +351,7 @@ describe(convertToReadonlyTransformer, () => {
             expected: dedent`
               type Foo = ReadonlyRecord<string, number>[string]
             `,
+            options,
           },
         ])('$name', testFn);
       });
@@ -788,6 +808,33 @@ describe(convertToReadonlyTransformer, () => {
           function foo(a: readonly number[], b: Promise<readonly number[]>) {}
         `,
       },
+      {
+        name: 'Array<T> whose element type has a parenthesis inside a string literal type',
+        source: dedent`
+          type T = Array<(A | '(') | (B)>;
+        `,
+        expected: dedent`
+          type T = readonly ((A | '(') | (B))[];
+        `,
+      },
+      {
+        name: 'Array<T> whose element type has a parenthesis inside a comment',
+        source: dedent`
+          type T = Array<(A | /* ( */ C) | (B)>;
+        `,
+        expected: dedent`
+          type T = readonly ((A | /* ( */ C) | (B))[];
+        `,
+      },
+      {
+        name: 'Array<T> whose element type has a parenthesis inside a template literal type',
+        source: dedent`
+          type T = Array<(\`(\${A}\` | C) | (B)>;
+        `,
+        expected: dedent`
+          type T = readonly ((\`(\${A}\` | C) | (B))[];
+        `,
+      },
       {
         name: 'Mutable array types in function args (generic)',
         source: dedent`

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

@@ -9,15 +9,15 @@ const TRANSFORMER_NAME = 'enable-no-unchecked-indexed-access';
 /**
  * Appends `!` to the index accesses that turning on the
  * [`noUncheckedIndexedAccess`](https://www.typescriptlang.org/tsconfig/#noUncheckedIndexedAccess)
- * compiler option would turn into type errors, as a stopgap while the option
- * is being enabled.
+ * compiler option would turn into type errors, as a stopgap while the option is
+ * being enabled.
  *
  * The rewrite is driven by the type checker rather than by syntax: the file is
  * checked twice, once with `noUncheckedIndexedAccess` off and once with it on,
  * and `!` is appended only where the option is what added `undefined` to the
  * expression's type. Consequently an index whose presence the type already
- * guarantees keeps its access untouched — `[T, T][1]`, `[T, T, ...T[]][0]`,
- * and `({ a: T })['a']` are all left as they are, as is an element type that
+ * guarantees keeps its access untouched — `[T, T][1]`, `[T, T, ...T[]][0]`, and
+ * `({ a: T })['a']` are all left as they are, as is an element type that
  * contained `undefined` to begin with.
  *
  * Both spellings of an index read are covered, because the option widens both:
@@ -31,10 +31,10 @@ const TRANSFORMER_NAME = 'enable-no-unchecked-indexed-access';
  * on its own — which is how {@link transformSourceCode} drives every
  * transformer here — resolves neither a type from another module nor a
  * narrowing that depends on an imported type guard, and the latter produces
- * assertions a whole-program check does not need. Most of those are reported
- * by `@typescript-eslint/no-unnecessary-type-assertion`, whose fixer removes
- * them; what no rule can see is an assertion that makes a later check dead,
- * as the `if` of `const v = xs[0]!; if (v === undefined) …` now is.
+ * assertions a whole-program check does not need. Most of those are reported by
+ * `@typescript-eslint/no-unnecessary-type-assertion`, whose fixer removes them;
+ * what no rule can see is an assertion that makes a later check dead, as the
+ * `if` of `const v = xs[0]!; if (v === undefined) …` now is.
  *
  * @example
  *
@@ -91,9 +91,9 @@ export const enableNoUncheckedIndexedAccessTransformer = (
         return;
       }
 
-      // One text edit for the whole file: `insertText` forgets every
-      // descendant node, so inserting one `!` at a time would reparse the
-      // file once per assertion.
+      // One text edit for the whole file: `insertText` forgets every descendant
+      // node, so inserting one `!` at a time would reparse the file once per
+      // assertion.
       sourceAst.replaceText(
         [0, sourceAst.getEnd()],
         insertNonNullAssertions(sourceAst.getFullText(), positions),
@@ -134,102 +134,6 @@ type EnableNoUncheckedIndexedAccessTransformerOptionsInternal = DeepReadonly<{
 type IndexReadExpression =
   tsm.ElementAccessExpression | tsm.PropertyAccessExpression;
 
-/**
- * Returns the positions at which a `!` has to be inserted, i.e. the end
- * offsets of the reads whose type `noUncheckedIndexedAccess` widens with
- * `undefined`.
- */
-const collectAssertionPositions = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  sourceAst: tsm.SourceFile,
-  options: EnableNoUncheckedIndexedAccessTransformerOptionsInternal,
-): readonly number[] => {
-  const candidates: readonly IndexReadExpression[] = [
-    ...sourceAst.getDescendantsOfKind(tsm.SyntaxKind.ElementAccessExpression),
-    ...sourceAst.getDescendantsOfKind(tsm.SyntaxKind.PropertyAccessExpression),
-  ].filter(
-    (node) => isAssertableReadPosition(node) && !isIgnoredByComment(node),
-  );
-
-  if (Arr.isEmpty(candidates)) {
-    return [];
-  }
-
-  const project = sourceAst.getProject();
-
-  const originalOptions = project.getCompilerOptions();
-
-  try {
-    // With the option on first, because that narrows the candidates down to
-    // the few reads worth checking a second time. `strictNullChecks` comes
-    // with it: `noUncheckedIndexedAccess` does nothing without it, and the
-    // project handed to the transformer may not have it on.
-    project.compilerOptions.set({
-      strictNullChecks: true,
-      noUncheckedIndexedAccess: true,
-    });
-
-    // The type asked is the access's own, so an `as`, `satisfies` or `!` on
-    // its object is already in it. That is the type the option's error is
-    // reported against, and the `!` appended has no run-time effect for the
-    // unwrapped object to contradict.
-    const widened = candidates.filter(
-      (node) =>
-        typeIncludesUndefined(node.getType()) &&
-        !(
-          options.applyLevel === 'avoidWhereUndefinedIsAllowed' &&
-          contextAcceptsUndefined(node)
-        ),
-    );
-
-    if (Arr.isEmpty(widened)) {
-      return [];
-    }
-
-    project.compilerOptions.set({ noUncheckedIndexedAccess: false });
-
-    // What is possibly `undefined` without the option too is not the option's
-    // doing — the element type says so, or the expression is erroneous (an
-    // unresolved import resolves to `any`, which is never widened).
-    return widened
-      .filter((node) => !typeIncludesUndefined(node.getType()))
-      .map((node) => {
-        options.debugPrint(`${node.getText()} -> ${node.getText()}!`);
-
-        return node.getEnd();
-      });
-  } finally {
-    // `set` merges, so the two options overridden above have to be named
-    // explicitly: they are absent from `originalOptions` when the project did
-    // not carry them, and would otherwise stay overridden for whichever
-    // transformer runs next.
-    project.compilerOptions.set({
-      ...originalOptions,
-      strictNullChecks: originalOptions.strictNullChecks,
-      noUncheckedIndexedAccess: originalOptions.noUncheckedIndexedAccess,
-    });
-  }
-};
-
-const insertNonNullAssertions = (
-  fullText: string,
-  positions: readonly number[],
-): string => {
-  const mut_parts: string[] = [];
-
-  let mut_restStart: number = 0;
-
-  for (const position of positions.toSorted((a, b) => a - b)) {
-    mut_parts.push(fullText.slice(mut_restStart, position), '!');
-
-    mut_restStart = position;
-  }
-
-  mut_parts.push(fullText.slice(mut_restStart));
-
-  return mut_parts.join('');
-};
-
 const typeIncludesUndefined = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   type: tsm.Type,
@@ -238,9 +142,9 @@ const typeIncludesUndefined = (
   (type.isUnion() && type.getUnionTypes().some((t) => t.isUndefined()));
 
 /**
- * Whether the position the access sits in already accepts `undefined`, in
- * which case `noUncheckedIndexedAccess` reports nothing there and the
- * assertion would only be noise.
+ * Whether the position the access sits in already accepts `undefined`, in which
+ * case `noUncheckedIndexedAccess` reports nothing there and the assertion would
+ * only be noise.
  */
 const contextAcceptsUndefined = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
@@ -276,38 +180,6 @@ const isIgnoredByComment = (
   );
 };
 
-/**
- * Whether a `!` appended to this access would be both syntactically valid and
- * meaningful.
- *
- * Note that most write positions need no rule of their own: TypeScript gives
- * 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 outer = outermostParenthesized(node);
-
-  const parent = outer.getParent();
-
-  if (parent === undefined) {
-    return false;
-  }
-
-  return (
-    !isAlreadyAssertedOrGuarded(node, outer, parent) &&
-    !isWriteTarget(outer, parent) &&
-    !isTestedForAbsence(outer, parent)
-  );
-};
-
 /** `node`, or the outermost of the parentheses written around it. */
 const outermostParenthesized = (node: tsm.Node): tsm.Node => {
   const parent = node.getParent();
@@ -317,12 +189,38 @@ const outermostParenthesized = (node: tsm.Node): tsm.Node => {
     : node;
 };
 
+/**
+ * Whether the read sits in an optional chain that can short-circuit before it,
+ * as the `xs[0]?.toFixed` of `xs[0]?.toFixed()` does. `undefined` in such a
+ * type comes from the chain rather than from the index, and the chain already
+ * accounts for it; asserting there would assert away the author's own `?.`.
+ *
+ * Parentheses end a chain (`(a?.b).c` is not one), which is why the walk stops
+ * at anything that is not a chain link.
+ */
+const isInOptionalChain = (node: tsm.Node): boolean => {
+  if (
+    node.isKind(tsm.SyntaxKind.PropertyAccessExpression) ||
+    node.isKind(tsm.SyntaxKind.ElementAccessExpression) ||
+    node.isKind(tsm.SyntaxKind.CallExpression)
+  ) {
+    return (
+      node.hasQuestionDotToken() || isInOptionalChain(node.getExpression())
+    );
+  }
+
+  return (
+    node.isKind(tsm.SyntaxKind.NonNullExpression) &&
+    isInOptionalChain(node.getExpression())
+  );
+};
+
 /**
  * `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`).
+ * `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,
@@ -341,8 +239,8 @@ const isAlreadyAssertedOrGuarded = (
     return true;
   }
 
-  // Only the object of the optional chain is guarded; an index argument such
-  // as the `xs[0]` of `m?.[xs[0]]` is not.
+  // Only the object of the optional chain is guarded; an index argument such as
+  // the `xs[0]` of `m?.[xs[0]]` is not.
   return (
     (parent.isKind(tsm.SyntaxKind.PropertyAccessExpression) ||
       parent.isKind(tsm.SyntaxKind.ElementAccessExpression) ||
@@ -353,36 +251,19 @@ const isAlreadyAssertedOrGuarded = (
 };
 
 /**
- * Whether the read sits in an optional chain that can short-circuit before it,
- * as the `xs[0]?.toFixed` of `xs[0]?.toFixed()` does. `undefined` in such a
- * type comes from the chain rather than from the index, and the chain already
- * accounts for it; asserting there would assert away the author's own `?.`.
- *
- * Parentheses end a chain (`(a?.b).c` is not one), which is why the walk stops
- * at anything that is not a chain link.
+ * `=` through `^=`, i.e. every assignment operator. TypeScript keeps them in
+ * one contiguous block of {@link tsm.SyntaxKind} and marks its ends, which is
+ * how the compiler itself recognizes them.
  */
-const isInOptionalChain = (node: tsm.Node): boolean => {
-  if (
-    node.isKind(tsm.SyntaxKind.PropertyAccessExpression) ||
-    node.isKind(tsm.SyntaxKind.ElementAccessExpression) ||
-    node.isKind(tsm.SyntaxKind.CallExpression)
-  ) {
-    return (
-      node.hasQuestionDotToken() || isInOptionalChain(node.getExpression())
-    );
-  }
-
-  return (
-    node.isKind(tsm.SyntaxKind.NonNullExpression) &&
-    isInOptionalChain(node.getExpression())
-  );
-};
+const isAssignmentOperatorKind = (kind: tsm.SyntaxKind): boolean =>
+  tsm.SyntaxKind.FirstAssignment <= kind &&
+  kind <= tsm.SyntaxKind.LastAssignment;
 
 /**
  * Positions that write the value rather than read it, where `!` cannot be
- * appended at all: an assignment target is not an expression (`xs[0]! = 1`
- * does not parse as an assignment), and `delete xs[0]!` and `xs[0]!++` are
- * equally invalid.
+ * appended at all: an assignment target is not an expression (`xs[0]! = 1` does
+ * not parse as an assignment), and `delete xs[0]!` and `xs[0]!++` are equally
+ * invalid.
  *
  * `xs[0] += 1` is the one case this leaves a type error behind: its left-hand
  * side is read as well as written, so `noUncheckedIndexedAccess` reports it,
@@ -465,13 +346,131 @@ const isTestedForAbsence = (node: tsm.Node, parent: tsm.Node): boolean => {
 };
 
 /**
- * `=` through `^=`, i.e. every assignment operator. TypeScript keeps them in
- * one contiguous block of {@link tsm.SyntaxKind} and marks its ends, which is
- * how the compiler itself recognizes them.
+ * Whether a `!` appended to this access would be both syntactically valid and
+ * meaningful.
+ *
+ * Note that most write positions need no rule of their own: TypeScript gives
+ * 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 isAssignmentOperatorKind = (kind: tsm.SyntaxKind): boolean =>
-  tsm.SyntaxKind.FirstAssignment <= kind &&
-  kind <= tsm.SyntaxKind.LastAssignment;
+const isAssertableReadPosition = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: IndexReadExpression,
+): boolean => {
+  const outer = outermostParenthesized(node);
+
+  const parent = outer.getParent();
+
+  if (parent === undefined) {
+    return false;
+  }
+
+  return (
+    !isAlreadyAssertedOrGuarded(node, outer, parent) &&
+    !isWriteTarget(outer, parent) &&
+    !isTestedForAbsence(outer, parent)
+  );
+};
+
+/**
+ * Returns the positions at which a `!` has to be inserted, i.e. the end offsets
+ * of the reads whose type `noUncheckedIndexedAccess` widens with `undefined`.
+ */
+const collectAssertionPositions = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  sourceAst: tsm.SourceFile,
+  options: EnableNoUncheckedIndexedAccessTransformerOptionsInternal,
+): readonly number[] => {
+  const candidates: readonly IndexReadExpression[] = [
+    ...sourceAst.getDescendantsOfKind(tsm.SyntaxKind.ElementAccessExpression),
+    ...sourceAst.getDescendantsOfKind(tsm.SyntaxKind.PropertyAccessExpression),
+  ].filter(
+    (node) => isAssertableReadPosition(node) && !isIgnoredByComment(node),
+  );
+
+  if (Arr.isEmpty(candidates)) {
+    return [];
+  }
+
+  const project = sourceAst.getProject();
+
+  const originalOptions = project.getCompilerOptions();
+
+  try {
+    // With the option on first, because that narrows the candidates down to the
+    // few reads worth checking a second time. `strictNullChecks` comes with it:
+    // `noUncheckedIndexedAccess` does nothing without it, and the project
+    // handed to the transformer may not have it on.
+    project.compilerOptions.set({
+      strictNullChecks: true,
+      noUncheckedIndexedAccess: true,
+    });
+
+    // The type asked is the access's own, so an `as`, `satisfies` or `!` on its
+    // object is already in it. That is the type the option's error is reported
+    // against, and the `!` appended has no run-time effect for the unwrapped
+    // object to contradict.
+    const widened = candidates.filter(
+      (node) =>
+        typeIncludesUndefined(node.getType()) &&
+        !(
+          options.applyLevel === 'avoidWhereUndefinedIsAllowed' &&
+          contextAcceptsUndefined(node)
+        ),
+    );
+
+    if (Arr.isEmpty(widened)) {
+      return [];
+    }
+
+    project.compilerOptions.set({ noUncheckedIndexedAccess: false });
+
+    // What is possibly `undefined` without the option too is not the option's
+    // doing — the element type says so, or the expression is erroneous (an
+    // unresolved import resolves to `any`, which is never widened).
+    return widened
+      .filter((node) => !typeIncludesUndefined(node.getType()))
+      .map((node) => {
+        options.debugPrint(`${node.getText()} -> ${node.getText()}!`);
+
+        return node.getEnd();
+      });
+  } finally {
+    // `set` merges, so the two options overridden above have to be named
+    // explicitly: they are absent from `originalOptions` when the project did
+    // not carry them, and would otherwise stay overridden for whichever
+    // transformer runs next.
+    project.compilerOptions.set({
+      ...originalOptions,
+      strictNullChecks: originalOptions.strictNullChecks,
+      noUncheckedIndexedAccess: originalOptions.noUncheckedIndexedAccess,
+    });
+  }
+};
+
+const insertNonNullAssertions = (
+  fullText: string,
+  positions: readonly number[],
+): string => {
+  const mut_parts: string[] = [];
+
+  let mut_restStart: number = 0;
+
+  for (const position of positions.toSorted((a, b) => a - b)) {
+    mut_parts.push(fullText.slice(mut_restStart, position), '!');
+
+    mut_restStart = position;
+  }
+
+  mut_parts.push(fullText.slice(mut_restStart));
+
+  return mut_parts.join('');
+};
 
 const equalityOperatorKinds: readonly tsm.SyntaxKind[] = [
   tsm.SyntaxKind.EqualsEqualsToken,