ts-codemod-lib 3.2.0 → 3.3.0

package/README.md

@@ -178,6 +178,74 @@ type ReadonlyConfig2 = UnknownRecord;
 type Data2 = UnknownRecord;
 ```
 
+### 6. `enableNoUncheckedIndexedAccessTransformer`
+
+Appends `!` to the index accesses that turning on
+[`noUncheckedIndexedAccess`](https://www.typescriptlang.org/tsconfig/#noUncheckedIndexedAccess)
+would turn into type errors, as a stopgap while the option is being enabled on
+an existing codebase.
+
+The rewrite is driven by the type checker rather than by syntax: each 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 is left untouched — `[T, T][1]`, `[T, T, ...T[]][0]` and
+`({ a: T })['a']` all keep their accesses as they are, as does an element type
+that contained `undefined` to begin with, and so does an access a preceding
+guard has already narrowed. `strictNullChecks` is turned on for both checks,
+because `noUncheckedIndexedAccess` does nothing without it.
+
+Both spellings of an index read are covered, because the option widens both:
+`rec['a']` and the dotted `rec.a` of a type carrying an index signature. A
+declared property is left alone either way, even on a type that also has an
+index signature.
+
+Options:
+
+- `applyLevel`: `'all'` or `'avoidWhereUndefinedIsAllowed'` (default: `'all'`)
+    - `'all'`: appends `!` to every read whose type the option widens with `undefined`, so that as few type errors as possible are left behind
+    - `'avoidWhereUndefinedIsAllowed'`: additionally leaves the access alone where its contextual type already accepts `undefined` (e.g. `const x: number | undefined = xs[0];`, or an argument of a `(x: number | undefined) => void` parameter), which produces fewer but only load-bearing assertions
+
+These positions are never rewritten, whichever level is selected:
+
+- **Assignment targets**, where `!` is not valid syntax: `xs[0] = 1`, `xs[0] ??= 1`, `xs[0]++`, `--xs[0]`, `delete rec['a']`, `[xs[0]] = ys`, `for (xs[0] of ys)`.
+- **Accesses that already account for `undefined`**: `xs[0]!`, `xs[0] as T`, `xs[0]?.foo`, `fns[0]?.()`, `xs[0] ?? d`, `xs[0] && d`.
+- **Positions that read the value precisely to find out whether it is there**: `typeof xs[0]`, `!xs[0]`, `xs[0] === undefined`, and the condition of `if` / `while` / `do` / `for` / `?:`, and the subject of `switch` — asserting there would defeat the check (`case undefined:` stops compiling against an asserted subject).
+
+Two things it cannot fix, which are left for a human to deal with:
+
+- **Destructuring**, since `!` has nowhere to go in `const [head] = xs;` or `const { a } = rec;`.
+- **Compound assignment**, `xs[0] += 1`, whose left-hand side is read as well as written.
+
+Two things to know before running it:
+
+- **Each file is transformed on its own**, as it is by every transformer in this library. A type that comes from another module does not resolve, and neither does a narrowing that depends on an imported type guard — `if (Arr.isNonEmpty(xs))` does not narrow `xs[0]` here. An unresolved type is never widened, so nothing is asserted there; a lost narrowing is the other way round, and produces an assertion the whole-program check does not need.
+- **Review the diff, and let ESLint clean up after it.** An assertion the compiler can prove unnecessary is reported by [`@typescript-eslint/no-unnecessary-type-assertion`](https://typescript-eslint.io/rules/no-unnecessary-type-assertion/), whose fixer removes it, so running `eslint --fix` over the transformed files takes most of the surplus back out. What no rule can see is an assertion that makes a later check dead — `const v = xs[0]!; if (v === undefined) …` — which is why this is a stopgap rather than a fix.
+
+Example:
+
+```ts
+const xs: readonly number[] = [1, 2, 3];
+
+const pair: readonly [number, string] = [1, 'a'];
+
+const rec: ReadonlyRecord<string, number> = { a: 1 };
+
+// Before (with `noUncheckedIndexedAccess` on, only `pair[1]` is known to be there)
+const first: number | undefined = xs[0];
+
+const entry: number | undefined = rec['a'];
+
+const second: string = pair[1];
+
+// After (the two unchecked reads are asserted, the guaranteed index is left alone)
+const first2: number = xs[0]!;
+
+const entry2: number = rec['a']!;
+
+const second2: string = pair[1];
+```
+
 ### Disabling Transformers
 
 - Nodes on the line immediately following a `// transformer-ignore-next-line` comment will be skipped.

package/dist/entry-point.mjs

@@ -1,6 +1,7 @@
 export { appendAsConstTransformer } from './functions/ast-transformers/append-as-const.mjs';
 export { convertInterfaceToTypeTransformer } from './functions/ast-transformers/convert-interface-to-type.mjs';
 export { convertToReadonlyTransformer } from './functions/ast-transformers/convert-to-readonly.mjs';
+export { enableNoUncheckedIndexedAccessTransformer } from './functions/ast-transformers/enable-no-unchecked-indexed-access.mjs';
 export { compareUnionIntersectionTypes } from './functions/ast-transformers/readonly-transformer-helpers/compare-union-types.mjs';
 export { invalidDeepReadonlyTypeName } from './functions/ast-transformers/readonly-transformer-helpers/constants.mjs';
 export { groupUnionIntersectionTypes } from './functions/ast-transformers/readonly-transformer-helpers/group-union-types.mjs';

package/dist/entry-point.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"entry-point.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"entry-point.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -0,0 +1,65 @@
+import { type DeepReadonly } from 'ts-type-forge';
+import { type TsMorphTransformer } from './types.mjs';
+/**
+ * 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.
+ *
+ * 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
+ * contained `undefined` to begin with.
+ *
+ * Both spellings of an index read are covered, because the option widens both:
+ * `rec['a']` and the dotted `rec.a` of a type carrying an index signature.
+ *
+ * `strictNullChecks` is turned on for both checks, because
+ * `noUncheckedIndexedAccess` does nothing without it and the project the
+ * transformer is handed may not have it on.
+ *
+ * The result is a stopgap, not a fix, and wants reviewing. A file transformed
+ * 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.
+ *
+ * @example
+ * ```ts
+ * declare const xs: readonly number[];
+ * declare const pair: readonly [number, number];
+ * declare const rec: Record<string, number>;
+ * declare const known: { a: number };
+ *
+ * xs[0].toFixed(); // -> xs[0]!.toFixed();
+ * rec['a'].toFixed(); // -> rec['a']!.toFixed();
+ * rec.a.toFixed(); // -> rec.a!.toFixed();
+ * pair[1].toFixed(); // -> pair[1].toFixed(); (guaranteed to exist)
+ * known.a.toFixed(); // -> known.a.toFixed(); (guaranteed to exist)
+ * ```
+ */
+export declare const enableNoUncheckedIndexedAccessTransformer: (options?: EnableNoUncheckedIndexedAccessTransformerOptions) => TsMorphTransformer;
+export type EnableNoUncheckedIndexedAccessTransformerOptions = DeepReadonly<{
+    /**
+     * How eagerly `!` is appended.
+     *
+     * - `"all"`: append it to every read whose type `noUncheckedIndexedAccess`
+     *   widens with `undefined`, so that as few type errors as possible remain.
+     * - `"avoidWhereUndefinedIsAllowed"`: additionally leave the access alone
+     *   where its contextual type already accepts `undefined` (e.g.
+     *   `const x: number | undefined = xs[0];` or an argument of a
+     *   `(x: number | undefined) => void` parameter), which produces fewer but
+     *   only load-bearing assertions.
+     *
+     * @default "all"
+     */
+    applyLevel?: 'all' | 'avoidWhereUndefinedIsAllowed';
+    debug?: boolean;
+}>;
+//# sourceMappingURL=enable-no-unchecked-indexed-access.d.mts.map

package/dist/functions/ast-transformers/enable-no-unchecked-indexed-access.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enable-no-unchecked-indexed-access.d.mts","sourceRoot":"","sources":["../../../src/functions/ast-transformers/enable-no-unchecked-indexed-access.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAItD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,eAAO,MAAM,yCAAyC,aAC1C,gDAAgD,KACzD,kBAyBF,CAAC;AAEF,MAAM,MAAM,gDAAgD,GAAG,YAAY,CAAC;IAC1E;;;;;;;;;;;;OAYG;IACH,UAAU,CAAC,EAAE,KAAK,GAAG,8BAA8B,CAAC;IAEpD,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC,CAAC"}

package/dist/functions/ast-transformers/enable-no-unchecked-indexed-access.mjs

@@ -0,0 +1,155 @@
+import { Arr } from 'ts-data-forge';
+import * as tsm from 'ts-morph';
+import { hasDisableNextLineComment } from '../functions/has-disable-next-line-comment.mjs';
+import '../functions/is-atomic-type-node.mjs';
+
+const TRANSFORMER_NAME = "enable-no-unchecked-indexed-access";
+const enableNoUncheckedIndexedAccessTransformer = (options) => {
+  const optionsInternal = {
+    applyLevel: options?.applyLevel ?? "all",
+    debugPrint: options?.debug === true ? console.debug : () => {
+    }
+  };
+  return {
+    name: TRANSFORMER_NAME,
+    transform: (sourceAst) => {
+      const positions = collectAssertionPositions(sourceAst, optionsInternal);
+      if (Arr.isEmpty(positions)) {
+        return;
+      }
+      sourceAst.replaceText(
+        [0, sourceAst.getEnd()],
+        insertNonNullAssertions(sourceAst.getFullText(), positions)
+      );
+    }
+  };
+};
+const collectAssertionPositions = (sourceAst, options) => {
+  const candidates = [
+    ...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 {
+    project.compilerOptions.set({
+      strictNullChecks: true,
+      noUncheckedIndexedAccess: true
+    });
+    const widened = candidates.filter(
+      (node) => typeIncludesUndefined(node.getType()) && !(options.applyLevel === "avoidWhereUndefinedIsAllowed" && contextAcceptsUndefined(node))
+    );
+    if (Arr.isEmpty(widened)) {
+      return [];
+    }
+    project.compilerOptions.set({ noUncheckedIndexedAccess: false });
+    return widened.filter((node) => !typeIncludesUndefined(node.getType())).map((node) => {
+      options.debugPrint(`${node.getText()} -> ${node.getText()}!`);
+      return node.getEnd();
+    });
+  } finally {
+    project.compilerOptions.set({
+      ...originalOptions,
+      strictNullChecks: originalOptions.strictNullChecks,
+      noUncheckedIndexedAccess: originalOptions.noUncheckedIndexedAccess
+    });
+  }
+};
+const insertNonNullAssertions = (fullText, positions) => {
+  const mut_parts = [];
+  let mut_restStart = 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 = (type) => type.isUndefined() || type.isUnion() && type.getUnionTypes().some((t) => t.isUndefined());
+const contextAcceptsUndefined = (node) => {
+  const contextualType = node.getContextualType();
+  return contextualType !== void 0 && (contextualType.isAny() || contextualType.isUnknown() || typeIncludesUndefined(contextualType));
+};
+const isIgnoredByComment = (node) => {
+  if (hasDisableNextLineComment(node, TRANSFORMER_NAME)) {
+    return true;
+  }
+  const statement = node.getFirstAncestor(
+    (ancestor) => tsm.Node.isStatement(ancestor)
+  );
+  return statement !== void 0 && hasDisableNextLineComment(statement, TRANSFORMER_NAME);
+};
+const isAssertableReadPosition = (node) => {
+  const parent = node.getParent();
+  if (parent === void 0) {
+    return false;
+  }
+  return !isAlreadyAssertedOrGuarded(node, parent) && !isWriteTarget(node, parent) && !isTestedForAbsence(node, parent);
+};
+const isAlreadyAssertedOrGuarded = (node, parent) => {
+  if (parent.isKind(tsm.SyntaxKind.NonNullExpression) || parent.isKind(tsm.SyntaxKind.AsExpression) || parent.isKind(tsm.SyntaxKind.TypeAssertionExpression)) {
+    return true;
+  }
+  if (isInOptionalChain(node)) {
+    return true;
+  }
+  return (parent.isKind(tsm.SyntaxKind.PropertyAccessExpression) || parent.isKind(tsm.SyntaxKind.ElementAccessExpression) || parent.isKind(tsm.SyntaxKind.CallExpression)) && parent.hasQuestionDotToken() && parent.getExpression() === node;
+};
+const isInOptionalChain = (node) => {
+  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 isWriteTarget = (node, parent) => {
+  if (parent.isKind(tsm.SyntaxKind.DeleteExpression) || parent.isKind(tsm.SyntaxKind.PostfixUnaryExpression)) {
+    return true;
+  }
+  if (parent.isKind(tsm.SyntaxKind.PrefixUnaryExpression)) {
+    const operator = parent.getOperatorToken();
+    return operator === tsm.SyntaxKind.PlusPlusToken || operator === tsm.SyntaxKind.MinusMinusToken;
+  }
+  if (parent.isKind(tsm.SyntaxKind.ForOfStatement) || parent.isKind(tsm.SyntaxKind.ForInStatement)) {
+    return parent.getInitializer() === node;
+  }
+  return parent.isKind(tsm.SyntaxKind.BinaryExpression) && parent.getLeft() === node && isAssignmentOperatorKind(parent.getOperatorToken().getKind());
+};
+const isTestedForAbsence = (node, parent) => {
+  if (parent.isKind(tsm.SyntaxKind.TypeOfExpression)) {
+    return true;
+  }
+  if (parent.isKind(tsm.SyntaxKind.PrefixUnaryExpression)) {
+    return parent.getOperatorToken() === tsm.SyntaxKind.ExclamationToken;
+  }
+  if (parent.isKind(tsm.SyntaxKind.BinaryExpression)) {
+    const operator = parent.getOperatorToken().getKind();
+    return equalityOperatorKinds.includes(operator) || parent.getLeft() === node && shortCircuitOperatorKinds.includes(operator);
+  }
+  if (parent.isKind(tsm.SyntaxKind.IfStatement) || parent.isKind(tsm.SyntaxKind.WhileStatement) || parent.isKind(tsm.SyntaxKind.DoStatement) || parent.isKind(tsm.SyntaxKind.SwitchStatement)) {
+    return parent.getExpression() === node;
+  }
+  if (parent.isKind(tsm.SyntaxKind.ForStatement)) {
+    return parent.getCondition() === node;
+  }
+  return parent.isKind(tsm.SyntaxKind.ConditionalExpression) && parent.getCondition() === node;
+};
+const isAssignmentOperatorKind = (kind) => tsm.SyntaxKind.FirstAssignment <= kind && kind <= tsm.SyntaxKind.LastAssignment;
+const equalityOperatorKinds = [
+  tsm.SyntaxKind.EqualsEqualsToken,
+  tsm.SyntaxKind.EqualsEqualsEqualsToken,
+  tsm.SyntaxKind.ExclamationEqualsToken,
+  tsm.SyntaxKind.ExclamationEqualsEqualsToken
+];
+const shortCircuitOperatorKinds = [
+  tsm.SyntaxKind.QuestionQuestionToken,
+  tsm.SyntaxKind.AmpersandAmpersandToken,
+  tsm.SyntaxKind.BarBarToken
+];
+
+export { enableNoUncheckedIndexedAccessTransformer };
+//# sourceMappingURL=enable-no-unchecked-indexed-access.mjs.map

package/dist/functions/ast-transformers/enable-no-unchecked-indexed-access.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"enable-no-unchecked-indexed-access.mjs","sources":["../../../src/functions/ast-transformers/enable-no-unchecked-indexed-access.mts"],"sourcesContent":["import { Arr } from 'ts-data-forge';\nimport * as tsm from 'ts-morph';\nimport { type DeepReadonly } from 'ts-type-forge';\nimport { hasDisableNextLineComment } from '../functions/index.mjs';\nimport { type TsMorphTransformer } from './types.mjs';\n\nconst TRANSFORMER_NAME = 'enable-no-unchecked-indexed-access';\n\n/**\n * Appends `!` to the index accesses that turning on the\n * [`noUncheckedIndexedAccess`](https://www.typescriptlang.org/tsconfig/#noUncheckedIndexedAccess)\n * compiler option would turn into type errors, as a stopgap while the option\n * is being enabled.\n *\n * The rewrite is driven by the type checker rather than by syntax: the file is\n * checked twice, once with `noUncheckedIndexedAccess` off and once with it on,\n * and `!` is appended only where the option is what added `undefined` to the\n * expression's type. Consequently an index whose presence the type already\n * guarantees keeps its access untouched — `[T, T][1]`, `[T, T, ...T[]][0]`,\n * and `({ a: T })['a']` are all left as they are, as is an element type that\n * contained `undefined` to begin with.\n *\n * Both spellings of an index read are covered, because the option widens both:\n * `rec['a']` and the dotted `rec.a` of a type carrying an index signature.\n *\n * `strictNullChecks` is turned on for both checks, because\n * `noUncheckedIndexedAccess` does nothing without it and the project the\n * transformer is handed may not have it on.\n *\n * The result is a stopgap, not a fix, and wants reviewing. A file transformed\n * on its own — which is how {@link transformSourceCode} drives every\n * transformer here — resolves neither a type from another module nor a\n * narrowing that depends on an imported type guard, and the latter produces\n * assertions a whole-program check does not need. Most of those are reported\n * by `@typescript-eslint/no-unnecessary-type-assertion`, whose fixer removes\n * them; what no rule can see is an assertion that makes a later check dead,\n * as the `if` of `const v = xs[0]!; if (v === undefined) …` now is.\n *\n * @example\n * ```ts\n * declare const xs: readonly number[];\n * declare const pair: readonly [number, number];\n * declare const rec: Record<string, number>;\n * declare const known: { a: number };\n *\n * xs[0].toFixed(); // -> xs[0]!.toFixed();\n * rec['a'].toFixed(); // -> rec['a']!.toFixed();\n * rec.a.toFixed(); // -> rec.a!.toFixed();\n * pair[1].toFixed(); // -> pair[1].toFixed(); (guaranteed to exist)\n * known.a.toFixed(); // -> known.a.toFixed(); (guaranteed to exist)\n * ```\n */\nexport const enableNoUncheckedIndexedAccessTransformer = (\n  options?: EnableNoUncheckedIndexedAccessTransformerOptions,\n): TsMorphTransformer => {\n  const optionsInternal: EnableNoUncheckedIndexedAccessTransformerOptionsInternal =\n    {\n      applyLevel: options?.applyLevel ?? 'all',\n      debugPrint: options?.debug === true ? console.debug : () => {},\n    } as const;\n\n  return {\n    name: TRANSFORMER_NAME,\n    transform: (sourceAst) => {\n      const positions = collectAssertionPositions(sourceAst, optionsInternal);\n\n      if (Arr.isEmpty(positions)) {\n        return;\n      }\n\n      // One text edit for the whole file: `insertText` forgets every\n      // descendant node, so inserting one `!` at a time would reparse the\n      // file once per assertion.\n      sourceAst.replaceText(\n        [0, sourceAst.getEnd()],\n        insertNonNullAssertions(sourceAst.getFullText(), positions),\n      );\n    },\n  };\n};\n\nexport type EnableNoUncheckedIndexedAccessTransformerOptions = DeepReadonly<{\n  /**\n   * How eagerly `!` is appended.\n   *\n   * - `\"all\"`: append it to every read whose type `noUncheckedIndexedAccess`\n   *   widens with `undefined`, so that as few type errors as possible remain.\n   * - `\"avoidWhereUndefinedIsAllowed\"`: additionally leave the access alone\n   *   where its contextual type already accepts `undefined` (e.g.\n   *   `const x: number | undefined = xs[0];` or an argument of a\n   *   `(x: number | undefined) => void` parameter), which produces fewer but\n   *   only load-bearing assertions.\n   *\n   * @default \"all\"\n   */\n  applyLevel?: 'all' | 'avoidWhereUndefinedIsAllowed';\n\n  debug?: boolean;\n}>;\n\ntype EnableNoUncheckedIndexedAccessTransformerOptionsInternal = DeepReadonly<{\n  applyLevel: 'all' | 'avoidWhereUndefinedIsAllowed';\n  debugPrint: (...args: readonly unknown[]) => void;\n}>;\n\n/**\n * An index read that `noUncheckedIndexedAccess` can widen: an element access,\n * and the dotted spelling of the same thing on a type with an index signature\n * (`rec.a`, which the option widens exactly as it widens `rec['a']`).\n */\ntype IndexReadExpression =\n  tsm.ElementAccessExpression | tsm.PropertyAccessExpression;\n\n/**\n * Returns the positions at which a `!` has to be inserted, i.e. the end\n * offsets of the reads whose type `noUncheckedIndexedAccess` widens with\n * `undefined`.\n */\nconst collectAssertionPositions = (\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  sourceAst: tsm.SourceFile,\n  options: EnableNoUncheckedIndexedAccessTransformerOptionsInternal,\n): readonly number[] => {\n  const candidates: readonly IndexReadExpression[] = [\n    ...sourceAst.getDescendantsOfKind(tsm.SyntaxKind.ElementAccessExpression),\n    ...sourceAst.getDescendantsOfKind(tsm.SyntaxKind.PropertyAccessExpression),\n  ].filter(\n    (node) => isAssertableReadPosition(node) && !isIgnoredByComment(node),\n  );\n\n  if (Arr.isEmpty(candidates)) {\n    return [];\n  }\n\n  const project = sourceAst.getProject();\n\n  const originalOptions = project.getCompilerOptions();\n\n  try {\n    // With the option on first, because that narrows the candidates down to\n    // the few reads worth checking a second time. `strictNullChecks` comes\n    // with it: `noUncheckedIndexedAccess` does nothing without it, and the\n    // project handed to the transformer may not have it on.\n    project.compilerOptions.set({\n      strictNullChecks: true,\n      noUncheckedIndexedAccess: true,\n    });\n\n    const widened = candidates.filter(\n      (node) =>\n        typeIncludesUndefined(node.getType()) &&\n        !(\n          options.applyLevel === 'avoidWhereUndefinedIsAllowed' &&\n          contextAcceptsUndefined(node)\n        ),\n    );\n\n    if (Arr.isEmpty(widened)) {\n      return [];\n    }\n\n    project.compilerOptions.set({ noUncheckedIndexedAccess: false });\n\n    // What is possibly `undefined` without the option too is not the option's\n    // doing — the element type says so, or the expression is erroneous (an\n    // unresolved import resolves to `any`, which is never widened).\n    return widened\n      .filter((node) => !typeIncludesUndefined(node.getType()))\n      .map((node) => {\n        options.debugPrint(`${node.getText()} -> ${node.getText()}!`);\n\n        return node.getEnd();\n      });\n  } finally {\n    // `set` merges, so the two options overridden above have to be named\n    // explicitly: they are absent from `originalOptions` when the project did\n    // not carry them, and would otherwise stay overridden for whichever\n    // transformer runs next.\n    project.compilerOptions.set({\n      ...originalOptions,\n      strictNullChecks: originalOptions.strictNullChecks,\n      noUncheckedIndexedAccess: originalOptions.noUncheckedIndexedAccess,\n    });\n  }\n};\n\nconst insertNonNullAssertions = (\n  fullText: string,\n  positions: readonly number[],\n): string => {\n  const mut_parts: string[] = [];\n\n  let mut_restStart: number = 0;\n\n  for (const position of positions.toSorted((a, b) => a - b)) {\n    mut_parts.push(fullText.slice(mut_restStart, position), '!');\n\n    mut_restStart = position;\n  }\n\n  mut_parts.push(fullText.slice(mut_restStart));\n\n  return mut_parts.join('');\n};\n\nconst typeIncludesUndefined = (\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  type: tsm.Type,\n): boolean =>\n  type.isUndefined() ||\n  (type.isUnion() && type.getUnionTypes().some((t) => t.isUndefined()));\n\n/**\n * Whether the position the access sits in already accepts `undefined`, in\n * which case `noUncheckedIndexedAccess` reports nothing there and the\n * assertion would only be noise.\n */\nconst contextAcceptsUndefined = (\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  node: IndexReadExpression,\n): boolean => {\n  const contextualType = node.getContextualType();\n\n  return (\n    contextualType !== undefined &&\n    (contextualType.isAny() ||\n      contextualType.isUnknown() ||\n      typeIncludesUndefined(contextualType))\n  );\n};\n\nconst isIgnoredByComment = (\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  node: IndexReadExpression,\n): boolean => {\n  if (hasDisableNextLineComment(node, TRANSFORMER_NAME)) {\n    return true;\n  }\n\n  // An index access is rarely the first thing on its own line, so the comment\n  // that covers it is the one above the statement it appears in.\n  const statement = node.getFirstAncestor((ancestor) =>\n    tsm.Node.isStatement(ancestor),\n  );\n\n  return (\n    statement !== undefined &&\n    hasDisableNextLineComment(statement, TRANSFORMER_NAME)\n  );\n};\n\n/**\n * Whether a `!` appended to this access would be both syntactically valid and\n * meaningful.\n *\n * Note that most write positions need no rule of their own: TypeScript gives\n * the target of an assignment the element type without `undefined`, so the\n * type comparison in {@link collectAssertionPositions} already passes them\n * over. The exceptions handled here are the ones it does widen.\n */\nconst isAssertableReadPosition = (\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  node: IndexReadExpression,\n): boolean => {\n  const parent = node.getParent();\n\n  if (parent === undefined) {\n    return false;\n  }\n\n  return (\n    !isAlreadyAssertedOrGuarded(node, parent) &&\n    !isWriteTarget(node, parent) &&\n    !isTestedForAbsence(node, parent)\n  );\n};\n\n/** `xs[0]!`, `xs[0] as T`, `<T>xs[0]`, `xs[0]?.foo`, `xs[0]?.()`, `xs[0]?.[1]`. */\nconst isAlreadyAssertedOrGuarded = (\n  node: tsm.Node,\n  parent: tsm.Node,\n): boolean => {\n  if (\n    parent.isKind(tsm.SyntaxKind.NonNullExpression) ||\n    parent.isKind(tsm.SyntaxKind.AsExpression) ||\n    parent.isKind(tsm.SyntaxKind.TypeAssertionExpression)\n  ) {\n    return true;\n  }\n\n  if (isInOptionalChain(node)) {\n    return true;\n  }\n\n  // Only the object of the optional chain is guarded; an index argument such\n  // as the `xs[0]` of `m?.[xs[0]]` is not.\n  return (\n    (parent.isKind(tsm.SyntaxKind.PropertyAccessExpression) ||\n      parent.isKind(tsm.SyntaxKind.ElementAccessExpression) ||\n      parent.isKind(tsm.SyntaxKind.CallExpression)) &&\n    parent.hasQuestionDotToken() &&\n    parent.getExpression() === node\n  );\n};\n\n/**\n * Whether the read sits in an optional chain that can short-circuit before it,\n * as the `xs[0]?.toFixed` of `xs[0]?.toFixed()` does. `undefined` in such a\n * type comes from the chain rather than from the index, and the chain already\n * accounts for it; asserting there would assert away the author's own `?.`.\n *\n * Parentheses end a chain (`(a?.b).c` is not one), which is why the walk stops\n * at anything that is not a chain link.\n */\nconst isInOptionalChain = (node: tsm.Node): boolean => {\n  if (\n    node.isKind(tsm.SyntaxKind.PropertyAccessExpression) ||\n    node.isKind(tsm.SyntaxKind.ElementAccessExpression) ||\n    node.isKind(tsm.SyntaxKind.CallExpression)\n  ) {\n    return (\n      node.hasQuestionDotToken() || isInOptionalChain(node.getExpression())\n    );\n  }\n\n  return (\n    node.isKind(tsm.SyntaxKind.NonNullExpression) &&\n    isInOptionalChain(node.getExpression())\n  );\n};\n\n/**\n * Positions that write the value rather than read it, where `!` cannot be\n * appended at all: an assignment target is not an expression (`xs[0]! = 1`\n * does not parse as an assignment), and `delete xs[0]!` and `xs[0]!++` are\n * equally invalid.\n *\n * `xs[0] += 1` is the one case this leaves a type error behind: its left-hand\n * side is read as well as written, so `noUncheckedIndexedAccess` reports it,\n * but no assertion can be spelled there.\n */\nconst isWriteTarget = (node: tsm.Node, parent: tsm.Node): boolean => {\n  if (\n    parent.isKind(tsm.SyntaxKind.DeleteExpression) ||\n    parent.isKind(tsm.SyntaxKind.PostfixUnaryExpression)\n  ) {\n    return true;\n  }\n\n  if (parent.isKind(tsm.SyntaxKind.PrefixUnaryExpression)) {\n    const operator = parent.getOperatorToken();\n\n    return (\n      operator === tsm.SyntaxKind.PlusPlusToken ||\n      operator === tsm.SyntaxKind.MinusMinusToken\n    );\n  }\n\n  if (\n    parent.isKind(tsm.SyntaxKind.ForOfStatement) ||\n    parent.isKind(tsm.SyntaxKind.ForInStatement)\n  ) {\n    return parent.getInitializer() === node;\n  }\n\n  return (\n    parent.isKind(tsm.SyntaxKind.BinaryExpression) &&\n    parent.getLeft() === node &&\n    isAssignmentOperatorKind(parent.getOperatorToken().getKind())\n  );\n};\n\n/**\n * Positions that read the access precisely to find out whether the value is\n * there — a truthiness check, an equality comparison, `??`, `typeof`. None of\n * them is an error under `noUncheckedIndexedAccess`, and asserting inside one\n * would defeat the check it performs (`case undefined:` would stop compiling\n * against an asserted `switch` subject).\n */\nconst isTestedForAbsence = (node: tsm.Node, parent: tsm.Node): boolean => {\n  if (parent.isKind(tsm.SyntaxKind.TypeOfExpression)) {\n    return true;\n  }\n\n  if (parent.isKind(tsm.SyntaxKind.PrefixUnaryExpression)) {\n    return parent.getOperatorToken() === tsm.SyntaxKind.ExclamationToken;\n  }\n\n  if (parent.isKind(tsm.SyntaxKind.BinaryExpression)) {\n    const operator = parent.getOperatorToken().getKind();\n\n    return (\n      equalityOperatorKinds.includes(operator) ||\n      (parent.getLeft() === node &&\n        shortCircuitOperatorKinds.includes(operator))\n    );\n  }\n\n  if (\n    parent.isKind(tsm.SyntaxKind.IfStatement) ||\n    parent.isKind(tsm.SyntaxKind.WhileStatement) ||\n    parent.isKind(tsm.SyntaxKind.DoStatement) ||\n    parent.isKind(tsm.SyntaxKind.SwitchStatement)\n  ) {\n    return parent.getExpression() === node;\n  }\n\n  if (parent.isKind(tsm.SyntaxKind.ForStatement)) {\n    return parent.getCondition() === node;\n  }\n\n  return (\n    parent.isKind(tsm.SyntaxKind.ConditionalExpression) &&\n    parent.getCondition() === node\n  );\n};\n\n/**\n * `=` through `^=`, i.e. every assignment operator. TypeScript keeps them in\n * one contiguous block of {@link tsm.SyntaxKind} and marks its ends, which is\n * how the compiler itself recognizes them.\n */\nconst isAssignmentOperatorKind = (kind: tsm.SyntaxKind): boolean =>\n  tsm.SyntaxKind.FirstAssignment <= kind &&\n  kind <= tsm.SyntaxKind.LastAssignment;\n\nconst equalityOperatorKinds: readonly tsm.SyntaxKind[] = [\n  tsm.SyntaxKind.EqualsEqualsToken,\n  tsm.SyntaxKind.EqualsEqualsEqualsToken,\n  tsm.SyntaxKind.ExclamationEqualsToken,\n  tsm.SyntaxKind.ExclamationEqualsEqualsToken,\n] as const;\n\nconst shortCircuitOperatorKinds: readonly tsm.SyntaxKind[] = [\n  tsm.SyntaxKind.QuestionQuestionToken,\n  tsm.SyntaxKind.AmpersandAmpersandToken,\n  tsm.SyntaxKind.BarBarToken,\n] as const;\n"],"names":[],"mappings":"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"}

package/dist/functions/ast-transformers/index.d.mts

@@ -1,6 +1,7 @@
 export * from './append-as-const.mjs';
 export * from './convert-interface-to-type.mjs';
 export * from './convert-to-readonly.mjs';
+export * from './enable-no-unchecked-indexed-access.mjs';
 export * from './readonly-transformer-helpers/index.mjs';
 export * from './replace-any-with-unknown.mjs';
 export * from './replace-record-with-unknown-record.mjs';

package/dist/functions/ast-transformers/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../src/functions/ast-transformers/index.mts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,iCAAiC,CAAC;AAChD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0CAA0C,CAAC;AACzD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,0CAA0C,CAAC;AACzD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../src/functions/ast-transformers/index.mts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,iCAAiC,CAAC;AAChD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0CAA0C,CAAC;AACzD,cAAc,0CAA0C,CAAC;AACzD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,0CAA0C,CAAC;AACzD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,aAAa,CAAC"}

package/dist/functions/ast-transformers/index.mjs

@@ -1,6 +1,7 @@
 export { appendAsConstTransformer } from './append-as-const.mjs';
 export { convertInterfaceToTypeTransformer } from './convert-interface-to-type.mjs';
 export { convertToReadonlyTransformer } from './convert-to-readonly.mjs';
+export { enableNoUncheckedIndexedAccessTransformer } from './enable-no-unchecked-indexed-access.mjs';
 export { compareUnionIntersectionTypes } from './readonly-transformer-helpers/compare-union-types.mjs';
 export { invalidDeepReadonlyTypeName } from './readonly-transformer-helpers/constants.mjs';
 export { groupUnionIntersectionTypes } from './readonly-transformer-helpers/group-union-types.mjs';

package/dist/functions/ast-transformers/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;"}

package/dist/functions/index.mjs

@@ -1,6 +1,7 @@
 export { appendAsConstTransformer } from './ast-transformers/append-as-const.mjs';
 export { convertInterfaceToTypeTransformer } from './ast-transformers/convert-interface-to-type.mjs';
 export { convertToReadonlyTransformer } from './ast-transformers/convert-to-readonly.mjs';
+export { enableNoUncheckedIndexedAccessTransformer } from './ast-transformers/enable-no-unchecked-indexed-access.mjs';
 export { compareUnionIntersectionTypes } from './ast-transformers/readonly-transformer-helpers/compare-union-types.mjs';
 export { invalidDeepReadonlyTypeName } from './ast-transformers/readonly-transformer-helpers/constants.mjs';
 export { groupUnionIntersectionTypes } from './ast-transformers/readonly-transformer-helpers/group-union-types.mjs';

package/dist/functions/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.mjs

@@ -1,6 +1,7 @@
 export { appendAsConstTransformer } from './functions/ast-transformers/append-as-const.mjs';
 export { convertInterfaceToTypeTransformer } from './functions/ast-transformers/convert-interface-to-type.mjs';
 export { convertToReadonlyTransformer } from './functions/ast-transformers/convert-to-readonly.mjs';
+export { enableNoUncheckedIndexedAccessTransformer } from './functions/ast-transformers/enable-no-unchecked-indexed-access.mjs';
 export { compareUnionIntersectionTypes } from './functions/ast-transformers/readonly-transformer-helpers/compare-union-types.mjs';
 export { invalidDeepReadonlyTypeName } from './functions/ast-transformers/readonly-transformer-helpers/constants.mjs';
 export { groupUnionIntersectionTypes } from './functions/ast-transformers/readonly-transformer-helpers/group-union-types.mjs';

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-codemod-lib",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "private": false,
   "keywords": [
     "typescript",
@@ -43,7 +43,7 @@
     "ts-type-forge": "^9.2.2"
   },
   "devDependencies": {
-    "@types/node": "26.3.0",
+    "@types/node": "26.4.0",
     "@vitest/browser-playwright": "4.1.11",
     "@vitest/coverage-v8": "4.1.11",
     "@vitest/ui": "4.1.11",
@@ -51,7 +51,7 @@
     "dedent": "1.7.2",
     "esbuild": "0.28.2",
     "eslint": "10.8.1",
-    "eslint-config-typed": "5.9.5",
+    "eslint-config-typed": "5.10.0",
     "eslint-plugin-ts-data-forge": "0.5.0",
     "eslint-plugin-ts-fortress": "1.0.4",
     "eslint-plugin-ts-type-forge": "0.7.0",