ts-codemod-lib 4.0.0 → 4.1.0

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>;
+}>;

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

@@ -8,6 +8,12 @@ import * as prettier from 'prettier/standalone';
 import { appendAsConstTransformer } from './append-as-const.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,
@@ -38,12 +44,6 @@ const testFn = async ({
   expect(transformed).toBe(expectedFormatted);
 };
 
-const formatter = (code: string): Promise<string> =>
-  prettier.format(code, {
-    parser: 'typescript',
-    plugins: [prettierPluginTypeScript, prettierPluginEstree],
-  });
-
 describe(appendAsConstTransformer, () => {
   describe('Primitive types (should not add as const)', () => {
     test.each([
@@ -794,6 +794,39 @@ describe(appendAsConstTransformer, () => {
           const m = h([1], [2] as const);
         `,
       },
+      {
+        name: 'a declared this parameter should not shift arguments onto the parameter to their left',
+        source: dedent`
+          declare function f<const T, U>(this: void, a: T, b: U): U;
+          const r = f(1, [1, 2] as const);
+        `,
+        expected: dedent`
+          declare function f<const T, U>(this: void, a: T, b: U): U;
+          const r = f(1, [1, 2] as const);
+        `,
+      },
+      {
+        name: 'a declared this parameter should still let the matching argument lose as const',
+        source: dedent`
+          declare function f<const T, U>(this: void, a: T, b: U): T;
+          const r = f([1, 2] as const, [3] as const);
+        `,
+        expected: dedent`
+          declare function f<const T, U>(this: void, a: T, b: U): T;
+          const r = f([1, 2], [3] as const);
+        `,
+      },
+      {
+        name: 'a this parameter in a function type should be skipped too',
+        source: dedent`
+          declare const g: <const T>(this: void, x: T) => T;
+          const r = g([1] as const);
+        `,
+        expected: dedent`
+          declare const g: <const T>(this: void, x: T) => T;
+          const r = g([1]);
+        `,
+      },
       {
         name: 'non-const type parameter should keep as const',
         source: dedent`