ts-codemod-lib 3.5.1 → 4.0.1

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

@@ -1,6 +1,10 @@
-import { Arr, ISet } from 'ts-data-forge';
+import { Arr, ISet, isRecord } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
 import type { DeepReadonly } from 'ts-type-forge';
+import {
+  DEFAULT_MUTABLE_PREFIXES,
+  DEFAULT_MUTABLE_TYPE_PREFIXES,
+} from '../constants/index.mjs';
 import {
   hasDisableNextLineComment,
   isAsConstNode,
@@ -16,16 +20,26 @@ const TRANSFORMER_NAME = 'append-as-const';
 export const appendAsConstTransformer = (
   options?: AppendAsConstTransformerOptions,
 ): TsMorphTransformer => {
-  // The ESLint counterpart is `ignoredMutablePattern` in
-  // `libs/eslint-config-typed/src/rules/eslint-functional-rules.mts`; change
-  // the two together.
-  const ignorePrefixes = ISet.create(
-    options?.ignorePrefixes ?? ['mut_', '#mut_', '_mut_', 'draft'],
-  );
+  // Removed in 4.0.0; a caller without types would otherwise lose it silently.
+  const untypedOptions: unknown = options;
+
+  if (
+    isRecord(untypedOptions) &&
+    untypedOptions['ignorePrefixes'] !== undefined
+  ) {
+    throw new Error(
+      `The "ignorePrefixes" option of ${TRANSFORMER_NAME} was renamed to "mutableVariablePrefixes".`,
+    );
+  }
 
   const optionsInternal: AppendAsConstTransformerOptionsInternal = {
     applyLevel: options?.applyLevel ?? 'avoidInFunctionArgs',
-    ignoredPrefixes: ignorePrefixes,
+    mutableVariablePrefixes: ISet.create(
+      options?.mutableVariablePrefixes ?? DEFAULT_MUTABLE_PREFIXES,
+    ),
+    mutableTypePrefixes: ISet.create(
+      options?.mutableTypePrefixes ?? DEFAULT_MUTABLE_TYPE_PREFIXES,
+    ),
     removeAsConstForConstTypeParameters:
       options?.removeAsConstForConstTypeParameters ?? true,
 
@@ -66,26 +80,35 @@ export type AppendAsConstTransformerOptions = DeepReadonly<{
   applyLevel?: 'all' | 'avoidInFunctionArgs';
 
   /**
-   * A mute keywords to ignore the readonly conversion.
+   * Prefixes of the names of variables that are left mutable: their
+   * initializers get no `as const`, nor does a value annotated with their type
+   * (`typeof mut_x`).
    *
-   * (e.g. `"mut_"`)
+   * @default ['mut_']
+   */
+  mutableVariablePrefixes?: string[];
+
+  /**
+   * 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.
    *
-   * @default ['mut_', '#mut_', '_mut_', 'draft']
+   * @default ['Mutable', 'mut_']
    */
-  ignorePrefixes?: string[];
+  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
    */
@@ -96,7 +119,8 @@ export type AppendAsConstTransformerOptions = DeepReadonly<{
 
 type AppendAsConstTransformerOptionsInternal = DeepReadonly<{
   applyLevel: 'all' | 'avoidInFunctionArgs';
-  ignoredPrefixes: ISet<string>;
+  mutableVariablePrefixes: ISet<string>;
+  mutableTypePrefixes: ISet<string>;
   removeAsConstForConstTypeParameters: boolean;
 
   debugPrint: (...args: readonly unknown[]) => void;
@@ -119,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,
@@ -146,11 +274,13 @@ const transformNode = (
   if (node.isKind(tsm.SyntaxKind.VariableDeclaration)) {
     const nodeName = node.getName();
 
-    // check for ignorePrefix
-    if (options.ignoredPrefixes.some((p) => nodeName.startsWith(p))) {
+    // check for mutableVariablePrefixes
+    if (options.mutableVariablePrefixes.some((p) => nodeName.startsWith(p))) {
       // Skip conversion for variable declarations with ignored prefixes
       // Example: const mut_foo: string[] = []; -> remains as is, without appending `as const`
-      options.debugPrint('skipped variable declaration by ignorePrefixes');
+      options.debugPrint(
+        'skipped variable declaration by mutableVariablePrefixes',
+      );
 
       return;
     }
@@ -170,6 +300,18 @@ const transformNode = (
       return;
     }
 
+    // Example: const foo: MutableFoo = { a: [] }; -> remains as is, because
+    // `as const` would make the initializer unassignable to `MutableFoo`
+    const typeNode = node.getTypeNode();
+
+    if (refersToMutableType(typeNode, options)) {
+      options.debugPrint(
+        'skipped variable declaration annotated with a mutable type',
+      );
+
+      return;
+    }
+
     const declarationKindKeywords = node
       .getVariableStatement()
       ?.getDeclarationKindKeywords()
@@ -192,13 +334,13 @@ const transformNode = (
     }
 
     // const [a, b] = ...;
-    // TODO: Support ignoredPrefixes in ArrayBindingPattern
+    // TODO: Support mutableVariablePrefixes in ArrayBindingPattern
     // if (ts.isArrayBindingPattern(nodeName)) {
     //   // for (const [i, el] of nodeName.elements.entries())
     // }
 
     // const { x, y } = ...;
-    // TODO: Support ignoredPrefixes in ObjectBindingPattern
+    // TODO: Support mutableVariablePrefixes in ObjectBindingPattern
     // if (ts.isObjectBindingPattern(nodeName)) {
     //   // for (const [i, el] of nodeName.elements.entries())
     // }
@@ -221,6 +363,14 @@ const transformNode = (
 
   // pass by ([X satisfies ...] -> X)
   if (tsm.Node.isSatisfiesExpression(node)) {
+    // Example: { a: [] } satisfies MutableFoo -> remains as is, because
+    // `as const` would make it fail to satisfy `MutableFoo`
+    if (refersToMutableType(node.getTypeNode(), options)) {
+      options.debugPrint('skipped satisfies expression with a mutable type');
+
+      return;
+    }
+
     transformNode(node.getExpression(), context, options);
 
     return;
@@ -239,6 +389,14 @@ const transformNode = (
 
   // pass by arrow function body ([() => X] -> X)
   if (tsm.Node.isArrowFunction(node)) {
+    // Example: (): MutableFoo => ({ a: [] }) -> remains as is, because
+    // `as const` would make the body unassignable to `MutableFoo`
+    if (refersToMutableType(node.getReturnTypeNode(), options)) {
+      options.debugPrint('skipped arrow function with a mutable return type');
+
+      return;
+    }
+
     const body = node.getBody();
 
     transformNode(body, context, options);
@@ -317,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;
 
@@ -410,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 = (
@@ -542,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 (
@@ -622,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()
@@ -637,51 +747,86 @@ const resolveSingleSignatureCallTarget = (
   }
 
   return {
-    parameters: declaration.getParameters(),
+    parameters: dropThisParameter(declaration.getParameters()),
     constTypeParameterNames,
   } as const;
 };
 
-const getMatchedParameter = (
+/**
+ * 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
-  parameters: readonly tsm.ParameterDeclaration[],
-  argumentIndex: number,
-): tsm.ParameterDeclaration | undefined => {
-  if (argumentIndex < parameters.length) {
-    return parameters[argumentIndex];
-  }
+  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 lastParameter = parameters.at(-1);
+    const args = call.getArguments();
 
-  return lastParameter?.isRestParameter() === true ? lastParameter : undefined;
-};
+    // Cheap syntactic pre-check before touching the type checker
+    if (
+      args.every(
+        (arg) => !isConstAssertionNode(skipParenthesizedExpressions(arg)),
+      )
+    ) {
+      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();
+    if (hasDisableNextLineComment(call, TRANSFORMER_NAME)) {
+      continue;
+    }
 
-  if (typeNode === undefined) {
-    return false;
-  }
+    const variableStatement = call.getFirstAncestorByKind(
+      tsm.SyntaxKind.VariableStatement,
+    );
 
-  if (!typeNode.isKind(tsm.SyntaxKind.TypeReference)) {
-    return false;
-  }
+    if (
+      variableStatement !== undefined &&
+      hasDisableNextLineComment(variableStatement, TRANSFORMER_NAME)
+    ) {
+      continue;
+    }
 
-  const typeName = typeNode.getTypeName();
+    // With explicit type arguments no inference happens, so the `as const` may
+    // be load-bearing for assignability.
+    if (!Arr.isEmpty(call.getTypeArguments())) {
+      continue;
+    }
 
-  return (
-    typeName.isKind(tsm.SyntaxKind.Identifier) &&
-    Arr.isEmpty(typeNode.getTypeArguments()) &&
-    constTypeParameterNames.has(typeName.getText())
-  );
+    const callTarget = resolveSingleSignatureCallTarget(call);
+
+    if (callTarget === undefined) {
+      continue;
+    }
+
+    removeAsConstArgsOfCall(args, callTarget, options);
+  }
 };
+
+type ResolvedCallTarget = Readonly<{
+  parameters: readonly tsm.ParameterDeclaration[];
+  constTypeParameterNames: ISet<string>;
+}>;