diff --git a/tests/baselines/reference/neverInference.js b/tests/baselines/reference/neverInference.js
new file mode 100644
index 00000000000..d13e537eba4
--- /dev/null
+++ b/tests/baselines/reference/neverInference.js
@@ -0,0 +1,31 @@
+//// [neverInference.ts]
+declare function f<T>(x: T[]): T;
+
+let neverArray: never[] = [];
+
+let a1 = f([]);  // {}
+let a2 = f(neverArray);  // never
+
+// Repro from #19576
+
+type Comparator<T> = (x: T, y: T) => number;
+
+interface LinkedList<T> {
+    comparator: Comparator<T>,
+    nodes: Node<T>
+}
+
+type Node<T> = { value: T, next: Node<T> } | null
+
+declare function compareNumbers(x: number, y: number): number;
+declare function mkList<T>(items: T[], comparator: Comparator<T>): LinkedList<T>;
+
+const list: LinkedList<number> = mkList([], compareNumbers);
+
+
+//// [neverInference.js]
+"use strict";
+var neverArray = [];
+var a1 = f([]); // {}
+var a2 = f(neverArray); // never
+var list = mkList([], compareNumbers);
diff --git a/tests/baselines/reference/neverInference.symbols b/tests/baselines/reference/neverInference.symbols
new file mode 100644
index 00000000000..683e079b2f8
--- /dev/null
+++ b/tests/baselines/reference/neverInference.symbols
@@ -0,0 +1,76 @@
+=== tests/cases/conformance/types/never/neverInference.ts ===
+declare function f<T>(x: T[]): T;
+>f : Symbol(f, Decl(neverInference.ts, 0, 0))
+>T : Symbol(T, Decl(neverInference.ts, 0, 19))
+>x : Symbol(x, Decl(neverInference.ts, 0, 22))
+>T : Symbol(T, Decl(neverInference.ts, 0, 19))
+>T : Symbol(T, Decl(neverInference.ts, 0, 19))
+
+let neverArray: never[] = [];
+>neverArray : Symbol(neverArray, Decl(neverInference.ts, 2, 3))
+
+let a1 = f([]);  // {}
+>a1 : Symbol(a1, Decl(neverInference.ts, 4, 3))
+>f : Symbol(f, Decl(neverInference.ts, 0, 0))
+
+let a2 = f(neverArray);  // never
+>a2 : Symbol(a2, Decl(neverInference.ts, 5, 3))
+>f : Symbol(f, Decl(neverInference.ts, 0, 0))
+>neverArray : Symbol(neverArray, Decl(neverInference.ts, 2, 3))
+
+// Repro from #19576
+
+type Comparator<T> = (x: T, y: T) => number;
+>Comparator : Symbol(Comparator, Decl(neverInference.ts, 5, 23))
+>T : Symbol(T, Decl(neverInference.ts, 9, 16))
+>x : Symbol(x, Decl(neverInference.ts, 9, 22))
+>T : Symbol(T, Decl(neverInference.ts, 9, 16))
+>y : Symbol(y, Decl(neverInference.ts, 9, 27))
+>T : Symbol(T, Decl(neverInference.ts, 9, 16))
+
+interface LinkedList<T> {
+>LinkedList : Symbol(LinkedList, Decl(neverInference.ts, 9, 44))
+>T : Symbol(T, Decl(neverInference.ts, 11, 21))
+
+    comparator: Comparator<T>,
+>comparator : Symbol(LinkedList.comparator, Decl(neverInference.ts, 11, 25))
+>Comparator : Symbol(Comparator, Decl(neverInference.ts, 5, 23))
+>T : Symbol(T, Decl(neverInference.ts, 11, 21))
+
+    nodes: Node<T>
+>nodes : Symbol(LinkedList.nodes, Decl(neverInference.ts, 12, 30))
+>Node : Symbol(Node, Decl(neverInference.ts, 14, 1))
+>T : Symbol(T, Decl(neverInference.ts, 11, 21))
+}
+
+type Node<T> = { value: T, next: Node<T> } | null
+>Node : Symbol(Node, Decl(neverInference.ts, 14, 1))
+>T : Symbol(T, Decl(neverInference.ts, 16, 10))
+>value : Symbol(value, Decl(neverInference.ts, 16, 16))
+>T : Symbol(T, Decl(neverInference.ts, 16, 10))
+>next : Symbol(next, Decl(neverInference.ts, 16, 26))
+>Node : Symbol(Node, Decl(neverInference.ts, 14, 1))
+>T : Symbol(T, Decl(neverInference.ts, 16, 10))
+
+declare function compareNumbers(x: number, y: number): number;
+>compareNumbers : Symbol(compareNumbers, Decl(neverInference.ts, 16, 49))
+>x : Symbol(x, Decl(neverInference.ts, 18, 32))
+>y : Symbol(y, Decl(neverInference.ts, 18, 42))
+
+declare function mkList<T>(items: T[], comparator: Comparator<T>): LinkedList<T>;
+>mkList : Symbol(mkList, Decl(neverInference.ts, 18, 62))
+>T : Symbol(T, Decl(neverInference.ts, 19, 24))
+>items : Symbol(items, Decl(neverInference.ts, 19, 27))
+>T : Symbol(T, Decl(neverInference.ts, 19, 24))
+>comparator : Symbol(comparator, Decl(neverInference.ts, 19, 38))
+>Comparator : Symbol(Comparator, Decl(neverInference.ts, 5, 23))
+>T : Symbol(T, Decl(neverInference.ts, 19, 24))
+>LinkedList : Symbol(LinkedList, Decl(neverInference.ts, 9, 44))
+>T : Symbol(T, Decl(neverInference.ts, 19, 24))
+
+const list: LinkedList<number> = mkList([], compareNumbers);
+>list : Symbol(list, Decl(neverInference.ts, 21, 5))
+>LinkedList : Symbol(LinkedList, Decl(neverInference.ts, 9, 44))
+>mkList : Symbol(mkList, Decl(neverInference.ts, 18, 62))
+>compareNumbers : Symbol(compareNumbers, Decl(neverInference.ts, 16, 49))
+
diff --git a/tests/baselines/reference/neverInference.types b/tests/baselines/reference/neverInference.types
new file mode 100644
index 00000000000..a7dd05a3f8b
--- /dev/null
+++ b/tests/baselines/reference/neverInference.types
@@ -0,0 +1,83 @@
+=== tests/cases/conformance/types/never/neverInference.ts ===
+declare function f<T>(x: T[]): T;
+>f : <T>(x: T[]) => T
+>T : T
+>x : T[]
+>T : T
+>T : T
+
+let neverArray: never[] = [];
+>neverArray : never[]
+>[] : never[]
+
+let a1 = f([]);  // {}
+>a1 : {}
+>f([]) : {}
+>f : <T>(x: T[]) => T
+>[] : never[]
+
+let a2 = f(neverArray);  // never
+>a2 : never
+>f(neverArray) : never
+>f : <T>(x: T[]) => T
+>neverArray : never[]
+
+// Repro from #19576
+
+type Comparator<T> = (x: T, y: T) => number;
+>Comparator : Comparator<T>
+>T : T
+>x : T
+>T : T
+>y : T
+>T : T
+
+interface LinkedList<T> {
+>LinkedList : LinkedList<T>
+>T : T
+
+    comparator: Comparator<T>,
+>comparator : Comparator<T>
+>Comparator : Comparator<T>
+>T : T
+
+    nodes: Node<T>
+>nodes : Node<T>
+>Node : Node<T>
+>T : T
+}
+
+type Node<T> = { value: T, next: Node<T> } | null
+>Node : Node<T>
+>T : T
+>value : T
+>T : T
+>next : Node<T>
+>Node : Node<T>
+>T : 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>
+>T : T
+>items : T[]
+>T : T
+>comparator : Comparator<T>
+>Comparator : Comparator<T>
+>T : T
+>LinkedList : LinkedList<T>
+>T : T
+
+const list: LinkedList<number> = mkList([], compareNumbers);
+>list : LinkedList<number>
+>LinkedList : LinkedList<T>
+>mkList([], compareNumbers) : LinkedList<number>
+>mkList : <T>(items: T[], comparator: Comparator<T>) => LinkedList<T>
+>[] : never[]
+>compareNumbers : (x: number, y: number) => number
+
diff --git a/tests/cases/conformance/types/never/neverInference.ts b/tests/cases/conformance/types/never/neverInference.ts
new file mode 100644
index 00000000000..1258a35e3d3
--- /dev/null
+++ b/tests/cases/conformance/types/never/neverInference.ts
@@ -0,0 +1,24 @@
+// @strict: true
+
+declare function f<T>(x: T[]): T;
+
+let neverArray: never[] = [];
+
+let a1 = f([]);  // {}
+let a2 = f(neverArray);  // never
+
+// Repro from #19576
+
+type Comparator<T> = (x: T, y: T) => number;
+
+interface LinkedList<T> {
+    comparator: Comparator<T>,
+    nodes: Node<T>
+}
+
+type Node<T> = { value: T, next: Node<T> } | null
+
+declare function compareNumbers(x: number, y: number): number;
+declare function mkList<T>(items: T[], comparator: Comparator<T>): LinkedList<T>;
+
+const list: LinkedList<number> = mkList([], compareNumbers);