TypeScript泛型继承问题：类型无法分配

问题背景 #

我正在为多个子类创建泛型抽象父类Parent<T>，希望在父类中定义抽象方法add，该方法接受匹配的子类实例并返回该子类。

父类代码：

abstract class Parent<T> {
    constructor(public readonly val: T) { }
    public abstract add<C extends Parent<T>>(other: C): C;
}

子类Child继承自Parent<string>，实现add方法时接受Child实例并返回Child：

class Child extends Parent<string> {
    public add(other: Child): Child {
        return new Child(this.val + other.val);
    }
}

此时出现类型错误：

Property 'add' in type 'Child' is not assignable to the same property in base type 'Parent'.
Type '(other: Child) => Child' is not assignable to type '<C extends Parent>(other: C) => C'.
Type 'Child' is not assignable to type 'C'.
'C' could be instantiated with an arbitrary type which could be unrelated to 'Child'.ts(2416)

尝试在子类add方法中添加泛型参数<Child>：

class Child extends Parent<string> {
    public add<Child>(other: Child): Child {
        return new Child(this.val + other.val);
    }
}

但return语句出现错误：

Type 'Child' is not assignable to type 'Child'. Two different types with this name exist, but they are unrelated.
'Child' could be instantiated with an arbitrary type which could be unrelated to 'Child'.ts(2719)

暂移除父类抽象方法可临时解决，但想得到永久修复方案，请问错误原因是什么？有哪些解决选项？

错误原因 #

第一个错误的根源 #

父类的add方法定义了泛型参数C，它要求任何继承自Parent<T>的子类都能作为参数传入，并且返回对应类型的实例。但Child类的add方法只接受Child类型，这违反了父类的契约——按照父类定义，调用add时可以传入Parent<string>的任意子类（比如另一个AnotherChild extends Parent<string>），但Child.add做不到这一点，因此TypeScript抛出类型不兼容错误。

第二个错误的根源 #

在子类add方法中添加<Child>泛型参数时，这个Child是一个泛型占位符，和你的Child类重名了。TypeScript会优先把它当成泛型参数，而非你定义的类，所以return new Child(...)里的Child是类，而返回值要求的是泛型参数Child，两者完全无关，因此报错。

解决选项 #

选项1：父类泛型绑定子类自身类型 #

修改父类的泛型定义，新增一个参数表示子类自身的类型，通过递归泛型明确父类和子类的绑定关系：

abstract class Parent<T, C extends Parent<T, C>> {
    constructor(public readonly val: T) { }
    public abstract add(other: C): C;
}

class Child extends Parent<string, Child> {
    public add(other: Child): Child {
        return new Child(this.val + other.val);
    }
}

这种方式能确保add方法只能接受当前子类的实例并返回该子类，严格符合需求。

选项2：利用this类型约束 #

TypeScript的this类型会自动指代当前子类的类型，不需要额外泛型参数：

abstract class Parent<T> {
    constructor(public readonly val: T) { }
    public abstract add(other: this): this;
}

class Child extends Parent<string> {
    public add(other: Child): Child {
        return new Child(this.val + other.val);
    }
}

this类型在子类中会被自动推断为Child，既满足父类的抽象方法约束，又能让子类的add方法正确限制参数和返回值类型，是最简洁的方案。

选项3：放宽父类方法的泛型约束（不推荐） #

如果不需要严格保留子类类型，可以将父类的add方法返回值改为Parent<T>，但这样会丢失子类的具体类型信息：

abstract class Parent<T> {
    constructor(public readonly val: T) { }
    public abstract add(other: Parent<T>): Parent<T>;
}

class Child extends Parent<string> {
    public add(other: Child): Child {
        return new Child(this.val + other.val);
    }
}

这种方式虽然能通过编译，但调用add后会丢失Child的独有方法和属性，仅适用于不需要子类类型特性的场景。

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