泛型联合类型触发交叉类型的TypeScript疑难类型问题

复现代码 #

export interface A {
  a: any;
}
export interface B {
  b: any;
}
export interface MyClasses {
  a: MyClass<A>;
  b: MyClass<B>;
}

export interface C {
  c: any;
}
export declare class MyClass<T = { [prop: string]: any }> {
  myMethod(data: T | C): T;
}

export type MyClassesKeys = keyof MyClasses;
export type MyClassInferGenericType<T> = T extends MyClass<infer G> ? G : T;

export class MyService {
  private myClasses: MyClasses = {
    a: new MyClass<A>(),
    b: new MyClass<B>()
  };

  public getMyClass<T extends MyClassesKeys>(keyName: T): MyClasses[T] {
    return this.myClasses[keyName];
  }

  public callerMethod<T extends MyClassesKeys, U extends MyClassInferGenericType<MyClasses[T]>>(key: T, myData: U) {
    const myClassInstance = this.getMyClass(key);
    myClassInstance.myMethod(myData); // 此处触发类型错误
  }
}

编译错误信息 #

Argument of type 'A | B' is not assignable to parameter of type '(A | C) & (B | C)'.
Type 'A' is not assignable to type '(A | C) & (B | C)'.
Type 'A' is not assignable to type 'A & C'.
Property 'c' is missing in type 'A' but required in type 'C'.

错误原因分析 #

这个问题的核心是TypeScript对联合类型函数的逆变处理规则：

1. 当myClassInstance的类型为MyClass<A> | MyClass<B>（因为泛型T是"a"|"b"的联合约束）时，调用它的myMethod方法，TypeScript会遵循函数逆变逻辑——联合类型的函数，其参数类型必须同时满足所有分支的参数要求，因此会将各分支的参数类型取交叉类型。
2. 具体来说，MyClass<A>.myMethod的参数是A | C，MyClass<B>.myMethod的参数是B | C，交叉后得到(A | C) & (B | C)，简化后等价于(A & B) | C。由于A和B无共同属性，实际要求参数必须是C类型。
3. 而你定义的U extends MyClassInferGenericType<MyClasses[T]>，会触发分布式条件类型，将MyClasses[T]拆解为MyClass<A> | MyClass<B>，最终U被推断为A | B，自然无法匹配myMethod要求的交叉类型参数。

解决方案 #

方案1：使用函数重载明确类型关联 #

通过为callerMethod添加重载，让TypeScript为每个具体的key匹配对应的参数类型，彻底避免联合类型的逆变问题：

export class MyService {
  private myClasses: MyClasses = {
    a: new MyClass<A>(),
    b: new MyClass<B>()
  };

  public getMyClass<T extends MyClassesKeys>(keyName: T): MyClasses[T] {
    return this.myClasses[keyName];
  }

  // 函数重载定义
  public callerMethod(key: "a", myData: A): void;
  public callerMethod(key: "b", myData: B): void;
  // 通用实现逻辑
  public callerMethod<T extends MyClassesKeys>(key: T, myData: MyClassInferGenericType<MyClasses[T]>) {
    const myClassInstance = this.getMyClass(key);
    myClassInstance.myMethod(myData); // 类型推断正常
  }
}

方案2：类型断言缩小范围 #

如果不想写重载，可以通过类型断言明确实例与参数的类型关联，快速解决报错：

public callerMethod<T extends MyClassesKeys>(key: T, myData: MyClassInferGenericType<MyClasses[T]>) {
  const myClassInstance = this.getMyClass(key);
  (myClassInstance as MyClass<MyClassInferGenericType<MyClasses[T]>>).myMethod(myData);
}

注意：这种方式需要确保传入的myData确实与实例的泛型类型匹配，避免类型不安全的情况。

方案3：重构泛型约束（复杂场景适用） #

通过反向映射key与实例类型的关系，让TypeScript更精确地推断类型，适合更复杂的类结构：

public callerMethod<T extends MyClasses[keyof MyClasses]>(
  key: { [K in MyClassesKeys]: MyClasses[K] extends T ? K : never }[MyClassesKeys],
  myData: T extends MyClass<infer G> ? G : never
) {
  const myClassInstance = this.getMyClass(key as MyClassesKeys) as T;
  myClassInstance.myMethod(myData);
}

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