InstanceType<T> fails when returning instance from constructor

[YitzhakAvm]

🔎 Search Terms

Using InstanceType<T> with a generic constructor type results in a type error where TypeScript rejects the return value of new Ctor() as not being compatible with InstanceType<T>, even when the constructor is the class itself and not a subclass.

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about InstanceType

⏯ Playground Link

https://www.typescriptlang.org/play/?#code/MYGwhgzhAEDKD2BbApgYXFaBvAUNaw8AdhAC4BOArsKfOQBQCU2AvjmzqQJ4AOycSNBgipiZKjTrQAvNjzQiyAO7QmALgEp0kCAG52+nADNKRGgEtiBcsjClkCLcIA88gCrRkAD3tEAJjCOQjqiJBTUtOQ4AHz0qJEabowaAJJhYGbIbrzIzm7Rcvg2pJTkRArK0PF0TLrQAPT10ACi5OR0iTnQAORB2lDd0OYwRPCk0DrmAOZEYABGIPy00Nx8PWlkGcBZOXnR3QB0qgBMAMzHx4wH7Dg4hGFD6Zky1rb2fcL0HzqMukA

💻 Code

class SomeClass {
  constructor() {}
}

type SomeClassConstructor = {
  new (): SomeClass;
};

function createSomeClass<
  T extends SomeClassConstructor
>(Ctor: T): InstanceType<T> {
  return new Ctor(); // Error: Type 'SomeClass' is not assignable to type 'InstanceType<T>'. (2322).
}

const instance = createSomeClass(SomeClass);

🙁 Actual behavior

When trying to return an instance of a class using a generic constructor type with InstanceType<T>, TypeScript produces the following error:

Type 'SomeClass' is not assignable to type 'InstanceType<T>'. (2322).

This happens even when the provided constructor T is the class itself (SomeClass), without involving any subclassing or other complex types.

I understand why TypeScript is complaining: the function body always creates a SomeClass instance, which might not match a derived class’s instance type. But conceptually, new Ctor() should produce an object of type Ctor itself—even if Ctor extends SomeClass. The compiler is effectively saying “SomeClass might not be assignable to a derived class,” but at runtime, we really do get the instance of that subclass.

🙂 Expected behavior

The TypeScript compiler should correctly recognize that:

return new Ctor();

is valid when the return type is InstanceType<T>, where T is a constructor function (new (): SomeClass). The returned value should match InstanceType<T> when the constructor type is used directly.

Additional information about the issue

No response

[RyanCavanaugh]

There's a trade-off here because if return type of new Ctor() is left as InstanceType<T> (a deferred operation) then you couldn't do this:

class SomeClass {
  constructor() {}
  method() { }
}

type SomeClassConstructor = {
  new (): SomeClass;
};

function createSomeClass<
  T extends SomeClassConstructor
>(Ctor: T): InstanceType<T> {
  const instance = new Ctor();
  instance.method();
}

So if you want to do this, you need to write the signature as

function createSomeClass<T>(Ctor: new() => T): T {
  return new Ctor();
}

which works as requested

[jcalz]

Duplicate #37705

search terms: instancetype generic in:title