=== tests/cases/conformance/expressions/typeGuards/typeGuardFunctionOfFormThis.ts ===
class RoyalGuard {
>RoyalGuard : RoyalGuard

    isLeader(): this is LeadGuard {
>isLeader : () => this is LeadGuard

        return this instanceof LeadGuard;
>this instanceof LeadGuard : boolean
>this : this
>LeadGuard : typeof LeadGuard
    }
    isFollower(): this is FollowerGuard {
>isFollower : () => this is FollowerGuard

        return this instanceof FollowerGuard;
>this instanceof FollowerGuard : boolean
>this : this
>FollowerGuard : typeof FollowerGuard
    }
}

class LeadGuard extends RoyalGuard {
>LeadGuard : LeadGuard
>RoyalGuard : RoyalGuard

    lead(): void {};
>lead : () => void
}

class FollowerGuard extends RoyalGuard {
>FollowerGuard : FollowerGuard
>RoyalGuard : RoyalGuard

    follow(): void {};
>follow : () => void
}

let a: RoyalGuard = new FollowerGuard();
>a : RoyalGuard
>new FollowerGuard() : FollowerGuard
>FollowerGuard : typeof FollowerGuard

if (a.isLeader()) {
>a.isLeader() : boolean
>a.isLeader : () => this is LeadGuard
>a : RoyalGuard
>isLeader : () => this is LeadGuard

    a.lead();
>a.lead() : void
>a.lead : () => void
>a : LeadGuard
>lead : () => void
}
else if (a.isFollower()) {
>a.isFollower() : boolean
>a.isFollower : () => this is FollowerGuard
>a : RoyalGuard
>isFollower : () => this is FollowerGuard

    a.follow();
>a.follow() : void
>a.follow : () => void
>a : FollowerGuard
>follow : () => void
}

interface GuardInterface extends RoyalGuard {}

let b: GuardInterface;
>b : GuardInterface

if (b.isLeader()) {
>b.isLeader() : boolean
>b.isLeader : () => this is LeadGuard
>b : GuardInterface
>isLeader : () => this is LeadGuard

    b.lead();
>b.lead() : void
>b.lead : () => void
>b : LeadGuard
>lead : () => void
}
else if (b.isFollower()) {
>b.isFollower() : boolean
>b.isFollower : () => this is FollowerGuard
>b : GuardInterface
>isFollower : () => this is FollowerGuard

    b.follow();
>b.follow() : void
>b.follow : () => void
>b : FollowerGuard
>follow : () => void
}

// if (((a.isLeader)())) {
//     a.lead();
// }
// else if (((a).isFollower())) {
//     a.follow();
// }

// if (((a["isLeader"])())) {
//     a.lead();
// }
// else if (((a)["isFollower"]())) {
//     a.follow();
// }

var holder2 = {a};
>holder2 : { a: RoyalGuard; }
>{a} : { a: RoyalGuard; }
>a : RoyalGuard

if (holder2.a.isLeader()) {
>holder2.a.isLeader() : boolean
>holder2.a.isLeader : () => this is LeadGuard
>holder2.a : RoyalGuard
>holder2 : { a: RoyalGuard; }
>a : RoyalGuard
>isLeader : () => this is LeadGuard

    holder2.a;
>holder2.a : LeadGuard
>holder2 : { a: RoyalGuard; }
>a : LeadGuard
}
else {
    holder2.a;
>holder2.a : RoyalGuard
>holder2 : { a: RoyalGuard; }
>a : RoyalGuard
}

class ArrowGuard {
>ArrowGuard : ArrowGuard

    isElite = (): this is ArrowElite => {
>isElite : () => this is ArrowElite
>(): this is ArrowElite => {        return this instanceof ArrowElite;    } : () => this is ArrowElite

        return this instanceof ArrowElite;
>this instanceof ArrowElite : boolean
>this : this
>ArrowElite : typeof ArrowElite
    }
    isMedic = (): this is ArrowMedic => {
>isMedic : () => this is ArrowMedic
>(): this is ArrowMedic => {        return this instanceof ArrowMedic;    } : () => this is ArrowMedic

        return this instanceof ArrowMedic;
>this instanceof ArrowMedic : boolean
>this : this
>ArrowMedic : typeof ArrowMedic
    }
}

class ArrowElite extends ArrowGuard {
>ArrowElite : ArrowElite
>ArrowGuard : ArrowGuard

    defend(): void {}
>defend : () => void
}

class ArrowMedic extends ArrowGuard {
>ArrowMedic : ArrowMedic
>ArrowGuard : ArrowGuard

    heal(): void {}
>heal : () => void
}

let guard = new ArrowGuard();
>guard : ArrowGuard
>new ArrowGuard() : ArrowGuard
>ArrowGuard : typeof ArrowGuard

if (guard.isElite()) {
>guard.isElite() : boolean
>guard.isElite : () => this is ArrowElite
>guard : ArrowGuard
>isElite : () => this is ArrowElite

    guard.defend();
>guard.defend() : void
>guard.defend : () => void
>guard : ArrowElite
>defend : () => void
}
else if (guard.isMedic()) {
>guard.isMedic() : boolean
>guard.isMedic : () => this is ArrowMedic
>guard : ArrowGuard
>isMedic : () => this is ArrowMedic

    guard.heal();
>guard.heal() : void
>guard.heal : () => void
>guard : ArrowMedic
>heal : () => void
}

interface Supplies {
    spoiled: boolean;
>spoiled : boolean
}

interface Sundries {
    broken: boolean;
>broken : boolean
}

interface Crate<T> {
    contents: T;
>contents : T

    volume: number;
>volume : number

    isSupplies(): this is Crate<Supplies>;
>isSupplies : () => this is Crate<Supplies>

    isSundries(): this is Crate<Sundries>;
>isSundries : () => this is Crate<Sundries>
}

let crate: Crate<{}>;
>crate : Crate<{}>

if (crate.isSundries()) {
>crate.isSundries() : boolean
>crate.isSundries : () => this is Crate<Sundries>
>crate : Crate<{}>
>isSundries : () => this is Crate<Sundries>

    crate.contents.broken = true;
>crate.contents.broken = true : true
>crate.contents.broken : boolean
>crate.contents : Sundries
>crate : Crate<Sundries>
>contents : Sundries
>broken : boolean
>true : true
}
else if (crate.isSupplies()) {
>crate.isSupplies() : boolean
>crate.isSupplies : () => this is Crate<Supplies>
>crate : Crate<{}>
>isSupplies : () => this is Crate<Supplies>

    crate.contents.spoiled = true;
>crate.contents.spoiled = true : true
>crate.contents.spoiled : boolean
>crate.contents : Supplies
>crate : Crate<Supplies>
>contents : Supplies
>spoiled : boolean
>true : true
}

// Matching guards should be assignable

a.isFollower = b.isFollower;
>a.isFollower = b.isFollower : () => this is FollowerGuard
>a.isFollower : () => this is FollowerGuard
>a : RoyalGuard
>isFollower : () => this is FollowerGuard
>b.isFollower : () => this is FollowerGuard
>b : GuardInterface
>isFollower : () => this is FollowerGuard

a.isLeader = b.isLeader;
>a.isLeader = b.isLeader : () => this is LeadGuard
>a.isLeader : () => this is LeadGuard
>a : RoyalGuard
>isLeader : () => this is LeadGuard
>b.isLeader : () => this is LeadGuard
>b : GuardInterface
>isLeader : () => this is LeadGuard

class MimicGuard {
>MimicGuard : MimicGuard

    isLeader(): this is MimicLeader { return this instanceof MimicLeader; };
>isLeader : () => this is MimicLeader
>this instanceof MimicLeader : boolean
>this : this
>MimicLeader : typeof MimicLeader

    isFollower(): this is MimicFollower { return this instanceof MimicFollower; };
>isFollower : () => this is MimicFollower
>this instanceof MimicFollower : boolean
>this : this
>MimicFollower : typeof MimicFollower
}

class MimicLeader extends MimicGuard {
>MimicLeader : MimicLeader
>MimicGuard : MimicGuard

    lead(): void {}
>lead : () => void
}

class MimicFollower extends MimicGuard {
>MimicFollower : MimicFollower
>MimicGuard : MimicGuard

    follow(): void {}
>follow : () => void
}

let mimic = new MimicGuard();
>mimic : MimicGuard
>new MimicGuard() : MimicGuard
>MimicGuard : typeof MimicGuard

a.isLeader = mimic.isLeader;
>a.isLeader = mimic.isLeader : () => this is MimicLeader
>a.isLeader : () => this is LeadGuard
>a : RoyalGuard
>isLeader : () => this is LeadGuard
>mimic.isLeader : () => this is MimicLeader
>mimic : MimicGuard
>isLeader : () => this is MimicLeader

a.isFollower = mimic.isFollower;
>a.isFollower = mimic.isFollower : () => this is MimicFollower
>a.isFollower : () => this is FollowerGuard
>a : RoyalGuard
>isFollower : () => this is FollowerGuard
>mimic.isFollower : () => this is MimicFollower
>mimic : MimicGuard
>isFollower : () => this is MimicFollower

if (mimic.isFollower()) {
>mimic.isFollower() : boolean
>mimic.isFollower : () => this is MimicFollower
>mimic : MimicGuard
>isFollower : () => this is MimicFollower

    mimic.follow();
>mimic.follow() : void
>mimic.follow : () => void
>mimic : MimicFollower
>follow : () => void

    mimic.isFollower = a.isFollower;
>mimic.isFollower = a.isFollower : () => this is FollowerGuard
>mimic.isFollower : () => this is MimicFollower
>mimic : MimicFollower
>isFollower : () => this is MimicFollower
>a.isFollower : () => this is FollowerGuard
>a : RoyalGuard
>isFollower : () => this is FollowerGuard
}


interface MimicGuardInterface {
    isLeader(): this is LeadGuard;
>isLeader : () => this is LeadGuard

    isFollower(): this is FollowerGuard;
>isFollower : () => this is FollowerGuard
}