1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
|
=== tests/cases/conformance/types/never/neverInference.ts ===
declare function f1<T>(x: T[]): T;
>f1 : <T>(x: T[]) => T
>x : T[]
let neverArray: never[] = [];
>neverArray : never[]
>[] : never[]
let a1 = f1([]); // never
>a1 : never
>f1([]) : never
>f1 : <T>(x: T[]) => T
>[] : never[]
let a2 = f1(neverArray); // never
>a2 : never
>f1(neverArray) : never
>f1 : <T>(x: T[]) => T
>neverArray : never[]
// Repro from #19576
type Comparator<T> = (x: T, y: T) => number;
>Comparator : Comparator<T>
>x : T
>y : T
interface LinkedList<T> {
comparator: Comparator<T>,
>comparator : Comparator<T>
nodes: Node<T>
>nodes : Node<T>
}
type Node<T> = { value: T, next: Node<T> } | null
>Node : Node<T>
>value : T
>next : Node<T>
>null : null
declare function compareNumbers(x: number, y: number): number;
>compareNumbers : (x: number, y: number) => number
>x : number
>y : number
declare function mkList<T>(items: T[], comparator: Comparator<T>): LinkedList<T>;
>mkList : <T>(items: T[], comparator: Comparator<T>) => LinkedList<T>
>items : T[]
>comparator : Comparator<T>
const list: LinkedList<number> = mkList([], compareNumbers);
>list : LinkedList<number>
>mkList([], compareNumbers) : LinkedList<number>
>mkList : <T>(items: T[], comparator: Comparator<T>) => LinkedList<T>
>[] : never[]
>compareNumbers : (x: number, y: number) => number
// Repro from #19858
declare function f2<a>(as1: a[], as2: a[], cmp: (a1: a, a2: a) => number): void;
>f2 : <a>(as1: a[], as2: a[], cmp: (a1: a, a2: a) => number) => void
>as1 : a[]
>as2 : a[]
>cmp : (a1: a, a2: a) => number
>a1 : a
>a2 : a
f2(Array.from([0]), [], (a1, a2) => a1 - a2);
>f2(Array.from([0]), [], (a1, a2) => a1 - a2) : void
>f2 : <a>(as1: a[], as2: a[], cmp: (a1: a, a2: a) => number) => void
>Array.from([0]) : number[]
>Array.from : { <T>(arrayLike: ArrayLike<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; <T>(iterable: Iterable<T> | ArrayLike<T>): T[]; <T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; }
>Array : ArrayConstructor
>from : { <T>(arrayLike: ArrayLike<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; <T>(iterable: Iterable<T> | ArrayLike<T>): T[]; <T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; }
>[0] : number[]
>0 : 0
>[] : never[]
>(a1, a2) => a1 - a2 : (a1: number, a2: number) => number
>a1 : number
>a2 : number
>a1 - a2 : number
>a1 : number
>a2 : number
f2(Array.from([]), [0], (a1, a2) => a1 - a2);
>f2(Array.from([]), [0], (a1, a2) => a1 - a2) : void
>f2 : <a>(as1: a[], as2: a[], cmp: (a1: a, a2: a) => number) => void
>Array.from([]) : never[]
>Array.from : { <T>(arrayLike: ArrayLike<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; <T>(iterable: Iterable<T> | ArrayLike<T>): T[]; <T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; }
>Array : ArrayConstructor
>from : { <T>(arrayLike: ArrayLike<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; <T>(iterable: Iterable<T> | ArrayLike<T>): T[]; <T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; }
>[] : never[]
>[0] : number[]
>0 : 0
>(a1, a2) => a1 - a2 : (a1: number, a2: number) => number
>a1 : number
>a2 : number
>a1 - a2 : number
>a1 : number
>a2 : number
|
