ts-codemod-lib 3.5.1 → 4.0.1

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,

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

@@ -34,6 +34,29 @@ const preamble = dedent`
   declare const k: string;
 `;
 
+/**
+ * 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();
+};
+
+const formatter = (code: string): Promise<string> =>
+  prettier.format(code, {
+    parser: 'typescript',
+    plugins: [prettierPluginTypeScript, prettierPluginEstree],
+  });
+
 const testFn = async ({
   source,
   expected,
@@ -59,23 +82,6 @@ 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.
  *
@@ -87,14 +93,14 @@ const transformInProject = (
  * 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,
- * 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.
+ * 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.
+ * against the full library — is what the tests at the bottom of this file still
+ * cover.
  */
 const project = new tsm.Project({
   useInMemoryFileSystem: true,
@@ -107,12 +113,6 @@ const project = new tsm.Project({
   },
 });
 
-const formatter = (code: string): Promise<string> =>
-  prettier.format(code, {
-    parser: 'typescript',
-    plugins: [prettierPluginTypeScript, prettierPluginEstree],
-  });
-
 describe(enableNoUncheckedIndexedAccessTransformer, () => {
   describe('accesses the option widens with undefined', () => {
     test.each([

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

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