泛型类型推断时触发TS2589错误的原因解析

我正在开发一个包含带监听器组件的库，在推断泛型类型时遇到TS2589错误：Type instantiation is excessively deep and possibly infinite。我编写了简化测试用例复现该问题，但仅当按特定顺序传入事件时才会触发错误。

测试代码 #

type extractStoreType<ListType> = ListType extends TestA<infer StoreType> ? StoreType : never;
type extractRecordType<StoreType> = StoreType extends TestStore<infer RecordType> ? RecordType : never;
class TestStore<RecordType> {
    data: RecordType[] = []
}

interface ObservableEventMap<Type> {

}

class Observable {
    set listeners(listeners: Partial<ObservableEventMap<this>>) {
        // listeners applied here
    }
}

interface EventMapA<Type>  extends ObservableEventMap<Type> {
    event1:<Sender extends Type> (comp:Sender) => void;
}

interface TestA<StoreType> extends Observable{
    set listeners(listeners: Partial<EventMapA<this>>)
}

class TestA<StoreType> extends Observable {
    store?: StoreType
    constructor(readonly tagName: keyof HTMLElementTagNameMap = "div") {
        super();
    }

}


interface EventMapB<Type> extends EventMapA<Type> {
    event2:<Sender extends Type> (comp:Sender, store: extractStoreType<Type>, record: extractRecordType<extractStoreType<Type>>) => void;
}


interface TestB<StoreType> extends TestA <StoreType> {
    set listeners(listeners: Partial<EventMapB<this>>)
}

class TestB<StoreType> extends TestA <StoreType> {

    constructor() {
        super();
    }

    parent:TestB<StoreType>|undefined;
}


interface TestC<StoreType> extends TestA <StoreType> {
    set listeners(listeners: Partial<EventMapB<this>>)
}

class TestC<StoreType> extends TestB <StoreType> {

    constructor() {
        super();

        const b = new TestB();
        b.parent = this;
    }
}



interface TestRecord {
    id:number,
    name: string
}

const b1 = new TestB<TestStore<TestRecord>>();
b1.listeners = {
    event2: (comp, store, record) => {

    }
};

interface TestBConfig<StoreType>  {
    store: StoreType,
    listeners: Partial<EventMapB<TestB<StoreType>>>
}

const createB = <StoreType>(config:TestBConfig<StoreType>) => {
    const b =  new TestB();
    Object.assign(b, config);
    return b;
}

const b2 = createB({
    store: new TestStore<TestRecord>(),
    listeners: {
        // If I remove this listener or move this below event2 it works!
        event1: comp => {

        },
        // this listener gets the error: TS2589: Type instantiation is excessively deep and possibly infinite.
        event2: (comp, store, record) => {

        },

    }

})

核心现象 #

• 当createB的listeners属性中先定义event1再定义event2时，触发TS2589错误
• 移除event1或把event2移到event1之前，错误自动消失

原因解析 #

这个问题是TypeScript类型推断顺序与递归泛型依赖共同作用的结果：

1. 递归类型依赖链：EventMapB的event2通过extractStoreType<Type>反向推断TestB<StoreType>的泛型参数，形成了TestB<StoreType> → extractStoreType → StoreType → extractRecordType → TestStore<RecordType>的链式推断逻辑，存在潜在的递归解析可能。
2. 属性顺序影响推断流程：TypeScript处理对象字面量时，会按属性定义顺序依次进行类型验证。当先处理event1时，EventMapA<TestB<StoreType>>中的<Sender extends Type>约束会优先尝试绑定Type为TestB<StoreType>，但此时StoreType尚未通过store属性或event2的参数完成推断，导致TypeScript反复尝试递归解析StoreType与Type的关系，最终触发深层递归的防护限制。
3. 顺序调换后的推断优化：当先处理event2时，StoreType会通过store属性和event2的参数类型被快速确定为TestStore<TestRecord>，此时event1的泛型约束可以直接使用已明确的TestB<TestStore<TestRecord>>类型，避免了递归循环。

解决方案 #

• 调整事件定义/传入顺序：在EventMapB中将event2放在event1之前，或者在传入listeners时优先定义依赖泛型推断的事件
• 显式指定泛型参数：调用createB时显式传入泛型类型，跳过自动推断的循环：

  const b2 = createB<TestStore<TestRecord>>({...})
  

• 简化类型提取逻辑：修改EventMapB的event2定义，直接使用StoreType而非反向推断，消除递归依赖：

  interface EventMapB<Type, StoreType> extends EventMapA<Type> {
      event2:<Sender extends Type> (comp:Sender, store: StoreType, record: extractRecordType<StoreType>) => void;
  }
  // 对应调整TestB的接口和类定义
  

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