=== tests/cases/conformance/classes/mixinClassesMembers.ts ===
declare class C1 {
>C1 : C1

    public a: number;
>a : number

    protected b: number;
>b : number

    private c: number;
>c : number

    constructor(s: string);
>s : string

    constructor(n: number);
>n : number
}

declare class M1 {
>M1 : M1

    constructor(...args: any[]);
>args : any[]

    p: number;
>p : number

    static p: number;
>p : number
}

declare class M2 {
>M2 : M2

    constructor(...args: any[]);
>args : any[]

    f(): number;
>f : () => number

    static f(): number;
>f : () => number
}

declare const Mixed1: typeof M1 & typeof C1;
>Mixed1 : typeof M1 & typeof C1
>M1 : typeof M1
>C1 : typeof C1

declare const Mixed2: typeof C1 & typeof M1;
>Mixed2 : typeof C1 & typeof M1
>C1 : typeof C1
>M1 : typeof M1

declare const Mixed3: typeof M2 & typeof M1 & typeof C1;
>Mixed3 : typeof M2 & typeof M1 & typeof C1
>M2 : typeof M2
>M1 : typeof M1
>C1 : typeof C1

declare const Mixed4: typeof C1 & typeof M1 & typeof M2;
>Mixed4 : typeof C1 & typeof M1 & typeof M2
>C1 : typeof C1
>M1 : typeof M1
>M2 : typeof M2

declare const Mixed5: typeof M1 & typeof M2;
>Mixed5 : typeof M1 & typeof M2
>M1 : typeof M1
>M2 : typeof M2

function f1() {
>f1 : () => void

    let x1 = new Mixed1("hello");
>x1 : M1 & C1
>new Mixed1("hello") : M1 & C1
>Mixed1 : typeof M1 & typeof C1
>"hello" : "hello"

    let x2 = new Mixed1(42);
>x2 : M1 & C1
>new Mixed1(42) : M1 & C1
>Mixed1 : typeof M1 & typeof C1
>42 : 42

    let x3 = new Mixed2("hello");
>x3 : C1 & M1
>new Mixed2("hello") : C1 & M1
>Mixed2 : typeof C1 & typeof M1
>"hello" : "hello"

    let x4 = new Mixed2(42);
>x4 : C1 & M1
>new Mixed2(42) : C1 & M1
>Mixed2 : typeof C1 & typeof M1
>42 : 42

    let x5 = new Mixed3("hello");
>x5 : M2 & M1 & C1
>new Mixed3("hello") : M2 & M1 & C1
>Mixed3 : typeof M2 & typeof M1 & typeof C1
>"hello" : "hello"

    let x6 = new Mixed3(42);
>x6 : M2 & M1 & C1
>new Mixed3(42) : M2 & M1 & C1
>Mixed3 : typeof M2 & typeof M1 & typeof C1
>42 : 42

    let x7 = new Mixed4("hello");
>x7 : C1 & M1 & M2
>new Mixed4("hello") : C1 & M1 & M2
>Mixed4 : typeof C1 & typeof M1 & typeof M2
>"hello" : "hello"

    let x8 = new Mixed4(42);
>x8 : C1 & M1 & M2
>new Mixed4(42) : C1 & M1 & M2
>Mixed4 : typeof C1 & typeof M1 & typeof M2
>42 : 42

    let x9 = new Mixed5();
>x9 : M1 & M2
>new Mixed5() : M1 & M2
>Mixed5 : typeof M1 & typeof M2
}

function f2() {
>f2 : () => void

    let x = new Mixed1("hello");
>x : M1 & C1
>new Mixed1("hello") : M1 & C1
>Mixed1 : typeof M1 & typeof C1
>"hello" : "hello"

    x.a;
>x.a : number
>x : M1 & C1
>a : number

    x.p;
>x.p : number
>x : M1 & C1
>p : number

    Mixed1.p;
>Mixed1.p : number
>Mixed1 : typeof M1 & typeof C1
>p : number
}

function f3() {
>f3 : () => void

    let x = new Mixed2("hello");
>x : C1 & M1
>new Mixed2("hello") : C1 & M1
>Mixed2 : typeof C1 & typeof M1
>"hello" : "hello"

    x.a;
>x.a : number
>x : C1 & M1
>a : number

    x.p;
>x.p : number
>x : C1 & M1
>p : number

    Mixed2.p;
>Mixed2.p : number
>Mixed2 : typeof C1 & typeof M1
>p : number
}

function f4() {
>f4 : () => void

    let x = new Mixed3("hello");
>x : M2 & M1 & C1
>new Mixed3("hello") : M2 & M1 & C1
>Mixed3 : typeof M2 & typeof M1 & typeof C1
>"hello" : "hello"

    x.a;
>x.a : number
>x : M2 & M1 & C1
>a : number

    x.p;
>x.p : number
>x : M2 & M1 & C1
>p : number

    x.f();
>x.f() : number
>x.f : () => number
>x : M2 & M1 & C1
>f : () => number

    Mixed3.p;
>Mixed3.p : number
>Mixed3 : typeof M2 & typeof M1 & typeof C1
>p : number

    Mixed3.f();
>Mixed3.f() : number
>Mixed3.f : () => number
>Mixed3 : typeof M2 & typeof M1 & typeof C1
>f : () => number
}

function f5() {
>f5 : () => void

    let x = new Mixed4("hello");
>x : C1 & M1 & M2
>new Mixed4("hello") : C1 & M1 & M2
>Mixed4 : typeof C1 & typeof M1 & typeof M2
>"hello" : "hello"

    x.a;
>x.a : number
>x : C1 & M1 & M2
>a : number

    x.p;
>x.p : number
>x : C1 & M1 & M2
>p : number

    x.f();
>x.f() : number
>x.f : () => number
>x : C1 & M1 & M2
>f : () => number

    Mixed4.p;
>Mixed4.p : number
>Mixed4 : typeof C1 & typeof M1 & typeof M2
>p : number

    Mixed4.f();
>Mixed4.f() : number
>Mixed4.f : () => number
>Mixed4 : typeof C1 & typeof M1 & typeof M2
>f : () => number
}

function f6() {
>f6 : () => void

    let x = new Mixed5();
>x : M1 & M2
>new Mixed5() : M1 & M2
>Mixed5 : typeof M1 & typeof M2

    x.p;
>x.p : number
>x : M1 & M2
>p : number

    x.f();
>x.f() : number
>x.f : () => number
>x : M1 & M2
>f : () => number

    Mixed5.p;
>Mixed5.p : number
>Mixed5 : typeof M1 & typeof M2
>p : number

    Mixed5.f();
>Mixed5.f() : number
>Mixed5.f : () => number
>Mixed5 : typeof M1 & typeof M2
>f : () => number
}

class C2 extends Mixed1 {
>C2 : C2
>Mixed1 : M1 & C1

    constructor() {
        super("hello");
>super("hello") : void
>super : typeof M1 & typeof C1
>"hello" : "hello"

        this.a;
>this.a : number
>this : this
>a : number

        this.b;
>this.b : number
>this : this
>b : number

        this.p;
>this.p : number
>this : this
>p : number
    }
}

class C3 extends Mixed3 {
>C3 : C3
>Mixed3 : M2 & M1 & C1

    constructor() {
        super(42);
>super(42) : void
>super : typeof M2 & typeof M1 & typeof C1
>42 : 42

        this.a;
>this.a : number
>this : this
>a : number

        this.b;
>this.b : number
>this : this
>b : number

        this.p;
>this.p : number
>this : this
>p : number

        this.f();
>this.f() : number
>this.f : () => number
>this : this
>f : () => number
    }
    f() { return super.f(); }
>f : () => number
>super.f() : number
>super.f : () => number
>super : M2 & M1 & C1
>f : () => number
}