TypeScript：多态 this 并推断通用 function 参数

Question

I would like to infer the type of the current class from this keyword passed to a function. For some reason when i'm passing this as a parameter to the function, TypeScript infers that type parameter T is this instead of the current class type.

Below there is an example of what i'm trying to do. I want both B and C class to have a field with a type number , but the field in C class is GenericArguments<this> when passing this as argument. When type is specified manually everything works fine ( B class example), but inferring the type from this does not give the results i want.

type GenericArgument<T> = T extends A<infer R> ? R : never;

function test<T>(obj: T): GenericArgument<T>  {
    // do operations
    // return ...;
}

class A<T> {
    something: T;
}

class B extends A<number> {
    field = test<B>(this); // <-- field has a type: number
}

class C extends A<number> {
    field = test(this); // <-- field has a type: GenericArgument<this> 
}

Do i need some additional keyword to force TypeScript to use current class type and not polymotphic this ? Or is there some other way to achieve this?

Answer 1

this is not of the same type as the class. It has a special type, the polymorphic this type. The polymorphic this type represents the type of the current class and will be seen from the outside as whatever the type of the current class is. So for example this works:

class A {
    getThis() { return this; }
    getA(): A { return this; }
}

class B extends A {
    method() { }
}
var b = new B();
b.getThis().method(); // ok since polymorphic this is seen as B from the outside 
b.getA().method(); // err since we are accessing on A

Playground Link

From inside the class, this has the unfortunate side effect that the this type has to behave as an unresolved type parameter (one that extends the current class). This is due to the fact that the final type of this is indeed not yet fully known.

Since the polymorphic this type is behaves like an unresolved type parameter, typescript is very limited in what it will do with it in conditional types. Typescript does not generally resolve conditional types that still contain unresolved type parameters.

From outside the class, the type of field will be resolved correctly, since polymorphic this is resolved to whatever type we access field on. We might even have some surprises if the type of something is narrowed by a derived class (which is possible):

class C extends A<number> {
    field = test(this); // <-- field has a type: GenericArgument<this> 
}
new C().field // is number
class D extends C {
    something!: 1
}
new D().field // is of type number literal type 1

Playground Link

The workaround of being explicit with the field number is probably the simplest one.