fix: handle type parameters with the same name (#126)

Co-authored-by: Kevin Deng <sxzz@sxzz.moe>

Author: ocavue

src/fake-js.ts

@@ -25,10 +25,19 @@ import type { Plugin, RenderedChunk } from 'rolldown'
 // export declare function x$1(xx: X$1): void
 
 type Dep = t.Expression & { replace?: (newNode: t.Node) => void }
+
+/**
+ * A collection of type parameters grouped by parameter name
+ */
+type GroupedTypeParams = Array<{
+  name: string
+  typeParams: t.TSTypeParameter[]
+}>
+
 interface SymbolInfo {
   decl: t.Declaration
   bindings: t.Identifier[]
-  params: t.TSTypeParameter[]
+  params: GroupedTypeParams
   deps: Dep[]
 }
 
@@ -179,11 +188,7 @@ export function createFakeJsPlugin({
         decl.id = binding
       }
 
-      const params: t.TSTypeParameter[] =
-        'typeParameters' in decl &&
-        decl.typeParameters?.type === 'TSTypeParameterDeclaration'
-          ? decl.typeParameters.params
-          : []
+      const params: GroupedTypeParams = collectParams(decl)
 
       const deps = collectDependencies(decl, namespaceStmts)
 
@@ -200,7 +205,7 @@ export function createFakeJsPlugin({
 
       const symbolIdNode = t.numericLiteral(symbolId)
       const depsNode = t.arrowFunctionExpression(
-        params.map((param) => t.identifier(param.name)),
+        params.map(({ name }) => t.identifier(name)),
         t.arrayExpression(deps),
       )
       const sideEffectNode =
@@ -312,10 +317,12 @@ export function createFakeJsPlugin({
         }
 
         const transformedParams = depsFn.params as t.Identifier[]
-        for (let i = 0; i < original.params.length; i++) {
-          const originalParam = original.params[i]
-          const transformedParam = transformedParams[i]
-          originalParam.name = transformedParam.name
+
+        for (const [i, transformedParam] of transformedParams.entries()) {
+          const transformedName = transformedParam.name
+          for (const originalTypeParam of original.params[i].typeParams) {
+            originalTypeParam.name = transformedName
+          }
         }
 
         const transformedDeps = (depsFn.body as t.ArrayExpression)
@@ -385,6 +392,42 @@ export function createFakeJsPlugin({
     return symbolMap.get(symbolId)!
   }
 
+  /**
+   * Collects all TSTypeParameter nodes from the given node and groups them by
+   * their name. One name can associate with one or more type parameters. These
+   * names will be used as the parameter name in the generated JavaScript
+   * dependency function.
+   */
+  function collectParams(node: t.Node): GroupedTypeParams {
+    const typeParams: t.TSTypeParameter[] = []
+    ;(walk as any)(node, {
+      leave(node: t.Node) {
+        if (
+          'typeParameters' in node &&
+          node.typeParameters?.type === 'TSTypeParameterDeclaration'
+        ) {
+          typeParams.push(...node.typeParameters.params)
+        }
+      },
+    })
+
+    const paramMap = new Map<string, t.TSTypeParameter[]>()
+    for (const typeParam of typeParams) {
+      const name = typeParam.name
+      const group = paramMap.get(name)
+      if (group) {
+        group.push(typeParam)
+      } else {
+        paramMap.set(name, [typeParam])
+      }
+    }
+
+    return Array.from(paramMap.entries()).map(([name, typeParams]) => ({
+      name,
+      typeParams,
+    }))
+  }
+
   function collectDependencies(
     node: t.Node,
     namespaceStmts: NamespaceMap,

tests/__snapshots__/index.test.ts.snap

@@ -81,12 +81,12 @@ export = _default;"
 `;
 
 exports[`cyclic import 1`] = `
-"// a-xNP_tEJE.d.ts
+"// a-C1hvFFD1.d.ts
 //#region b.d.ts
 declare class SomeClass<T$1 extends SomeInterface<number>> {
   value: T$1;
   constructor(value: T$1);
-  doSomething<T extends SomeInterface<number>>(value: T$1): T$1;
+  doSomething<T$1 extends SomeInterface<number>>(value: T$1): T$1;
 }
 type SomeBoolean = boolean;
 //#endregion
@@ -98,10 +98,10 @@ type T = SomeBoolean;
 //#endregion
 export { SomeClass as i, T as n, SomeBoolean as r, SomeInterface as t };
 // a.d.ts
-import { n as T, t as SomeInterface } from "./a-xNP_tEJE.js";
+import { n as T, t as SomeInterface } from "./a-C1hvFFD1.js";
 export { SomeInterface, T };
 // b.d.ts
-import { i as SomeClass, r as SomeBoolean } from "./a-xNP_tEJE.js";
+import { i as SomeClass, r as SomeBoolean } from "./a-C1hvFFD1.js";
 export { SomeBoolean, SomeClass };"
 `;
 

tests/rollup-plugin-dts/generics/known-diff.patch

@@ -2,33 +2,8 @@ Index: diff.patch
 ===================================================================
 --- diff.patch
 +++ diff.patch
-@@ -13,23 +13,22 @@
- interface M {}
- interface N {}
- interface O {}
- interface P {}
--declare type Gen<T> = T
--interface I1<T = A> {
--  a: T
-+declare type Gen<T$1> = T$1
-+interface I1<T$1 = A> {
-+  a: T$1
-   b: Gen<B>
- }
--declare type Ty<T = C> = {
--  c: T
-+declare type Ty<T$1 = C> = {
-+  c: T$1
-   d: Gen<D>
- }
--declare class Cl<T = E> {
--  e: T
-+declare class Cl<T$1 = E> {
-+  e: T$1
-   f: Gen<F>
- }
--declare function fn<T = G>(g: T, h: Gen<H>): void
-+declare function fn<T$1 = G>(g: T$1, h: Gen<H>): void
+@@ -30,6 +30,5 @@
+ declare function fn<T = G>(g: T, h: Gen<H>): void
  declare type TyFn = <T = J>(j: T, k: Gen<K>) => L
  declare type TyCtor = new <T = M>(m: T, n: Gen<N>) => O
  interface I2 extends Gen<P> {}

tests/rollup-plugin-dts/generics/snapshot.d.ts

@@ -15,20 +15,20 @@ interface M {}
 interface N {}
 interface O {}
 interface P {}
-declare type Gen<T$1> = T$1;
-interface I1<T$1 = A> {
-  a: T$1;
+declare type Gen<T> = T;
+interface I1<T = A> {
+  a: T;
   b: Gen<B>;
 }
-declare type Ty<T$1 = C> = {
-  c: T$1;
+declare type Ty<T = C> = {
+  c: T;
   d: Gen<D>;
 };
-declare class Cl<T$1 = E> {
-  e: T$1;
+declare class Cl<T = E> {
+  e: T;
   f: Gen<F>;
 }
-declare function fn<T$1 = G>(g: T$1, h: Gen<H>): void;
+declare function fn<T = G>(g: T, h: Gen<H>): void;
 declare type TyFn = <T = J>(j: T, k: Gen<K>) => L;
 declare type TyCtor = new <T = M>(m: T, n: Gen<N>) => O;
 interface I2 extends Gen<P> {}