TypeScript泛型、枚举与继承场景下类型推断不符合预期问题

你的问题核心在于父类Task的类型定义没有保留子类execute方法的具体类型信息，导致done方法只能基于父类声明的宽泛类型做推断，而非子类的精确实现。

具体来说：

• 父类Task中，execute的返回类型被声明为Promise<{[K in Status]: Result<K>}[Status]>，展开后是Promise<Result<Status.UNDEFINED> | Result<Status.SUCCESS> | Result<Status.FAIL>>，这里的Result<Status.SUCCESS>使用的是Result类的默认泛型参数（Data=unknown、Code=string|number）。
• 当子类TestTask实现execute时，虽然返回了更具体的Result<Status.SUCCESS, {}, number> | Result<Status.FAIL, string, string|number>，但父类done方法的类型推断是基于父类的execute声明，而非子类的实际实现。TypeScript不会自动将子类的类型信息“回溯”提升到父类方法中，这是类型系统的设计限制——父类方法必须在父类的上下文里确定类型，不能依赖子类的具体实现。

通过给Task类引入泛型，让它能捕获子类execute方法的返回类型，从而让done方法可以基于这个精确的联合类型做类型缩小：

enum Status {
  UNDEFINED = 0,
  SUCCESS = 1,
  FAIL = 2,
}

class Result<StatusT extends Status = Status, Data = unknown, Code = string | number> {
  constructor(
    public status?: StatusT,
    public data?: Data,
    public code?: Code,
  ) {}
}

// 新增泛型ExecuteResult，约束为包含status属性的类型
abstract class Task<ExecuteResult extends { status: Status }> {
  async done(...args: Parameters<this['execute']>) {
    while (true) {
      const result = await this.execute(...args);
      if (result.status === Status.SUCCESS) {
        // 此时TypeScript能精确推断出成功分支的类型
        return result;
      }
    }
  }

  abstract execute(...args: any[]): Promise<ExecuteResult>;
}

// 让TestTask继承时指定具体的ExecuteResult类型
class TestTask extends Task<
  Result<Status.SUCCESS, {}, number> | Result<Status.FAIL, string, string | number>
> {
  async execute () {
    if (Math.random() > 0.5) {
      return new Result(Status.SUCCESS, {}, 0);
    } else {
      return new Result(Status.FAIL, "error");
    }
  }
}

const test = new TestTask()
// 现在推断类型为：Promise<Result<Status.SUCCESS, {}, number>>
test.done();

如果不想手动指定泛型参数，也可以让TypeScript自动推导：

enum Status {
  UNDEFINED = 0,
  SUCCESS = 1,
  FAIL = 2,
}

class Result<StatusT extends Status = Status, Data = unknown, Code = string | number> {
  constructor(
    public status?: StatusT,
    public data?: Data,
    public code?: Code,
  ) {}
}

abstract class Task {
  async done(...args: Parameters<this['execute']>) {
    while (true) {
      const result = await this.execute(...args);
      if (result.status === Status.SUCCESS) {
        return result;
      }
    }
  }

  abstract execute(...args: any[]): Promise<{ status: Status }>;
}

// TypeScript会自动推导execute的返回类型
class TestTask extends Task {
  async execute () {
    if (Math.random() > 0.5) {
      return new Result(Status.SUCCESS, {}, 0);
    } else {
      return new Result(Status.FAIL, "error");
    }
  }
}

const test = new TestTask();
// 此时done的返回类型已正确推断为Promise<Result<Status.SUCCESS, {}, number>>
test.done();

这不是你代码结构的疏漏，而是TypeScript类型推断的上下文限制：父类方法的类型推断仅基于父类的类型声明，无法自动感知子类的具体实现细节。通过给父类添加泛型来捕获子类的返回类型，就能让done方法获得精确的类型推断结果。

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