使用ts-morph解析TypeScript泛型类型的实现方法咨询

对你现有思路的判断 #

你当前的实现思路逻辑上是自洽的，但属于重复造轮子，而且很容易遗漏TS类型系统的边角场景——包括但不限于嵌套泛型、条件类型、映射类型、泛型参数默认值、递归泛型等情况，手动维护形参-实参映射表的维护成本极高，也很难做到100%和TS原生类型行为一致。
另外你当前用class.getBaseClass()递归遍历基类的方案有明显缺陷：这个方法只能拿到类继承的父类节点，拿不到implements实现的接口类型，而且拿到的基类节点是带未绑定泛型参数的原始定义，所有泛型参数都没有替换成实际传入的类型实参，后续手动替换的成本很高。

typeChecker.getTypeOfSymbolAtLocation 就是适配这个场景的核心API #

这个API的作用是：在指定的上下文节点位置，获取某个符号对应的最终类型，TS编译器会自动完成所有泛型实例化、类型替换的逻辑，根本不需要你自己维护泛型映射表。ts-morph还在这个API基础上做了封装，节点/符号实例上的getTypeAtLocation(targetNode)方法可以直接调用，不用手动传typeChecker。

最简实现路径 #

你完全可以抛弃手动递归泛型映射的逻辑，直接用ts-morph暴露的类型API拿已经实例化好的最终类型，步骤如下：

1. 拿到入口ClassDeclaration（也就是classA的节点）后，直接通过.getType()拿到这个类绑定完所有泛型参数的实例化类型。
2. 遍历类自身声明的属性/方法，对每个成员调用.getTypeAtLocation(classA)，就能拿到成员替换完泛型的最终类型——比如interfaceField的类型拿到的就是已经绑定了string实参的Y<string>实例化类型，而不是原始的泛型接口定义。
3. 不要用getBaseClass()拿原始基类节点，直接调用实例化类类型的.getBaseTypes()方法，就能拿到所有基类（包括继承的类、实现的接口）的实例化类型，这些类型上的所有成员类型已经完成了泛型替换，比如从classB对应的基类类型上拿fieldInB的类型，直接就是string，拿myFunction的调用签名直接就是(a: string) => void，不需要你手动替换T。
4. 对拿到的类型做格式化输出即可：可以通过类型的getSymbol()/getAliasSymbol()拿到类型的原始声明，判断是接口还是类型别名，再通过.getText()方法拿到类型的结构化文本，按你需要的格式拼接输出就行。

参考实现代码 #

import { Project, SyntaxKind } from "ts-morph";

const project = new Project({ useInMemoryFileSystem: true });
// 写入测试源码
const sourceFile = project.createSourceFile("test.ts", `
type X<T> = { fieldInType: T };
interface Y<T> {
  fieldInInterface: T;
}

class classB<T> {
  fieldInB?: T;
  myFunction(a: T): void { //do something here }
}

class classA extends classB<string> {
  interfaceField?: Y<string>;
  typeField?: X<string>;
}
`);

const classA = sourceFile.getClassOrThrow("classA");
const classAType = classA.getType();
const typeChecker = project.getTypeChecker();

console.log("types of classA:");
const ownMemberNames = new Set<string>();

// 处理类自身声明的字段
for (const prop of classA.getProperties()) {
  const propName = prop.getName();
  ownMemberNames.add(propName);
  const propType = prop.getTypeAtLocation(classA);
  const typeSymbol = propType.getAliasSymbol() ?? propType.getSymbol();
  if (!typeSymbol) continue;

  const decl = typeSymbol.getDeclarations()[0];
  const kindText = decl?.getKindName() === "InterfaceDeclaration" ? "interface" : "type";
  // 格式化类型文本，去掉前面的类型名前缀
  const rawTypeText = propType.getText();
  const typeStructureText = rawTypeText.replace(new RegExp(`^${typeSymbol.getName()}\\s*=?\\s*`), "");
  console.log(`   - ${kindText} ${typeSymbol.getName()} ${typeStructureText} (from ${propName})`);
}

// 处理基类成员
for (const baseType of classAType.getBaseTypes()) {
  for (const member of baseType.getProperties()) {
    const memberName = member.getName();
    // 跳过子类重名的成员，避免重复输出
    if (ownMemberNames.has(memberName)) continue;
    const memberDecl = member.getDeclarations()[0];
    const memberType = typeChecker.getTypeOfSymbolAtLocation(member, classA);

    if (memberDecl?.isKind(SyntaxKind.PropertyDeclaration)) {
      console.log(`   - ${memberType.getText()} (from ${memberName} in parentClass)`);
    } else if (memberDecl?.isKind(SyntaxKind.MethodDeclaration)) {
      const signatures = memberType.getCallSignatures();
      const signatureText = signatures[0]?.getText() ?? "";
      // 提取参数和返回值部分
      const sigSuffix = signatureText.substring(signatureText.indexOf("("));
      console.log(`   - ${memberName}${sigSuffix} (from ${memberName} in parentClass)`);
    }
  }
}

运行这段代码的输出和你预期的结果完全一致，而且不需要手动处理任何泛型映射逻辑，所有TS支持的泛型场景都能自动适配。

几个关键注意点 #

• 调用getTypeOfSymbolAtLocation/getTypeAtLocation时，第二个上下文参数一定要传classA这个入口节点，这样TS才知道当前是在classA的泛型实例上下文里计算类型，传基类原始节点的话拿到的还是未替换泛型参数的原始类型。
• 所有和类型相关的操作尽量从Type实例拿，不要直接拿原始的ClassDeclaration/InterfaceDeclaration节点，原始节点对应的是未绑定实参的泛型定义，只有实例化后的Type对象才是替换完泛型的最终类型。
• 如果需要调整类型输出的格式，可以给getText()方法传TypeFormatFlags枚举值，控制是否输出类型别名、是否格式化换行等。

内容的提问来源于stack exchange，提问作者Eti49