TypeScript/tests/baselines/reference/booleanLiteralTypes1.types

=== tests/cases/conformance/types/literal/booleanLiteralTypes1.ts ===
type A1 = true | false;
>A1 : boolean
>true : true
>false : false

type A2 = false | true;
>A2 : boolean
>false : false
>true : true

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

    var a: A1;
>a : boolean
>A1 : boolean

    var a: A2;
>a : boolean
>A2 : boolean

    var a: true | false;
>a : boolean
>true : true
>false : false

    var a: false | true;
>a : boolean
>false : false
>true : true
}

function f2(a: true | false, b: boolean) {
>f2 : (a: boolean, b: boolean) => void
>a : boolean
>true : true
>false : false
>b : boolean

    a = b;
>a = b : boolean
>a : boolean
>b : boolean

    b = a;
>b = a : boolean
>b : boolean
>a : boolean
}

function f3(a: true | false, b: true | false) {
>f3 : (a: boolean, b: boolean) => void
>a : boolean
>true : true
>false : false
>b : boolean
>true : true
>false : false

    var x = a || b;
>x : boolean
>a || b : boolean
>a : boolean
>b : boolean

    var x = a && b;
>x : boolean
>a && b : boolean
>a : boolean
>b : boolean

    var x = !a;
>x : boolean
>!a : boolean
>a : boolean
}

function f4(t: true, f: false) {
>f4 : (t: true, f: false) => void
>t : true
>true : true
>f : false
>false : false

    var x1 = t && f;
>x1 : false
>t && f : false
>t : true
>f : false

    var x2 = f && t;
>x2 : false
>f && t : false
>f : false
>t : true

    var x3 = t || f;
>x3 : boolean
>t || f : boolean
>t : true
>f : false

    var x4 = f || t;
>x4 : true
>f || t : true
>f : false
>t : true

    var x5 = !t;
>x5 : boolean
>!t : boolean
>t : true

    var x6 = !f;
>x6 : true
>!f : true
>f : false
}

declare function g(x: true): string;
>g : { (x: true): string; (x: false): boolean; (x: boolean): number; }
>x : true
>true : true

declare function g(x: false): boolean;
>g : { (x: true): string; (x: false): boolean; (x: boolean): number; }
>x : false
>false : false

declare function g(x: boolean): number;
>g : { (x: true): string; (x: false): boolean; (x: boolean): number; }
>x : boolean

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

    var z1 = g(true);
>z1 : string
>g(true) : string
>g : { (x: true): string; (x: false): boolean; (x: boolean): number; }
>true : true

    var z2 = g(false);
>z2 : boolean
>g(false) : boolean
>g : { (x: true): string; (x: false): boolean; (x: boolean): number; }
>false : false

    var z3 = g(b);
>z3 : number
>g(b) : number
>g : { (x: true): string; (x: false): boolean; (x: boolean): number; }
>b : boolean
}

function assertNever(x: never): never {
>assertNever : (x: never) => never
>x : never

    throw new Error("Unexpected value");
>new Error("Unexpected value") : Error
>Error : ErrorConstructor
>"Unexpected value" : string
}

function f10(x: true | false) {
>f10 : (x: boolean) => string
>x : boolean
>true : true
>false : false

    switch (x) {
>x : boolean

        case true: return "true";
>true : true
>"true" : string

        case false: return "false";
>false : false
>"false" : string
    }
}

function f11(x: true | false) {
>f11 : (x: boolean) => string
>x : boolean
>true : true
>false : false

    switch (x) {
>x : boolean

        case true: return "true";
>true : true
>"true" : string

        case false: return "false";
>false : false
>"false" : string
    }
    return assertNever(x);
>assertNever(x) : never
>assertNever : (x: never) => never
>x : never
}

function f12(x: true | false) {
>f12 : (x: boolean) => void
>x : boolean
>true : true
>false : false

    if (x) {
>x : boolean

        x;
>x : true
    }
    else {
        x;
>x : boolean
    }
}

function f13(x: true | false) {
>f13 : (x: boolean) => void
>x : boolean
>true : true
>false : false

    if (x === true) {
>x === true : boolean
>x : boolean
>true : true

        x;
>x : true
    }
    else {
        x;
>x : false
    }
}

type Item =
>Item : Item

    { kind: true, a: string } |
>kind : true
>true : true
>a : string

    { kind: false, b: string };
>kind : false
>false : false
>b : string

function f20(x: Item) {
>f20 : (x: Item) => string
>x : Item
>Item : Item

    switch (x.kind) {
>x.kind : boolean
>x : Item
>kind : boolean

        case true: return x.a;
>true : true
>x.a : string
>x : { kind: true; a: string; }
>a : string

        case false: return x.b;
>false : false
>x.b : string
>x : { kind: false; b: string; }
>b : string
    }
}

function f21(x: Item) {
>f21 : (x: Item) => string
>x : Item
>Item : Item

    switch (x.kind) {
>x.kind : boolean
>x : Item
>kind : boolean

        case true: return x.a;
>true : true
>x.a : string
>x : { kind: true; a: string; }
>a : string

        case false: return x.b;
>false : false
>x.b : string
>x : { kind: false; b: string; }
>b : string
    }
    return assertNever(x);
>assertNever(x) : never
>assertNever : (x: never) => never
>x : never
}