ts-codemod-lib 3.1.0 → 3.2.0

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

@@ -20,6 +20,8 @@ export const appendAsConstTransformer = (
   const optionsInternal: AppendAsConstTransformerOptionsInternal = {
     applyLevel: options?.applyLevel ?? 'avoidInFunctionArgs',
     ignoredPrefixes: ignorePrefixes,
+    removeAsConstForConstTypeParameters:
+      options?.removeAsConstForConstTypeParameters ?? true,
 
     debugPrint: options?.debug === true ? console.debug : () => {},
     replaceNode:
@@ -43,6 +45,10 @@ export const appendAsConstTransformer = (
           optionsInternal,
         );
       }
+
+      if (optionsInternal.removeAsConstForConstTypeParameters) {
+        removeAsConstInConstTypeParameterArgs(sourceAst, optionsInternal);
+      }
     },
   };
 };
@@ -62,8 +68,22 @@ export type AppendAsConstTransformerOptions = DeepReadonly<{
    */
   ignorePrefixes?: string[];
 
-  // TODO
-  // ignoreConstTypeParameter?: boolean;
+  /**
+   * 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`.)
+   *
+   * 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
+   */
+  removeAsConstForConstTypeParameters?: boolean;
 
   debug?: boolean;
 }>;
@@ -71,6 +91,7 @@ export type AppendAsConstTransformerOptions = DeepReadonly<{
 type AppendAsConstTransformerOptionsInternal = DeepReadonly<{
   applyLevel: 'all' | 'avoidInFunctionArgs';
   ignoredPrefixes: ISet<string>;
+  removeAsConstForConstTypeParameters: boolean;
 
   debugPrint: (...args: readonly unknown[]) => void;
   replaceNode: (node: tsm.Node, newNodeText: string) => void;
@@ -364,3 +385,231 @@ 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();
+
+    // Cheap syntactic pre-check before touching the type checker
+    if (!args.some(isAsConstNode)) {
+      continue;
+    }
+
+    if (hasDisableNextLineComment(call, TRANSFORMER_NAME)) {
+      continue;
+    }
+
+    const variableStatement = call.getFirstAncestorByKind(
+      tsm.SyntaxKind.VariableStatement,
+    );
+
+    if (
+      variableStatement !== undefined &&
+      hasDisableNextLineComment(variableStatement, TRANSFORMER_NAME)
+    ) {
+      continue;
+    }
+
+    // With explicit type arguments no inference happens, so the `as const`
+    // may be load-bearing for assignability.
+    if (!Arr.isEmpty(call.getTypeArguments())) {
+      continue;
+    }
+
+    const callTarget = resolveSingleSignatureCallTarget(call);
+
+    if (callTarget === undefined) {
+      continue;
+    }
+
+    removeAsConstArgsOfCall(args, callTarget, options);
+  }
+};
+
+const removeAsConstArgsOfCall = (
+  args: readonly tsm.Node[],
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  callTarget: ResolvedCallTarget,
+  options: AppendAsConstTransformerOptionsInternal,
+): void => {
+  // Argument positions at or after a spread argument cannot be mapped to a
+  // parameter statically.
+  const firstSpreadIndex = args.findIndex((a) =>
+    a.isKind(tsm.SyntaxKind.SpreadElement),
+  );
+
+  const mappableArgCount =
+    firstSpreadIndex === -1 ? args.length : firstSpreadIndex;
+
+  for (const [argumentIndex, argument] of args.entries()) {
+    if (argumentIndex >= mappableArgCount) {
+      return;
+    }
+
+    if (argument.wasForgotten() || !isAsConstNode(argument)) {
+      continue;
+    }
+
+    if (hasDisableNextLineComment(argument, TRANSFORMER_NAME)) {
+      continue;
+    }
+
+    const parameter = getMatchedParameter(callTarget.parameters, argumentIndex);
+
+    if (
+      parameter === undefined ||
+      !isBareConstTypeParameterReference(
+        parameter,
+        callTarget.constTypeParameterNames,
+      )
+    ) {
+      continue;
+    }
+
+    options.debugPrint(
+      'removing redundant as const in const type parameter argument',
+      argument.getText(),
+    );
+
+    options.replaceNode(argument, argument.getExpression().getText());
+  }
+};
+
+type ResolvedCallTarget = Readonly<{
+  parameters: readonly tsm.ParameterDeclaration[];
+  constTypeParameterNames: ISet<string>;
+}>;
+
+/**
+ * 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.
+ *
+ * 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.
+ */
+const resolveSingleSignatureCallTarget = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  call: tsm.CallExpression,
+): ResolvedCallTarget | undefined => {
+  // 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 (
+    !Arr.isFixedLengthArray(
+      1,
+      call.getExpression().getType().getCallSignatures(),
+    )
+  ) {
+    return undefined;
+  }
+
+  const declaration = call
+    .getProject()
+    .getTypeChecker()
+    .getResolvedSignature(call)
+    ?.getDeclaration();
+
+  if (
+    declaration === undefined ||
+    !tsm.Node.isParametered(declaration) ||
+    !tsm.Node.isTypeParametered(declaration)
+  ) {
+    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.
+  const constTypeParameterNames = ISet.create(
+    declaration
+      .getTypeParameters()
+      .filter((tp) => tp.hasModifier(tsm.SyntaxKind.ConstKeyword))
+      .map((tp) => tp.getName()),
+  );
+
+  if (constTypeParameterNames.size === 0) {
+    return undefined;
+  }
+
+  return {
+    parameters: 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).
+ */
+const isBareConstTypeParameterReference = (
+  // 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())
+  );
+};

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

@@ -11,10 +11,12 @@ import { transformSourceCode } from './transform-source-code.mjs';
 const testFn = async ({
   source,
   expected,
+  options,
   debug,
 }: Readonly<{
   source: string;
   expected: string;
+  options?: Parameters<typeof appendAsConstTransformer>[0];
   debug?: boolean;
 }>): Promise<void> => {
   if (debug !== true) {
@@ -26,7 +28,9 @@ const testFn = async ({
   }
 
   const transformed = await formatter(
-    transformSourceCode(source, false, [appendAsConstTransformer({ debug })]),
+    transformSourceCode(source, false, [
+      appendAsConstTransformer({ ...options, debug }),
+    ]),
   );
 
   const expectedFormatted = await formatter(expected);
@@ -698,6 +702,174 @@ describe(appendAsConstTransformer, () => {
     ])('$name', testFn);
   });
 
+  describe('Redundant as const in const type parameter arguments', () => {
+    test.each([
+      {
+        name: 'const type parameter (function declaration) should remove as const',
+        source: dedent`
+          function f<const T>(x: T): T { return x; }
+          const a = f([1, 2] as const);
+        `,
+        expected: dedent`
+          function f<const T>(x: T): T { return x; }
+          const a = f([1, 2]);
+        `,
+      },
+      {
+        name: 'const type parameter (expression statement call) should remove as const',
+        source: dedent`
+          function f<const T>(x: T): T { return x; }
+          f({ x: 1 } as const);
+        `,
+        expected: dedent`
+          function f<const T>(x: T): T { return x; }
+          f({ x: 1 });
+        `,
+      },
+      {
+        name: 'const type parameter (arrow function) should remove as const',
+        source: dedent`
+          const f = <const S,>(x: S): S => x;
+          const a = f([1, 2] as const);
+        `,
+        expected: dedent`
+          const f = <const S,>(x: S): S => x;
+          const a = f([1, 2]);
+        `,
+      },
+      {
+        name: 'const type parameter (object literal method) should remove as const',
+        source: dedent`
+          const Obj = { m: <const U,>(x: U): U => x } as const;
+          const a = Obj.m([1] as const);
+        `,
+        expected: dedent`
+          const Obj = { m: <const U,>(x: U): U => x } as const;
+          const a = Obj.m([1]);
+        `,
+      },
+      {
+        name: 'const rest type parameter should remove as const',
+        source: dedent`
+          function rest<const T extends readonly unknown[]>(...xs: T): T { return xs; }
+          const r = rest(1 as const, [2, 3] as const);
+        `,
+        expected: dedent`
+          function rest<const T extends readonly unknown[]>(...xs: T): T { return xs; }
+          const r = rest(1, [2, 3]);
+        `,
+      },
+      {
+        name: 'mixed const and non-const type parameters should only remove for const ones',
+        source: dedent`
+          function h<const A, B>(a: A, b: B): A { return a; }
+          const m = h([1] as const, [2] as const);
+        `,
+        expected: dedent`
+          function h<const A, B>(a: A, b: B): A { return a; }
+          const m = h([1], [2] as const);
+        `,
+      },
+      {
+        name: 'non-const type parameter should keep as const',
+        source: dedent`
+          function g<T>(x: T): T { return x; }
+          const b = g([1, 2] as const);
+        `,
+        expected: dedent`
+          function g<T>(x: T): T { return x; }
+          const b = g([1, 2] as const);
+        `,
+      },
+      {
+        name: 'imported callee should keep as const',
+        source: dedent`
+          import { f } from './other.mjs';
+          const a = f([1, 2] as const);
+        `,
+        expected: dedent`
+          import { f } from './other.mjs';
+          const a = f([1, 2] as const);
+        `,
+      },
+      {
+        name: 'overloaded function should keep as const',
+        source: dedent`
+          function ov<const T>(x: T): T;
+          function ov(x: number): number;
+          function ov(x: unknown): unknown { return x; }
+          const e = ov([1] as const);
+        `,
+        expected: dedent`
+          function ov<const T>(x: T): T;
+          function ov(x: number): number;
+          function ov(x: unknown): unknown { return x; }
+          const e = ov([1] as const);
+        `,
+      },
+      {
+        name: 'explicit type arguments should keep as const',
+        source: dedent`
+          function f<const T>(x: T): T { return x; }
+          const j = f<readonly [1, 2]>([1, 2] as const);
+        `,
+        expected: dedent`
+          function f<const T>(x: T): T { return x; }
+          const j = f<readonly [1, 2]>([1, 2] as const);
+        `,
+      },
+      {
+        name: 'non-bare type parameter reference (readonly T[]) should keep as const',
+        source: dedent`
+          function ro<const T>(xs: readonly T[]): T { return xs[0] as T; }
+          const o = ro([1, 2] as const);
+        `,
+        expected: dedent`
+          function ro<const T>(xs: readonly T[]): T { return xs[0] as T; }
+          const o = ro([1, 2] as const);
+        `,
+      },
+      {
+        name: 'argument after spread argument should keep as const',
+        source: dedent`
+          function f<const T>(a: T, b: T): T { return a; }
+          const xs = [1, 2] as const;
+          const s = f(...xs, [3] as const);
+        `,
+        expected: dedent`
+          function f<const T>(a: T, b: T): T { return a; }
+          const xs = [1, 2] as const;
+          const s = f(...xs, [3] as const);
+        `,
+      },
+      {
+        name: 'transformer-ignore-next-line should keep as const',
+        source: dedent`
+          function f<const T>(x: T): T { return x; }
+          // transformer-ignore-next-line
+          const a = f([1, 2] as const);
+        `,
+        expected: dedent`
+          function f<const T>(x: T): T { return x; }
+          // transformer-ignore-next-line
+          const a = f([1, 2] as const);
+        `,
+      },
+      {
+        name: 'removeAsConstForConstTypeParameters: false should keep as const',
+        source: dedent`
+          function f<const T>(x: T): T { return x; }
+          const a = f([1, 2] as const);
+        `,
+        expected: dedent`
+          function f<const T>(x: T): T { return x; }
+          const a = f([1, 2] as const);
+        `,
+        options: { removeAsConstForConstTypeParameters: false },
+      },
+    ])('$name', testFn);
+  });
+
   describe('ignorePrefixes option (mut_ prefix)', () => {
     test.each([
       {

package/src/functions/ast-transformers/convert-to-readonly.mts

@@ -1445,6 +1445,26 @@ const transformUnionOrIntersectionTypeNodeImpl = (
 };
 
 const unionToString = ({
+  types: typesRaw,
+  op,
+  wrapWithReadonly,
+}: Readonly<{
+  types: readonly string[];
+  op: '&' | '|';
+  wrapWithReadonly: boolean | string;
+}>): string => {
+  // The members arrive as `getFullText()`, which carries the whitespace in
+  // front of each one, and they are joined with a separator that supplies its
+  // own space. Left alone, that whitespace accumulates: every run of the
+  // transformer adds one more space before every member but the first, so a
+  // file never reaches a fixed point. Comments live in the same trivia and are
+  // not whitespace, so trimming keeps them.
+  const types = typesRaw.map((s) => s.trim());
+
+  return unionToStringImpl({ types, op, wrapWithReadonly });
+};
+
+const unionToStringImpl = ({
   types,
   op,
   wrapWithReadonly,

package/src/functions/ast-transformers/convert-to-readonly.test.mts

@@ -4352,3 +4352,29 @@ const toUnionAndIntersectionTestCase = ({
     name: title(op === '&' ? 'Intersection' : 'Union'),
     ...testCase(op),
   }));
+
+describe('idempotency', () => {
+  test('a union whose members carry leading whitespace reaches a fixed point', () => {
+    // The members are read with `getFullText()`, which includes the whitespace
+    // in front of each one, and joined with a separator that adds its own. Left
+    // alone the two compound, and a file with `// prettier-ignore` on a long
+    // union grows by one space per member on every run — nothing downstream
+    // normalizes it back.
+    const code = [
+      '// prettier-ignore',
+      'export type P = ',
+      '    (0 |  0.1 |  0.2 |  0.3);',
+      '',
+    ].join('\n');
+
+    const once = transformSourceCode(code, false, [
+      convertToReadonlyTransformer(),
+    ]);
+
+    const twice = transformSourceCode(once, false, [
+      convertToReadonlyTransformer(),
+    ]);
+
+    expect(twice).toBe(once);
+  });
+});