Support mixins for abstract classes

Search Terms

Related to #32122, but not the same. abstract mixins classes

Suggestion

Right now we can’t to extending abstract classes with mixins. So, it would be nice to create a solution for this case.

Use Cases

abstract class Test {
}

type Constructor = new (...args: any[]) => any;

function MyAwesomeMixin<T extends Constructor>(Constructor: Constructor) {
  abstract class MyAwesomeMixin extends Constructor {
  }
  return MyAwesomeMixin;
}

class A extends MyAwesomeMixin(Test) {
  /* Argument of type 'typeof Test' is not assignable to parameter of type 'Constructor'.
  Cannot assign an abstract constructor type to a non-abstract constructor type.(2345) */
}

Okay, try to create abstract constructor type:

type Constructor = abstract new (...args: any[]) => any;
/* Syntax error */

Hmm,…

Examples

Here is two way to create solution for this problem:

1. (simple) Allow create abstract constructor types

type Constructor = (new (...args: any[]) => any) | (abstract new (...args: any[]) => any);

1. (complex, but beautiful) Add new syntax to define mixins, and initially add support to extending abstract classes, like this:

abstract class Test {
   abstract mainMethod(): void;
}

mixin MyAwesomeMixin {
   public someMethod(): void {
      console.log('hello');
   }
}

class A extends MyAwesomeMixin(Test) {
   public mainMethod(): void {
      this.someMethod();
   }
}

// AND

abstract mixin MyAwesomeAbstractMixin {
    abstract someMethod(): void;
}

class B extends MyAwesomeAbstractMixin(Test) {
   public mainMethod(): void {
      this.someMethod();
   }
}

// Also this can add support to extending mixins without Mixin(Mixin2(Mixin3(Class)))

mixin MyAwesomeExtendedMixin extends MyAwesomeAbstractMixin {
   public someMethod(): void {
      ...
   }
}

Checklist

My suggestion meets these guidelines:

• This wouldn’t be a breaking change in existing TypeScript/JavaScript code
• This wouldn’t change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn’t a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript’s Design Goals.

[dragomirtitian]

@fatcerberus you can’t new but you can inherit and call it in the constructor of the derived class.

Currently if the base class signature returns an abstract class (ie. You are extending something of type new (...args :any) => AbstractClass) , it is assumed that this represents an abstract class and this forces you to implement the abstract methods, when in reality new (...args :any) => AbstractClass could also represent the constructor of any derived class.

abstract class Foo {
  abstract m(): void;
}

class Bar extends Foo {
  m() { }
}

let base: new () => Foo = Bar 

class MyClass extends base { // error, but not really 

}

Playground Link

[dragomirtitian]

Also realetd https://github.com/microsoft/TypeScript/issues/29653, IMO. I came to the same conclusion, that there is a need for a way to define a constructor that is explicitly abstract.