=== tests/cases/conformance/types/literal/numericLiteralTypes3.ts ===
type A = 1;
>A : 1

type B = 2 | 3;
>B : B

type C = 1 | 2 | 3;
>C : C

type D = 0 | 1 | 2;
>D : D

function f1(a: A, b: B, c: C, d: D) {
>f1 : (a: A, b: B, c: C, d: D) => void
>a : 1
>b : B
>c : C
>d : D

    a = a;
>a = a : 1
>a : 1
>a : 1

    a = b;
>a = b : B
>a : 1
>b : B

    a = c;
>a = c : C
>a : 1
>c : C

    a = d;
>a = d : D
>a : 1
>d : D
}

function f2(a: A, b: B, c: C, d: D) {
>f2 : (a: A, b: B, c: C, d: D) => void
>a : 1
>b : B
>c : C
>d : D

    b = a;
>b = a : 1
>b : B
>a : 1

    b = b;
>b = b : B
>b : B
>b : B

    b = c;
>b = c : C
>b : B
>c : C

    b = d;
>b = d : D
>b : B
>d : D
}

function f3(a: A, b: B, c: C, d: D) {
>f3 : (a: A, b: B, c: C, d: D) => void
>a : 1
>b : B
>c : C
>d : D

    c = a;
>c = a : 1
>c : C
>a : 1

    c = b;
>c = b : B
>c : C
>b : B

    c = c;
>c = c : 2 | 3
>c : C
>c : 2 | 3

    c = d;
>c = d : D
>c : C
>d : D
}

function f4(a: A, b: B, c: C, d: D) {
>f4 : (a: A, b: B, c: C, d: D) => void
>a : 1
>b : B
>c : C
>d : D

    d = a;
>d = a : 1
>d : D
>a : 1

    d = b;
>d = b : B
>d : D
>b : B

    d = c;
>d = c : C
>d : D
>c : C

    d = d;
>d = d : D
>d : D
>d : D
}

function f5(a: A, b: B, c: C, d: D) {
>f5 : (a: A, b: B, c: C, d: D) => void
>a : 1
>b : B
>c : C
>d : D

    a = 0;
>a = 0 : 0
>a : 1
>0 : 0

    a = 1;
>a = 1 : 1
>a : 1
>1 : 1

    a = 2;
>a = 2 : 2
>a : 1
>2 : 2

    a = 3;
>a = 3 : 3
>a : 1
>3 : 3

    b = 0;
>b = 0 : 0
>b : B
>0 : 0

    b = 1;
>b = 1 : 1
>b : B
>1 : 1

    b = 2;
>b = 2 : 2
>b : B
>2 : 2

    b = 3;
>b = 3 : 3
>b : B
>3 : 3

    c = 0;
>c = 0 : 0
>c : C
>0 : 0

    c = 1;
>c = 1 : 1
>c : C
>1 : 1

    c = 2;
>c = 2 : 2
>c : C
>2 : 2

    c = 3;
>c = 3 : 3
>c : C
>3 : 3

    d = 0;
>d = 0 : 0
>d : D
>0 : 0

    d = 1;
>d = 1 : 1
>d : D
>1 : 1

    d = 2;
>d = 2 : 2
>d : D
>2 : 2

    d = 3;
>d = 3 : 3
>d : D
>3 : 3
}

function f6(a: A, b: B, c: C, d: D) {
>f6 : (a: A, b: B, c: C, d: D) => void
>a : 1
>b : B
>c : C
>d : D

    a === 0;
>a === 0 : boolean
>a : 1
>0 : 0

    a === 1;
>a === 1 : boolean
>a : 1
>1 : 1

    a === 2;
>a === 2 : boolean
>a : 1
>2 : 2

    a === 3;
>a === 3 : boolean
>a : 1
>3 : 3

    b === 0;
>b === 0 : boolean
>b : B
>0 : 0

    b === 1;
>b === 1 : boolean
>b : B
>1 : 1

    b === 2;
>b === 2 : boolean
>b : B
>2 : 2

    b === 3;
>b === 3 : boolean
>b : B
>3 : 3

    c === 0;
>c === 0 : boolean
>c : C
>0 : 0

    c === 1;
>c === 1 : boolean
>c : C
>1 : 1

    c === 2;
>c === 2 : boolean
>c : C
>2 : 2

    c === 3;
>c === 3 : boolean
>c : C
>3 : 3

    d === 0;
>d === 0 : boolean
>d : D
>0 : 0

    d === 1;
>d === 1 : boolean
>d : D
>1 : 1

    d === 2;
>d === 2 : boolean
>d : D
>2 : 2

    d === 3;
>d === 3 : boolean
>d : D
>3 : 3
}

function f7(a: A, b: B, c: C, d: D) {
>f7 : (a: A, b: B, c: C, d: D) => void
>a : 1
>b : B
>c : C
>d : D

    a === a;
>a === a : boolean
>a : 1
>a : 1

    a === b;
>a === b : boolean
>a : 1
>b : B

    a === c;
>a === c : boolean
>a : 1
>c : C

    a === d;
>a === d : boolean
>a : 1
>d : D

    b === a;
>b === a : boolean
>b : B
>a : 1

    b === b;
>b === b : boolean
>b : B
>b : B

    b === c;
>b === c : boolean
>b : B
>c : C

    b === d;
>b === d : boolean
>b : B
>d : D

    c === a;
>c === a : boolean
>c : C
>a : 1

    c === b;
>c === b : boolean
>c : C
>b : B

    c === c;
>c === c : boolean
>c : C
>c : C

    c === d;
>c === d : boolean
>c : C
>d : D

    d === a;
>d === a : boolean
>d : D
>a : 1

    d === b;
>d === b : boolean
>d : D
>b : B

    d === c;
>d === c : boolean
>d : D
>c : C

    d === d;
>d === d : boolean
>d : D
>d : D
}

function f8(x: 0 | 2 | 4) {
>f8 : (x: 0 | 2 | 4) => void
>x : 0 | 2 | 4

    switch (x) {
>x : 0 | 2 | 4

        case 0: return;
>0 : 0

        case 1: return;
>1 : 1

        case 2: return;
>2 : 2

        case 3: return;
>3 : 3

        case 4: return;
>4 : 4

        case 5: return;
>5 : 5
    }
}