6aeb8c12cc
* Create separate types for equivalent aliased unions * Accept new baselines * Preserve original types for union types * Accept new baselines * Preserve intersection origin for union types * Accept new baselines * Accept new baselines * Preserve aliases during relationship checks * Accept new baselines * Preserve aliases for intersection and indexed access types * Accept new baselines * Compute intersection-of-unions cross product without recursion * Accept new baselines * Use denormalized type objects for origin / support 'keyof' origins * Accept new baselines * Fix fourslash test * Recursively extract named union types * Accept new baselines * Map on union origin in mapType to better preserve aliases and origins * Remove redundant call * Accept new baselines * Revert back to declared type when branches produce equivalent union * Accept new baselines * Don't include denormal origin types in regular type statistics * Fix issue with unions not being marked primitive-only * Allow new alias to be associated with type alias instantiation * Accept new baselines * Revert "Accept new baselines" This reverts commit4507270cc1. * Revert "Allow new alias to be associated with type alias instantiation" This reverts commit2c2d06dfe1.
416 lines
4.2 KiB
Plaintext
416 lines
4.2 KiB
Plaintext
=== 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
|
|
}
|
|
}
|