Class mixins shouldn't require a specific signature of constructors

TypeScript Version: 2.2.0-dev.20170209

Code

Requiring mixins to have a constructor signature of constructor(...args: any[]) causes a few problems:

1. Node v4, which is an active LTS, doesn't support rest and spread syntax. We avoid it and can run our output on Node v4 even when targeting ES6. The mixin constructor requirements prevent this.

2. It's common to have mixins that want to provide a specific constructor. These will usually be applied last to create a concrete class. This is impossible now, so you have to create a new concrete class with only a constructor to give it the correct signature.

3. For a mixin that does have constructor argument requirements, it's very cumbersome to extract arguments out of ...args.

Here's an approximation of a case I hit. I have two classes that that share a base class:

class Base {
  foo: string[];
}

class A extends Base {}

class B extends Base {}

Later, I want to add some functionality to via mixins to create two new classes:

type Constructor<T extends object> = new (...args: any[]) => T;
interface Magic {}
const Magic = <T extends Constructor<Base>>(superclass: T): Constructor<Magic>& T =>
  class extends superclass implements Magic {
    constructor(foo: string[]) {
      super();
      this.foo = foo;
    }
  };

const MagicA = Magic(A);
const MagicB = Magic(A);

And I want MagicA and MagicA to have a constructor that takes a single argument. I know the code will work because I know the constructors of A and B, but the type checker is unhappy.

First, the Constructor type is wrong in this case because I know the signature I want. I'd actually like to write:

type BaseConstructor = new() => Base;
type MagicConstructor = new(foo: string[]) => Magic;
interface Magic {}

const Magic = <T extends BaseConstructor>(superclass: T): MagicConstructor & T =>
  class extends superclass implements Magic {
    constructor(foo: string[]) {
      super();
      this.foo = foo;
    }
  };
const MagicA = Magic(A);
const MagicB = Magic(A);

Expected behavior:

This works

Actual behavior:

Error: "Type 'T' is not a constructor function type." on the extends clause.

Start by reproducing the TypeScript 2.2 constructor-mixin example in the issue, focusing on the "T is not a constructor function type" error at the extends clause. Investigate how the type checker validates mixin constructors; done means the shown mixin can retain its specific constructor signature without requiring constructor(...args: any[]).