In typescript, how does the 'this' type really infer its type?

In typescript, I would like to use the this keywork to type some properties of my class. However, I face a problem I can't solve.
What I would like to do is something like :

export class Animal{
/*some properties*/
}

export class Population{
    AnimalConstructor : typeof Animal = Animal;
    animal : InstanceType<this['AnimalConstructor']>;

    createAnimal(){
        this.animal = new this.AnimalConstructor();//Type 'Animal' is not assignable to type 'InstanceType<this["AnimalConstructor"]>'
    }
}

Doing that, I have the error : Type 'Animal' is not assignable to type 'InstanceType<this["AnimalConstructor"]>' on line 10.
However, this code works well:

export class Animal{
/*some properties*/
}

export class Population{
    AnimalConstructor : typeof Animal = Animal;
    animal : Animal;

    createAnimal(){
        this.animal = new this.AnimalConstructor();
    }

}

I can't understand why the last one work and the first one doesn't. This is probably due to the way the compiler infers the type of the this keyword. But I didn't find any docs able to explain that behaviour neither. The official document only says : 'a special type called this refers dynamically to the type of the current class.' - which doesn't explain why the example above doesn't work.

The polymorphic this type acts as an implicit generic type parameter which is constrained to the current class type, but is only specified as a type argument when you access a specific instance of the class or its subclass. (See microsoft/TypeScript#4910 for the implementing pull request that describes this as an implicit type parameter.) That means when you use the this type you get the benefits—and the drawbacks—of generics.

The InstanceType<T> utility type is implemented as a conditional type, as you can see from its definition:

> type InstanceType<T extends abstract new (...args: any) => any> =
> T extends abstract new (...args: any) => infer R ? R : any;

So, inside the body of the Population class definition, the type InstanceType<this['AnimalConstructor']> is a generic conditional type (a conditional type that depends on at least one as-yet-unspecified type parameter). And, unfortunately, the compiler cannot really reason about such types.

When evaluating the value new this.AnimalConstructor(), the compiler widens the apparent type of this to Animal, because you're accessing a specific property on a generic-typed value, and the compiler does this widening as an approximation to make things easier. (See this comment on microsoft/TypeScript#33181 for a source.) And so this.AnimalConstructor is seen as type typeof Animal and thus new this.AnimalConstructor() is seen as type Animal:

const ac = this.AnimalConstructor;
//const ac: typeof Animal
const a = new ac();
//const a: Animal;

But the compiler defers evaluation of generic conditional types like InstanceType<this["AnimalConstructor"]>, and therefore ends up treating such types as essentially opaque. If you try to assign a value to a variable of such a type, the compiler will almost certainly complain because it can't verify that the value is compatible with the type. As a human being you can examine the value is and understand the meaning behind the conditional type and say "yes this is fine", but the compiler mostly sees the type as a black box and it has no idea what might be compatible with it. (The closest thing to documentation for this issue is microsoft/TypeScript#33912).

So you get an error:

this.animal = a; // error!
// Type 'Animal' is not assignable to 
// type 'InstanceType<this["AnimalConstructor"]>' 😟

If you want to keep your types as they are, then probably the best way forward is just to accept that you're smarter than the compiler. Since you're sure that new this.AnimalConstructor() is clearly of type InstanceType<this["AnimalConstructor"]> no matter what this turns out to be in subclasses, then you can just assert that fact to the compiler to stop it from worrying about things it can't figure out:

createAnimal() {
  const ac = this.AnimalConstructor;    
  const a = new ac();
  this.animal = a as InstanceType<this['AnimalConstructor']>; // okay
}

or just

createAnimal() {
  this.animal = new this.AnimalConstructor() as typeof this.animal; // okay
}

That works and you can move on. It's not as type safe as it could be if the compiler were smarter, but it's the probably best you can do without refactoring... for example, to make Population explicitly generic in the instance type of AnimalConstructor so you can control when generics get widened and avoid conditional types altogether:

export class Population<T extends Animal> {
  constructor(public AnimalConstructor: new () => T) {
    this.animal = new AnimalConstructor(); // things should be initialized
  }
  animal: T

  createAnimal() {
    this.animal = new this.AnimalConstructor(); // okay
  }
}

Playground link to code