Abstract Constructor is breaking on Class decorators

[arciisine]

Bug Report

🔎 Search Terms

abstract constructor decorator

🕗 Version & Regression Information

4.2.0-dev.20210113

• This is a bug tied to newly released functionality

⏯ Playground Link

Playground link with relevant code

💻 Code

type Class<T = any> = abstract new (...args: any[]) => T;

function Injectable() {
  return function <T>(target: Class<T>) { 
    return target;
  }
}


@Injectable()
class TestInjectable {

}

🙁 Actual behavior

Actual behavior is that TestInjectable is failing decoration with the error:

Unable to resolve signature of class decorator when called as an expression.
  Type 'Class<TestInjectable>' is not assignable to type 'typeof TestInjectable'.
    Cannot assign an abstract constructor type to a non-abstract constructor type.(1238)

🙂 Expected behavior

Given the blog post comment of:
Adding the abstract modifier to a construct signature signals that you can pass in abstract constructors. It doesn’t stop you from passing in other classes/constructor functions that are “concrete” – it really just signals that there’s no intent to run the constructor directly, so it’s safe to pass in either class type.

I'm expecting the Class alias to properly support both abstract and concrete classes, but that doesn't seem to be the case.

[arciisine]

As a follow up, I'm also not able to get (new (...args: any[]) => T) | (abstract new (...args: any[]) => T) to work in the scenario above. It seems the abstract behavior is overriding everything else.

[RyanCavanaugh]

@rbuckton what's the desired behavior here?

[rbuckton]

The issue is that target isn't generic with respect to the entire construct signature, but rather is only generic with respect to the instance type. The decorator type has the type <T>(target: Class<T>) => Class<T>. If we expand out the type alias, what you actually have is this:

<T>(target: abstract new (...args: any[]) => T) => abstract new (...args: any[]) => T

What this signature implies is that you input at least an abstract class and always receive an abstract class in return. When we apply class decorators, we ensure that the return type is always assignable to the original class (to try to avoid decorators that could easily confuse our type system). Based on this signature, we're trying to assign an abstract new (...args: any[]) => TestInjectable to a typeof TestInjectable, which is an error because typeof TestInjectable is not abstract.

What you actually want is to make target generic and use Class<{}> as the base constraint so that we infer typeof TestInjectable for the type parameter:

type Class<T = any> = abstract new (...args: any[]) => T;

function Injectable() {
  return function <TClass extends Class>(target: TClass): TClass { 
    return target;
  }
}

@Injectable()
class TestInjectable {
}

@Injectable()
abstract class TestInjectableAbstract {
}

Playground link.

This is not a bug but is the intended and correct behavior.

[rbuckton]

To clarify the behavior, here's a trimmed down example of what's happening above:

declare function Injectable<T>(target: abstract new (...args: any[]) => T): abstract new (...args: any[]) => T;

class TestInjectable {}

// error
const TestInjectable2: typeof TestInjectable = Injectable(TestInjectable);

Playground link

We report the same error here we do for the example, because abstract new (...args: any[]) => TestInjectable isn't assignable to typeof TestInjectable.

And the same change I recommended makes the error go away:

declare function Injectable<TClass extends abstract new (...args: any[]) => any>(target: TClass): TClass;

class TestInjectable {}

const TestInjectable2: typeof TestInjectable = Injectable(TestInjectable);

Playground link

Which shows that this behaves just like our other assignability relationships.

[arciisine]

@rbuckton Thanks for the explanation.

[weagle08]

In 4.1.x this would work:

abstract class MyAbstract<T extends {} = any> {

}

type Foo<T extends MyAbstract> = typeof MyAbstract & { new(): T };

interface IMyImpl {

}

class MyImpl extends MyAbstract<IMyImpl> {

}

export interface Bar extends Foo<MyImpl> {

}

However in 4.2.x it gives an error:

Type 'Bar' is not assignable to type 'new () => MyImpl'. Cannot assign an abstract constructor type to a non-abstract constructor type.

What is the reason that in 4.2.x I can no longer have an interface that extends and abstract class? I know that sounds odd to extend an abstract class with an interface, but I have some code this was working in previously, but now in does not. Just want to know the change that caused it.