Can't extend intersection containing constructable type parameter

[canonic-epicure]

Lets say we have 2 mixins, like this:

type Constructable<T = {}> = new (...args : any[]) => T

export const Mixin1 = <T extends Constructable>(base : T) =>

class Mixin1 extends base {
    method1() {
    }
}

export const Mixin2 = <T extends Constructable>(base : T) =>

class Mixin2 extends base {
    method2 () {
    }
}

Now we want to declare a Mixin3 that already includes Mixin2:

• First of all this won't work

export const Mixin3 = <T extends Constructable>(base : T) =>

class Mixin3 extends Mixin2(base) { // !!! typecheck error here

    method3 () {
    }
}

but this form will work

export const Mixin3 = <T extends Constructable>(base : T) =>

class Mixin3 extends Mixin2<Constructable>(base) {
    method3 () {
    }
}

This is generally fine.

Now, we want to declare Mixin4 which includes Mixin3 and Mixin1:

export const Mixin4 = <T extends Constructable>(base : T) =>

class Mixin4 extends Mixin3(Mixin1(base)) {

    method4 () {
        this.method1() // !!! this method is not "recognized"

        this.method2() // !!! this method is recognized
    }
}

Note, that for Mixin4 the specification of the form Mixin2<Constructable> like we did for Mixin3 is not needed.

It seems the nested application of the Mixin1 in the declaration of Mixin4 was not "picked up". Any help is greatly appreciated.

=======================================================================
All the code from above in one snippet:

type Constructable<T = {}> = new (...args : any[]) => T

export const Mixin1 = <T extends Constructable>(base : T) =>

class Mixin1 extends base {
    method1() {
    }
}

export const Mixin2 = <T extends Constructable>(base : T) =>

class Mixin2 extends base {
    method2 () {
    }
}


export const Mixin3 = <T extends Constructable>(base : T) =>

class Mixin3 extends Mixin2<Constructable>(base) {
    method3 () {
    }
}


export const Mixin4 = <T extends Constructable>(base : T) =>

class Mixin4 extends Mixin3(Mixin1(base)) {
    method4 () {
        this.method1()

        this.method2()
    }
}

[canonic-epicure]

This form does not work either:

export const Mixin4 = <T extends Constructable>(base : T) => {

    class Temp extends Mixin1<Constructable>(base) {
        methodTemp () {
            this.method1() // typechecks fine
        }
    }

    return class Mixin4 extends Mixin3(Temp) {

        method4 () {
            this.method1() // !!! not found

            this.method2()
        }
    }
}

[canonic-epicure]

Huh, but changing the order of mixin applications fixes it:

export const Mixin4 = <T extends Constructable>(base : T) =>

//  class Mixin4 extends Mixin3(Mixin1(base)) { -- fails in this order
    class Mixin4 extends Mixin1(Mixin3(base)) { // -- works in this order
        method4 () {
            this.method1() // method found

            this.method2() // method found
        }
    }

Ehm, why does the order of mixins application matter in this case? Definitely feels like some quirk in the typechecker.

[ghost]

The bug is that we don't consider an intersection containing a constructable type parameter to be constructable:

type Ctr = new (...args : any[]) => any;
const Mixin1 = <T extends Ctr>(Sup: T) => class extends Sup {};
const Mixin2 = <T extends Ctr>(Sup: T) => class extends Mixin1(Sup) {};

[canonic-epicure]

Cool, hopefully the fix will make it to 2.8.0 final..

[canonic-epicure]

Any workarounds possible to use right now?

[ghost]

It doesn't look like there's a good workaround, besides avoiding mixins extending mixins and having the final ("leaf") class declarations directly write all the mixins they want to include.

[canonic-epicure]

I see. In our project we primarily use mixins for functionality extension (a-la haskell typeclasses). There's not many "leaf" class declarations actually - those are in the external project, that consumes required parts of the functionality from ours.

[canonic-epicure]

Some thoughts:

The test case you posted:

type Ctr = new (...args : any[]) => any;
const Mixin1 = <T extends Ctr>(Sup1: T) => class extends Sup1 {};
const Mixin2 = <T extends Ctr>(Sup2: T) => class extends Mixin1(Sup2) {};

Can be fixed with explicit type for the application of generic function Mixin1<T>:

type Ctr = new (...args : any[]) => any;
const Mixin1 = <T1 extends Ctr>(Sup1: T1) => class extends Sup1 {};
const Mixin2 = <T2 extends Ctr>(Sup2: T2) => class extends Mixin1<Ctr>(Sup2) {};

Shouldn't that be a job of type inference facilities? Since Sup2 : T2 and T2 extends Ctr type checker has enough information to infer, that T in Mixin1<T> is of the type T2 extends Ctr, which should give required type annotation.

So the bug is probably in the code for type inference for generic functions.

[ghost]

Ctr isn't the right type argument though, T2 is -- you don't want to extend just any constructor, you want the particular type that was passed in. If you use Mixin1<Ctr> you can't call a method defined by Sup2, because the type information is lost.

[canonic-epicure]

Right