Generic `{ new(...args: any[]): T }` parameter doesn't work for abstract classes

[jklmli]

Following up on #5236 (comment), the proposed solution doesn't cover all bases now that abstract classes are supported.

abstract class A {}

class B extends A {}

function isType<T>(value: any, key: { new(...args: any[]): T }): boolean {
  return value instanceof key;
}

console.log(isType((new B), A))

Error TS2345: Argument of type 'typeof A' is not assignable to parameter of type 'new (...args: any[]) => A'. Cannot assign an abstract constructor type to a non-abstract constructor type.

On a related note, interfaces and abstract classes feel a bit kludgey since I can't seem to verify that an arbitrary object actually conforms to them. I can require them as parameter types and use user-defined type guards, but there's no generic equivalent to instanceof.

[jklmli]

@RyanCavanaugh

[jesseschalken]

As a guess, the error seems to suggest there is a way to denote an "abstract constructor type" (eg typeof A), which would solve your problem. Maybe abstract new (...args:any[]):T or something?

[jklmli]

I interpreted the error to mean that typeof A is an abstract constructor type. Normally (as a non-abstract type), this is fine since typeof A is a subset of new (...args: any[]) => A. But it looks like abstract types don't have an equivalent superset?

[mhegazy]

the error is that A is not constructable. your function isType says it expects things that it can construct, though in the implementation it never constructs anything. so you can not pass an abstract class to a function that may use it to construct objects. consider:

function makeInstance(constructor: new()=> T): T {
    return new constructor();
}

makeInstace(B); // OK
makeInstace(A); // Error as you would expect

i think we need a way to enable the scenario, though this needs a propsal

[DanielRosenwasser]

though in the implementation it never constructs anything

We've discussed this issue elsewhere, and this is not the only thing a construct signature is used for. One specific scenario is checking super calls as well. Any solution to this problem should enable the user to extend a given value with a subclass as well.

[jklmli]

Right, I got burned by that a few times when learning TypeScript - this is why I only use the { new(...args: any[]): T } syntax now. I haven't found any real uses for typeof T, outside of strict type bounds (which I haven't encountered).

[sccolbert]

I also just ran into this when trying to find a way to use abstract classes in the context of a DI container. Something like:

registerType<T>(base: AbstractClass<T>, impl: ConcreteClass<T>);

interface ConcreteClass<T> {
  new (...args: any[]): T;
}

interface AbstractClass<T> {
  // ???
}

[mweststrate]

+1 for this issue, I have a real-life scenario as well where I have a function which accepts constructors but only for reflection purposes; e.g. it does instanceof checks but nothing else with the constructor, just like the above examply:

function isType<T>(value: any, key: { new(...args: any[]): T }): boolean {
  return value instanceof key;
}

Currently I have to cast the type to any when passing it to isType. Being able to mark the constructor as (possibly) abstract in the type would solve this issue.

[nomaed]

^^ Same, I have a real life scenario; an Angular component factory that accepts a controller constructor as an argument, and this constructor is always a child of an abstract base.

@thorn0 suggested a very neat solution which works very well in my case, but I do consider the inability to specify an abstract with this syntax, while it compiles cleanly with interface syntax.

DefinitelyTyped/DefinitelyTyped#11541 (comment)

[karlthepagan]

Passing a constructor reference is the only way I know to materialize a parameterized type in a function signature per issue #4890. This restriction on passing a constructor reference constrains useful type checking.

[unional]

I also encounter this for a DI:

container.registerInstance(AbstractClass, someInstance)
const instance = container.get(AbstractClass)
instance === someInstance // true

// where
class Container {
  get<T>(key: new (...args: any[]) => T): T
}