ts-codemod-lib 4.0.0 → 4.0.1

package/dist/functions/functions/wrap-with-parentheses.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"wrap-with-parentheses.mjs","sourceRoot":"","sources":["../../../src/functions/functions/wrap-with-parentheses.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAEhD,MAAM,eAAe,GAAG,CAAC,IAAwB,EAAU,EAAE;IAC3D,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,GAAG;YACN,OAAO,CAAC,CAAC;QAEX,KAAK,GAAG;YACN,OAAO,CAAC,CAAC,CAAC;QAEZ,sEAAsE;QACtE,0DAA0D;QAC1D,KAAK,SAAS,CAAC;QACf;YACE,OAAO,CAAC,CAAC;IACb,CAAC;AACH,CAAC,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,wBAAwB,GAAG,CAAC,GAAW,EAAW,EAAE;IACxD,MAAM,OAAO,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC;IAE3B,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QACvD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,4DAA4D;IAC5D,6DAA6D;IAC7D,IAAI,SAAS,GAAG,CAAC,CAAC;IAElB,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;QACvD,SAAS,IAAI,eAAe,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;QAEhD,kFAAkF;QAClF,IAAI,SAAS,KAAK,CAAC,IAAI,KAAK,GAAG,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAClD,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,OAAe,EAAU,EAAE;IAC7D,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAE/B,OAAO,wBAAwB,CAAC,OAAO,CAAC;QACtC,CAAC,CAAC,OAAO;QACT,CAAC,CAAE,IAAI,OAAO,GAAa,CAAC;AAChC,CAAC,CAAC"}
+{"version":3,"file":"wrap-with-parentheses.mjs","sourceRoot":"","sources":["../../../src/functions/functions/wrap-with-parentheses.mts"],"names":[],"mappings":"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"}

package/dist/functions/utils/replace-node-with-text.d.mts

@@ -3,19 +3,18 @@ import type * as tsm from 'ts-morph';
  * `node.replaceWithText(newNodeText)`, sparing a one-line text the indentation
  * lookup.
  *
- * `replaceWithText` writes the text through a writer whose indentation it
- * looks up first, for the lines after the first one, and the lookup reparses
- * the whole file in the language service: on top of the reparse every
- * replacement makes anyway, once per replacement, so it is quadratic in the
- * size of the file. A text with no `\n` has no line after the first, the
- * indentation is never applied, and a plain writer from the same project
- * writes the same text — so the lookup is skipped. A multi-line text takes
- * the original path.
+ * `replaceWithText` writes the text through a writer whose indentation it looks
+ * up first, for the lines after the first one, and the lookup reparses the
+ * whole file in the language service: on top of the reparse every replacement
+ * makes anyway, once per replacement, so it is quadratic in the size of the
+ * file. A text with no `\n` has no line after the first, the indentation is
+ * never applied, and a plain writer from the same project writes the same text
+ * — so the lookup is skipped. A multi-line text takes the original path.
  *
  * The writer is passed as `replaceWithText`'s second argument, which its
- * declaration leaves out and ts-morph passes itself when it sets an
- * expression. Were it ever dropped, the method would look the indentation up
- * as before: slower, never different.
+ * declaration leaves out and ts-morph passes itself when it sets an expression.
+ * Were it ever dropped, the method would look the indentation up as before:
+ * slower, never different.
  */
 export declare const replaceNodeWithText: (node: tsm.Node, newNodeText: string) => tsm.Node;
 //# sourceMappingURL=replace-node-with-text.d.mts.map

package/dist/functions/utils/replace-node-with-text.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"replace-node-with-text.d.mts","sourceRoot":"","sources":["../../../src/functions/utils/replace-node-with-text.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,GAAG,MAAM,UAAU,CAAC;AAErC;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,mBAAmB,SACxB,GAAG,CAAC,IAAI,eACD,MAAM,KAClB,GAAG,CAAC,IAOA,CAAC"}
+{"version":3,"file":"replace-node-with-text.d.mts","sourceRoot":"","sources":["../../../src/functions/utils/replace-node-with-text.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,GAAG,MAAM,UAAU,CAAC;AAErC;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,mBAAmB,SACxB,GAAG,CAAC,IAAI,eACD,MAAM,KAClB,GAAG,CAAC,IAOA,CAAC"}

package/dist/functions/utils/replace-node-with-text.mjs

@@ -15,7 +15,6 @@
 
 
 
-
 export const replaceNodeWithText = (node, newNodeText) => newNodeText.includes('\n')
     ? node.replaceWithText(newNodeText)
     : node.replaceWithText.call(node, newNodeText, node.getProject().createWriter());

package/dist/functions/utils/replace-node-with-text.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"replace-node-with-text.mjs","sourceRoot":"","sources":["../../../src/functions/utils/replace-node-with-text.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CACjC,IAAc,EACd,WAAmB,EACT,EAAE,CACZ,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC;IACxB,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC;IACnC,CAAC,CAAE,IAAI,CAAC,eAA6C,CAAC,IAAI,CACtD,IAAI,EACJ,WAAW,EACX,IAAI,CAAC,UAAU,EAAE,CAAC,YAAY,EAAE,CACjC,CAAC"}
+{"version":3,"file":"replace-node-with-text.mjs","sourceRoot":"","sources":["../../../src/functions/utils/replace-node-with-text.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CACjC,IAAc,EACd,WAAmB,EACT,EAAE,CACZ,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC;IACxB,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC;IACnC,CAAC,CAAE,IAAI,CAAC,eAA6C,CAAC,IAAI,CACtD,IAAI,EACJ,WAAW,EACX,IAAI,CAAC,UAAU,EAAE,CAAC,YAAY,EAAE,CACjC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-codemod-lib",
-  "version": "4.0.0",
+  "version": "4.0.1",
   "private": false,
   "keywords": [
     "typescript",
@@ -38,7 +38,7 @@
     "LICENSE"
   ],
   "dependencies": {
-    "ts-data-forge": "^14.10.0",
+    "ts-data-forge": "^14.10.2",
     "ts-morph": "^28.0.0",
     "ts-type-forge": "^9.2.2"
   },
@@ -51,10 +51,10 @@
     "dedent": "1.7.2",
     "esbuild": "0.28.2",
     "eslint": "10.13.0",
-    "eslint-config-typed": "6.0.0",
-    "eslint-plugin-ts-data-forge": "0.10.4",
-    "eslint-plugin-ts-fortress": "1.3.9",
-    "eslint-plugin-ts-type-forge": "0.8.14",
+    "eslint-config-typed": "7.3.1",
+    "eslint-plugin-ts-data-forge": "0.10.8",
+    "eslint-plugin-ts-fortress": "1.3.12",
+    "eslint-plugin-ts-type-forge": "0.8.17",
     "jiti": "2.7.0",
     "npm-run-all2": "9.0.4",
     "playwright": "1.64.1",

package/src/functions/ast-transformers/append-as-const.mts

@@ -91,25 +91,24 @@ export type AppendAsConstTransformerOptions = DeepReadonly<{
   /**
    * Prefixes of the names of mutable types (see `convert-to-readonly`): a
    * variable whose type annotation names such a type, an expression that
-   * `satisfies` one and an arrow function body returning one get no
-   * `as const`, which would make them unassignable to it.
+   * `satisfies` one and an arrow function body returning one get no `as const`,
+   * which would make them unassignable to it.
    *
    * @default ['Mutable', 'mut_']
    */
   mutableTypePrefixes?: string[];
 
   /**
-   * Whether to remove redundant `as const` assertions from call arguments
-   * whose corresponding parameter type is exactly a `const`-modified type
-   * parameter.
+   * Whether to remove redundant `as const` assertions from call arguments whose
+   * corresponding parameter type is exactly a `const`-modified type parameter.
    *
    * (e.g. `f([1, 2] as const)` becomes `f([1, 2])` for
-   * `function f<const T>(x: T): T`, because the `const` type parameter
-   * already makes TypeScript infer the argument as if it were annotated
-   * with `as const`.)
+   * `function f<const T>(x: T): T`, because the `const` type parameter already
+   * makes TypeScript infer the argument as if it were annotated with
+   * `as const`.)
    *
-   * Only applies when the callee resolves to a single call signature within
-   * the transformed file itself; imported callees are left as they are.
+   * Only applies when the callee resolves to a single call signature within the
+   * transformed file itself; imported callees are left as they are.
    *
    * @default true
    */
@@ -144,6 +143,110 @@ type AsConstContext = Readonly<{
   isDirectUnderConstInitializer: boolean;
 }>;
 
+/**
+ * `x as const`, or `<const>x`, the angle-bracket spelling TypeScript treats
+ * identically (outside `.tsx`, where it does not parse).
+ */
+const isConstAssertionNode = (
+  node: tsm.Node,
+): node is tsm.AsExpression | tsm.TypeAssertion => {
+  if (isAsConstNode(node)) {
+    return true;
+  }
+
+  if (!tsm.Node.isTypeAssertion(node)) {
+    return false;
+  }
+
+  const typeNode = node.getTypeNode();
+
+  return (
+    typeNode !== undefined &&
+    typeNode.isKind(tsm.SyntaxKind.TypeReference) &&
+    typeNode.getTypeName().getText() === 'const' &&
+    Arr.isEmpty(typeNode.getTypeArguments())
+  );
+};
+
+/** `ns.MutableFoo` -> `MutableFoo` */
+const lastNameOf = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  entityName: tsm.EntityName,
+): string =>
+  (tsm.Node.isQualifiedName(entityName)
+    ? entityName.getRight()
+    : entityName
+  ).getText();
+
+/** `mut_x.items` -> `mut_x` */
+const firstNameOf = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  entityName: tsm.EntityName,
+): string =>
+  tsm.Node.isQualifiedName(entityName)
+    ? firstNameOf(entityName.getLeft())
+    : entityName.getText();
+
+const startsWithAny = (prefixes: ISet<string>, name: string): boolean =>
+  prefixes.some((p) => name.startsWith(p));
+
+/**
+ * The name a `typeof` starts from: a variable (`mut_x`) or a class, which
+ * `convert-to-readonly` leaves mutable by its type prefix (`MutableStore`).
+ */
+const isMutableValueName = (
+  name: string,
+  options: AppendAsConstTransformerOptionsInternal,
+): boolean =>
+  startsWithAny(options.mutableVariablePrefixes, name) ||
+  startsWithAny(options.mutableTypePrefixes, name);
+
+/**
+ * Whether `typeNode` names a type of a `mutableTypePrefixes` prefix anywhere in
+ * it (`MutableFoo`, `ns.MutableFoo[]`, `import('./m').MutableFoo | X`), or the
+ * type of a variable of a `mutableVariablePrefixes` prefix or a class of a
+ * `mutableTypePrefixes` one (`typeof mut_x`, `typeof MutableStore`). It reads
+ * names only, so an alias of another name for such a type is missed.
+ */
+const refersToMutableType = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  typeNode: tsm.TypeNode | undefined,
+  options: AppendAsConstTransformerOptionsInternal,
+): boolean => {
+  if (typeNode === undefined) {
+    return false;
+  }
+
+  const refers = (n: tsm.Node): boolean => {
+    if (n.isKind(tsm.SyntaxKind.TypeReference)) {
+      return startsWithAny(
+        options.mutableTypePrefixes,
+        lastNameOf(n.getTypeName()),
+      );
+    }
+
+    if (n.isKind(tsm.SyntaxKind.ImportType)) {
+      const qualifier = n.getQualifier();
+
+      return (
+        qualifier !== undefined &&
+        // typeof import('./m').mut_x names a value
+        (n.compilerNode.isTypeOf
+          ? isMutableValueName(firstNameOf(qualifier), options)
+          : startsWithAny(options.mutableTypePrefixes, lastNameOf(qualifier)))
+      );
+    }
+
+    // typeof mut_x, typeof mut_x.items, typeof MutableClass
+    return (
+      n.isKind(tsm.SyntaxKind.TypeQuery) &&
+      isMutableValueName(firstNameOf(n.getExprName()), options)
+    );
+  };
+
+  return refers(typeNode) || typeNode.getFirstDescendant(refers) !== undefined;
+};
+
 const transformNode = (
   node: tsm.Node,
   context: AsConstContext,
@@ -372,9 +475,9 @@ const transformNode = (
     return;
   }
 
-  // `<const>x` is handled as the `x as const` it means. Appending `as const`
-  // to `x` in place would read as `(<const>x) as const`, and every position
-  // that reaches here already takes an `as` expression.
+  // `<const>x` is handled as the `x as const` it means. Appending `as const` to
+  // `x` in place would read as `(<const>x) as const`, and every position that
+  // reaches here already takes an `as` expression.
   if (tsm.Node.isTypeAssertion(node) && isConstAssertionNode(node)) {
     const asConstText = `${node.getExpression().getText()} as const` as const;
 
@@ -465,78 +568,54 @@ const transformNode = (
   // return;
 };
 
-/**
- * Removes redundant `as const` assertions from call arguments whose
- * corresponding parameter type is exactly a `const`-modified type parameter
- * (e.g. `f([1, 2] as const)` for `function f<const T>(x: T): T`).
- *
- * A `const` type parameter makes TypeScript treat every inference candidate
- * as if it were annotated with `as const`, so when the parameter type is the
- * bare type parameter itself, removing the assertion cannot change the
- * inferred type. Conservative bail-outs (the `as const` is kept) when:
- *
- * - the callee does not resolve to exactly one call signature (unresolved
- *   imports resolve to none, since each file is transformed in an isolated
- *   single-file project; overloaded functions resolve to several),
- * - the call has explicit type arguments (inference is not involved),
- * - the argument is a spread argument or follows one (its parameter position
- *   is not statically known),
- * - the parameter type is not the bare type parameter (e.g. `readonly T[]`).
- */
-const removeAsConstInConstTypeParameterArgs = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  sourceAst: tsm.SourceFile,
-  options: AppendAsConstTransformerOptionsInternal,
-): void => {
-  // Reversed so that calls nested inside another call's arguments are
-  // processed before the outer call replaces (and thereby forgets) them.
-  for (const call of sourceAst
-    .getDescendantsOfKind(tsm.SyntaxKind.CallExpression)
-    .toReversed()) {
-    if (call.wasForgotten()) {
-      continue;
-    }
-
-    const args = call.getArguments();
+/** `node` with the parentheses written around it taken off. */
+const skipParenthesizedExpressions = (node: tsm.Node): tsm.Node =>
+  tsm.Node.isParenthesizedExpression(node)
+    ? skipParenthesizedExpressions(node.getExpression())
+    : node;
 
-    // Cheap syntactic pre-check before touching the type checker
-    if (
-      args.every(
-        (arg) => !isConstAssertionNode(skipParenthesizedExpressions(arg)),
-      )
-    ) {
-      continue;
-    }
+const getMatchedParameter = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  parameters: readonly tsm.ParameterDeclaration[],
+  argumentIndex: number,
+): tsm.ParameterDeclaration | undefined => {
+  if (argumentIndex < parameters.length) {
+    return parameters[argumentIndex];
+  }
 
-    if (hasDisableNextLineComment(call, TRANSFORMER_NAME)) {
-      continue;
-    }
+  const lastParameter = parameters.at(-1);
 
-    const variableStatement = call.getFirstAncestorByKind(
-      tsm.SyntaxKind.VariableStatement,
-    );
+  return lastParameter?.isRestParameter() === true ? lastParameter : undefined;
+};
 
-    if (
-      variableStatement !== undefined &&
-      hasDisableNextLineComment(variableStatement, TRANSFORMER_NAME)
-    ) {
-      continue;
-    }
+/**
+ * Whether the parameter's declared type is exactly a bare reference to one of
+ * the given `const`-modified type parameters (i.e. `x: T`, not `x: readonly
+ * T[]` or `x: Wrapper<T>` — there the argument expression's own type is still
+ * observable, so the `as const` is kept).
+ */
+const isBareConstTypeParameterReference = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  parameter: tsm.ParameterDeclaration,
+  constTypeParameterNames: ISet<string>,
+): boolean => {
+  const typeNode = parameter.getTypeNode();
 
-    // With explicit type arguments no inference happens, so the `as const`
-    // may be load-bearing for assignability.
-    if (!Arr.isEmpty(call.getTypeArguments())) {
-      continue;
-    }
+  if (typeNode === undefined) {
+    return false;
+  }
 
-    const callTarget = resolveSingleSignatureCallTarget(call);
+  if (!typeNode.isKind(tsm.SyntaxKind.TypeReference)) {
+    return false;
+  }
 
-    if (callTarget === undefined) {
-      continue;
-    }
+  const typeName = typeNode.getTypeName();
 
-    removeAsConstArgsOfCall(args, callTarget, options);
-  }
+  return (
+    typeName.isKind(tsm.SyntaxKind.Identifier) &&
+    Arr.isEmpty(typeNode.getTypeArguments()) &&
+    constTypeParameterNames.has(typeName.getText())
+  );
 };
 
 const removeAsConstArgsOfCall = (
@@ -597,61 +676,37 @@ const removeAsConstArgsOfCall = (
 };
 
 /**
- * `x as const`, or `<const>x`, the angle-bracket spelling TypeScript treats
- * identically (outside `.tsx`, where it does not parse).
+ * The parameters an argument list is matched against: a declared `this`
+ * parameter (`function f(this: void, a: T)`) stays in the AST's parameter list
+ * but takes no argument, so leaving it there would match every argument to the
+ * parameter on its left. TypeScript only allows it first.
  */
-const isConstAssertionNode = (
-  node: tsm.Node,
-): node is tsm.AsExpression | tsm.TypeAssertion => {
-  if (isAsConstNode(node)) {
-    return true;
-  }
-
-  if (!tsm.Node.isTypeAssertion(node)) {
-    return false;
-  }
-
-  const typeNode = node.getTypeNode();
-
-  return (
-    typeNode !== undefined &&
-    typeNode.isKind(tsm.SyntaxKind.TypeReference) &&
-    typeNode.getTypeName().getText() === 'const' &&
-    Arr.isEmpty(typeNode.getTypeArguments())
-  );
-};
-
-/** `node` with the parentheses written around it taken off. */
-const skipParenthesizedExpressions = (node: tsm.Node): tsm.Node =>
-  tsm.Node.isParenthesizedExpression(node)
-    ? skipParenthesizedExpressions(node.getExpression())
-    : node;
-
-type ResolvedCallTarget = Readonly<{
-  parameters: readonly tsm.ParameterDeclaration[];
-  constTypeParameterNames: ISet<string>;
-}>;
+const dropThisParameter = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- ts-morph nodes are mutable class instances
+  parameters: readonly tsm.ParameterDeclaration[],
+): readonly tsm.ParameterDeclaration[] =>
+  parameters.filter((parameter) => parameter.getName() !== 'this');
 
 /**
  * Resolves the callee of a call expression to the declaration of its single
- * call signature, and collects the names of that declaration's
- * `const`-modified type parameters.
+ * call signature, and collects the names of that declaration's `const`-modified
+ * type parameters.
  *
  * Returns `undefined` when the callee does not resolve to exactly one call
- * signature, the resolved declaration has no parameters or type parameters,
- * or none of the type parameters carry the `const` modifier.
+ * signature, the resolved declaration is of a kind that cannot carry both
+ * parameters and type parameters, or none of its type parameters carries the
+ * `const` modifier.
  */
 const resolveSingleSignatureCallTarget = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   call: tsm.CallExpression,
 ): ResolvedCallTarget | undefined => {
-  // The callee's type is read as the call sees it, after any `as`,
-  // `satisfies` or `!` around it: that is the signature the argument is
-  // inferred against, and an `as const` has no run-time effect for an inner
-  // layer to contradict.
+  // The callee's type is read as the call sees it, after any `as`, `satisfies`
+  // or `!` around it: that is the signature the argument is inferred against,
+  // and an `as const` has no run-time effect for an inner layer to contradict.
   //
-  // 0 signatures: the callee is unresolved (e.g. imported, since each file
-  // is transformed in an isolated single-file project).
+  // 0 signatures: the callee is unresolved (e.g. imported, since each file is
+  // transformed in an isolated single-file project).
   // 2+ signatures: overloads, where removing `as const` could change which
   // overload is selected.
   if (
@@ -677,9 +732,9 @@ const resolveSingleSignatureCallTarget = (
     return undefined;
   }
 
-  // Only type parameters declared on the call's own signature are inferred
-  // at the call site; a `const` type parameter of an enclosing declaration
-  // (e.g. a generic class containing this method) is already fixed there.
+  // Only type parameters declared on the call's own signature are inferred at
+  // the call site; a `const` type parameter of an enclosing declaration (e.g. a
+  // generic class containing this method) is already fixed there.
   const constTypeParameterNames = ISet.create(
     declaration
       .getTypeParameters()
@@ -692,130 +747,86 @@ const resolveSingleSignatureCallTarget = (
   }
 
   return {
-    parameters: declaration.getParameters(),
+    parameters: dropThisParameter(declaration.getParameters()),
     constTypeParameterNames,
   } as const;
 };
 
-const getMatchedParameter = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  parameters: readonly tsm.ParameterDeclaration[],
-  argumentIndex: number,
-): tsm.ParameterDeclaration | undefined => {
-  if (argumentIndex < parameters.length) {
-    return parameters[argumentIndex];
-  }
-
-  const lastParameter = parameters.at(-1);
-
-  return lastParameter?.isRestParameter() === true ? lastParameter : undefined;
-};
-
 /**
- * Whether the parameter's declared type is exactly a bare reference to one of
- * the given `const`-modified type parameters (i.e. `x: T`, not `x: readonly
- * T[]` or `x: Wrapper<T>` — there the argument expression's own type is still
- * observable, so the `as const` is kept).
+ * Removes redundant `as const` assertions from call arguments whose
+ * corresponding parameter type is exactly a `const`-modified type parameter
+ * (e.g. `f([1, 2] as const)` for `function f<const T>(x: T): T`).
+ *
+ * A `const` type parameter makes TypeScript treat every inference candidate as
+ * if it were annotated with `as const`, so when the parameter type is the bare
+ * type parameter itself, removing the assertion cannot change the inferred
+ * type. Conservative bail-outs (the `as const` is kept) when:
+ *
+ * - the callee does not resolve to exactly one call signature (unresolved
+ *   imports resolve to none, since each file is transformed in an isolated
+ *   single-file project; overloaded functions resolve to several),
+ * - the call has explicit type arguments (inference is not involved),
+ * - the argument is a spread argument or follows one (its parameter position
+ *   is not statically known),
+ * - the parameter type is not the bare type parameter (e.g. `readonly T[]`).
  */
-const isBareConstTypeParameterReference = (
+const removeAsConstInConstTypeParameterArgs = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  parameter: tsm.ParameterDeclaration,
-  constTypeParameterNames: ISet<string>,
-): boolean => {
-  const typeNode = parameter.getTypeNode();
-
-  if (typeNode === undefined) {
-    return false;
-  }
-
-  if (!typeNode.isKind(tsm.SyntaxKind.TypeReference)) {
-    return false;
-  }
-
-  const typeName = typeNode.getTypeName();
-
-  return (
-    typeName.isKind(tsm.SyntaxKind.Identifier) &&
-    Arr.isEmpty(typeNode.getTypeArguments()) &&
-    constTypeParameterNames.has(typeName.getText())
-  );
-};
+  sourceAst: tsm.SourceFile,
+  options: AppendAsConstTransformerOptionsInternal,
+): void => {
+  // Reversed so that calls nested inside another call's arguments are processed
+  // before the outer call replaces (and thereby forgets) them.
+  for (const call of sourceAst
+    .getDescendantsOfKind(tsm.SyntaxKind.CallExpression)
+    .toReversed()) {
+    if (call.wasForgotten()) {
+      continue;
+    }
 
-/** `ns.MutableFoo` -> `MutableFoo` */
-const lastNameOf = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  entityName: tsm.EntityName,
-): string =>
-  (tsm.Node.isQualifiedName(entityName)
-    ? entityName.getRight()
-    : entityName
-  ).getText();
+    const args = call.getArguments();
 
-/** `mut_x.items` -> `mut_x` */
-const firstNameOf = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  entityName: tsm.EntityName,
-): string =>
-  tsm.Node.isQualifiedName(entityName)
-    ? firstNameOf(entityName.getLeft())
-    : entityName.getText();
+    // Cheap syntactic pre-check before touching the type checker
+    if (
+      args.every(
+        (arg) => !isConstAssertionNode(skipParenthesizedExpressions(arg)),
+      )
+    ) {
+      continue;
+    }
 
-const startsWithAny = (prefixes: ISet<string>, name: string): boolean =>
-  prefixes.some((p) => name.startsWith(p));
+    if (hasDisableNextLineComment(call, TRANSFORMER_NAME)) {
+      continue;
+    }
 
-/**
- * The name a `typeof` starts from: a variable (`mut_x`) or a class, which
- * `convert-to-readonly` leaves mutable by its type prefix (`MutableStore`).
- */
-const isMutableValueName = (
-  name: string,
-  options: AppendAsConstTransformerOptionsInternal,
-): boolean =>
-  startsWithAny(options.mutableVariablePrefixes, name) ||
-  startsWithAny(options.mutableTypePrefixes, name);
+    const variableStatement = call.getFirstAncestorByKind(
+      tsm.SyntaxKind.VariableStatement,
+    );
 
-/**
- * Whether `typeNode` names a type of a `mutableTypePrefixes` prefix anywhere
- * in it (`MutableFoo`, `ns.MutableFoo[]`, `import('./m').MutableFoo | X`), or
- * the type of a variable of a `mutableVariablePrefixes` prefix or a class of
- * a `mutableTypePrefixes` one (`typeof mut_x`, `typeof MutableStore`). It reads names only, so an alias of another name for such
- * a type is missed.
- */
-const refersToMutableType = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  typeNode: tsm.TypeNode | undefined,
-  options: AppendAsConstTransformerOptionsInternal,
-): boolean => {
-  if (typeNode === undefined) {
-    return false;
-  }
+    if (
+      variableStatement !== undefined &&
+      hasDisableNextLineComment(variableStatement, TRANSFORMER_NAME)
+    ) {
+      continue;
+    }
 
-  const refers = (n: tsm.Node): boolean => {
-    if (n.isKind(tsm.SyntaxKind.TypeReference)) {
-      return startsWithAny(
-        options.mutableTypePrefixes,
-        lastNameOf(n.getTypeName()),
-      );
+    // With explicit type arguments no inference happens, so the `as const` may
+    // be load-bearing for assignability.
+    if (!Arr.isEmpty(call.getTypeArguments())) {
+      continue;
     }
 
-    if (n.isKind(tsm.SyntaxKind.ImportType)) {
-      const qualifier = n.getQualifier();
+    const callTarget = resolveSingleSignatureCallTarget(call);
 
-      return (
-        qualifier !== undefined &&
-        // typeof import('./m').mut_x names a value
-        (n.compilerNode.isTypeOf
-          ? isMutableValueName(firstNameOf(qualifier), options)
-          : startsWithAny(options.mutableTypePrefixes, lastNameOf(qualifier)))
-      );
+    if (callTarget === undefined) {
+      continue;
     }
 
-    // typeof mut_x, typeof mut_x.items, typeof MutableClass
-    return (
-      n.isKind(tsm.SyntaxKind.TypeQuery) &&
-      isMutableValueName(firstNameOf(n.getExprName()), options)
-    );
-  };
-
-  return refers(typeNode) || typeNode.getFirstDescendant(refers) !== undefined;
+    removeAsConstArgsOfCall(args, callTarget, options);
+  }
 };
+
+type ResolvedCallTarget = Readonly<{
+  parameters: readonly tsm.ParameterDeclaration[];
+  constTypeParameterNames: ISet<string>;
+}>;