diff --git a/tests/baselines/reference/genericFunctionInference1.js b/tests/baselines/reference/genericFunctionInference1.js
new file mode 100644
index 00000000000..872656ba9c5
--- /dev/null
+++ b/tests/baselines/reference/genericFunctionInference1.js
@@ -0,0 +1,109 @@
+//// [genericFunctionInference1.ts]
+declare function pipe<A extends any[], B>(ab: (...args: A) => B): (...args: A) => B;
+declare function pipe<A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C;
+declare function pipe<A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D;
+
+declare function list<T>(a: T): T[];
+declare function box<V>(x: V): { value: V };
+
+const f00 = pipe(list);
+const f01 = pipe(list, box);
+const f02 = pipe(x => list(x), box);
+const f03 = pipe(list, x => box(x));
+const f04 = pipe(x => list(x), x => box(x))
+const f05 = pipe(list, pipe(box));
+const f06 = pipe(x => list(x), pipe(box));
+const f07 = pipe(x => list(x), pipe(x => box(x)));
+
+const f10: <T>(x: T) => T[] = pipe(list);
+const f11: <T>(x: T) => { value: T[] } = pipe(list, box);
+const f12: <T>(x: T) => { value: T[] } = pipe(x => list(x), box);
+const f13: <T>(x: T) => { value: T[] } = pipe(list, x => box(x));
+const f14: <T>(x: T) => { value: T[] } = pipe(x => list(x), x => box(x))
+const f15: <T>(x: T) => { value: T[] } = pipe(list, pipe(box));
+const f16: <T>(x: T) => { value: T[] } = pipe(x => list(x), pipe(box));
+const f17: <T>(x: T) => { value: T[] } = pipe(x => list(x), pipe(x => box(x)));
+
+// #29904.2
+
+const fn20 = pipe((_a?: {}) => 1);
+
+// #29904.3
+
+type Fn = (n: number) => number;
+const fn30: Fn = pipe(
+    x => x + 1,
+    x => x * 2,
+);
+
+const promise = Promise.resolve(1);
+promise.then(
+    pipe(
+        x => x + 1,
+        x => x * 2,
+    ),
+);
+
+// #29904.4
+
+declare const getString: () => string;
+declare const orUndefined: (name: string) => string | undefined;
+declare const identity: <T>(value: T) => T;
+
+const fn40 = pipe(
+    getString,
+    string => orUndefined(string),
+    identity,
+);
+
+// #29904.6
+
+declare const getArray: () => string[];
+declare const first: <T>(ts: T[]) => T;
+
+const fn60 = pipe(
+    getArray,
+    x => x,
+    first,
+);
+
+const fn61 = pipe(
+    getArray,
+    identity,
+    first,
+);
+
+const fn62 = pipe(
+    getArray,
+    x => x,
+    x => first(x),
+);
+
+
+//// [genericFunctionInference1.js]
+"use strict";
+const f00 = pipe(list);
+const f01 = pipe(list, box);
+const f02 = pipe(x => list(x), box);
+const f03 = pipe(list, x => box(x));
+const f04 = pipe(x => list(x), x => box(x));
+const f05 = pipe(list, pipe(box));
+const f06 = pipe(x => list(x), pipe(box));
+const f07 = pipe(x => list(x), pipe(x => box(x)));
+const f10 = pipe(list);
+const f11 = pipe(list, box);
+const f12 = pipe(x => list(x), box);
+const f13 = pipe(list, x => box(x));
+const f14 = pipe(x => list(x), x => box(x));
+const f15 = pipe(list, pipe(box));
+const f16 = pipe(x => list(x), pipe(box));
+const f17 = pipe(x => list(x), pipe(x => box(x)));
+// #29904.2
+const fn20 = pipe((_a) => 1);
+const fn30 = pipe(x => x + 1, x => x * 2);
+const promise = Promise.resolve(1);
+promise.then(pipe(x => x + 1, x => x * 2));
+const fn40 = pipe(getString, string => orUndefined(string), identity);
+const fn60 = pipe(getArray, x => x, first);
+const fn61 = pipe(getArray, identity, first);
+const fn62 = pipe(getArray, x => x, x => first(x));
diff --git a/tests/baselines/reference/genericFunctionInference1.symbols b/tests/baselines/reference/genericFunctionInference1.symbols
new file mode 100644
index 00000000000..d49a20cec9c
--- /dev/null
+++ b/tests/baselines/reference/genericFunctionInference1.symbols
@@ -0,0 +1,381 @@
+=== tests/cases/compiler/genericFunctionInference1.ts ===
+declare function pipe<A extends any[], B>(ab: (...args: A) => B): (...args: A) => B;
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+>A : Symbol(A, Decl(genericFunctionInference1.ts, 0, 22))
+>B : Symbol(B, Decl(genericFunctionInference1.ts, 0, 38))
+>ab : Symbol(ab, Decl(genericFunctionInference1.ts, 0, 42))
+>args : Symbol(args, Decl(genericFunctionInference1.ts, 0, 47))
+>A : Symbol(A, Decl(genericFunctionInference1.ts, 0, 22))
+>B : Symbol(B, Decl(genericFunctionInference1.ts, 0, 38))
+>args : Symbol(args, Decl(genericFunctionInference1.ts, 0, 67))
+>A : Symbol(A, Decl(genericFunctionInference1.ts, 0, 22))
+>B : Symbol(B, Decl(genericFunctionInference1.ts, 0, 38))
+
+declare function pipe<A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C;
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+>A : Symbol(A, Decl(genericFunctionInference1.ts, 1, 22))
+>B : Symbol(B, Decl(genericFunctionInference1.ts, 1, 38))
+>C : Symbol(C, Decl(genericFunctionInference1.ts, 1, 41))
+>ab : Symbol(ab, Decl(genericFunctionInference1.ts, 1, 45))
+>args : Symbol(args, Decl(genericFunctionInference1.ts, 1, 50))
+>A : Symbol(A, Decl(genericFunctionInference1.ts, 1, 22))
+>B : Symbol(B, Decl(genericFunctionInference1.ts, 1, 38))
+>bc : Symbol(bc, Decl(genericFunctionInference1.ts, 1, 67))
+>b : Symbol(b, Decl(genericFunctionInference1.ts, 1, 73))
+>B : Symbol(B, Decl(genericFunctionInference1.ts, 1, 38))
+>C : Symbol(C, Decl(genericFunctionInference1.ts, 1, 41))
+>args : Symbol(args, Decl(genericFunctionInference1.ts, 1, 87))
+>A : Symbol(A, Decl(genericFunctionInference1.ts, 1, 22))
+>C : Symbol(C, Decl(genericFunctionInference1.ts, 1, 41))
+
+declare function pipe<A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D;
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+>A : Symbol(A, Decl(genericFunctionInference1.ts, 2, 22))
+>B : Symbol(B, Decl(genericFunctionInference1.ts, 2, 38))
+>C : Symbol(C, Decl(genericFunctionInference1.ts, 2, 41))
+>D : Symbol(D, Decl(genericFunctionInference1.ts, 2, 44))
+>ab : Symbol(ab, Decl(genericFunctionInference1.ts, 2, 48))
+>args : Symbol(args, Decl(genericFunctionInference1.ts, 2, 53))
+>A : Symbol(A, Decl(genericFunctionInference1.ts, 2, 22))
+>B : Symbol(B, Decl(genericFunctionInference1.ts, 2, 38))
+>bc : Symbol(bc, Decl(genericFunctionInference1.ts, 2, 70))
+>b : Symbol(b, Decl(genericFunctionInference1.ts, 2, 76))
+>B : Symbol(B, Decl(genericFunctionInference1.ts, 2, 38))
+>C : Symbol(C, Decl(genericFunctionInference1.ts, 2, 41))
+>cd : Symbol(cd, Decl(genericFunctionInference1.ts, 2, 87))
+>c : Symbol(c, Decl(genericFunctionInference1.ts, 2, 93))
+>C : Symbol(C, Decl(genericFunctionInference1.ts, 2, 41))
+>D : Symbol(D, Decl(genericFunctionInference1.ts, 2, 44))
+>args : Symbol(args, Decl(genericFunctionInference1.ts, 2, 107))
+>A : Symbol(A, Decl(genericFunctionInference1.ts, 2, 22))
+>D : Symbol(D, Decl(genericFunctionInference1.ts, 2, 44))
+
+declare function list<T>(a: T): T[];
+>list : Symbol(list, Decl(genericFunctionInference1.ts, 2, 124))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 4, 22))
+>a : Symbol(a, Decl(genericFunctionInference1.ts, 4, 25))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 4, 22))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 4, 22))
+
+declare function box<V>(x: V): { value: V };
+>box : Symbol(box, Decl(genericFunctionInference1.ts, 4, 36))
+>V : Symbol(V, Decl(genericFunctionInference1.ts, 5, 21))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 5, 24))
+>V : Symbol(V, Decl(genericFunctionInference1.ts, 5, 21))
+>value : Symbol(value, Decl(genericFunctionInference1.ts, 5, 32))
+>V : Symbol(V, Decl(genericFunctionInference1.ts, 5, 21))
+
+const f00 = pipe(list);
+>f00 : Symbol(f00, Decl(genericFunctionInference1.ts, 7, 5))
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+>list : Symbol(list, Decl(genericFunctionInference1.ts, 2, 124))
+
+const f01 = pipe(list, box);
+>f01 : Symbol(f01, Decl(genericFunctionInference1.ts, 8, 5))
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+>list : Symbol(list, Decl(genericFunctionInference1.ts, 2, 124))
+>box : Symbol(box, Decl(genericFunctionInference1.ts, 4, 36))
+
+const f02 = pipe(x => list(x), box);
+>f02 : Symbol(f02, Decl(genericFunctionInference1.ts, 9, 5))
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 9, 17))
+>list : Symbol(list, Decl(genericFunctionInference1.ts, 2, 124))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 9, 17))
+>box : Symbol(box, Decl(genericFunctionInference1.ts, 4, 36))
+
+const f03 = pipe(list, x => box(x));
+>f03 : Symbol(f03, Decl(genericFunctionInference1.ts, 10, 5))
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+>list : Symbol(list, Decl(genericFunctionInference1.ts, 2, 124))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 10, 22))
+>box : Symbol(box, Decl(genericFunctionInference1.ts, 4, 36))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 10, 22))
+
+const f04 = pipe(x => list(x), x => box(x))
+>f04 : Symbol(f04, Decl(genericFunctionInference1.ts, 11, 5))
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 11, 17))
+>list : Symbol(list, Decl(genericFunctionInference1.ts, 2, 124))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 11, 17))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 11, 30))
+>box : Symbol(box, Decl(genericFunctionInference1.ts, 4, 36))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 11, 30))
+
+const f05 = pipe(list, pipe(box));
+>f05 : Symbol(f05, Decl(genericFunctionInference1.ts, 12, 5))
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+>list : Symbol(list, Decl(genericFunctionInference1.ts, 2, 124))
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+>box : Symbol(box, Decl(genericFunctionInference1.ts, 4, 36))
+
+const f06 = pipe(x => list(x), pipe(box));
+>f06 : Symbol(f06, Decl(genericFunctionInference1.ts, 13, 5))
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 13, 17))
+>list : Symbol(list, Decl(genericFunctionInference1.ts, 2, 124))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 13, 17))
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+>box : Symbol(box, Decl(genericFunctionInference1.ts, 4, 36))
+
+const f07 = pipe(x => list(x), pipe(x => box(x)));
+>f07 : Symbol(f07, Decl(genericFunctionInference1.ts, 14, 5))
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 14, 17))
+>list : Symbol(list, Decl(genericFunctionInference1.ts, 2, 124))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 14, 17))
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 14, 36))
+>box : Symbol(box, Decl(genericFunctionInference1.ts, 4, 36))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 14, 36))
+
+const f10: <T>(x: T) => T[] = pipe(list);
+>f10 : Symbol(f10, Decl(genericFunctionInference1.ts, 16, 5))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 16, 12))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 16, 15))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 16, 12))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 16, 12))
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+>list : Symbol(list, Decl(genericFunctionInference1.ts, 2, 124))
+
+const f11: <T>(x: T) => { value: T[] } = pipe(list, box);
+>f11 : Symbol(f11, Decl(genericFunctionInference1.ts, 17, 5))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 17, 12))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 17, 15))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 17, 12))
+>value : Symbol(value, Decl(genericFunctionInference1.ts, 17, 25))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 17, 12))
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+>list : Symbol(list, Decl(genericFunctionInference1.ts, 2, 124))
+>box : Symbol(box, Decl(genericFunctionInference1.ts, 4, 36))
+
+const f12: <T>(x: T) => { value: T[] } = pipe(x => list(x), box);
+>f12 : Symbol(f12, Decl(genericFunctionInference1.ts, 18, 5))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 18, 12))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 18, 15))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 18, 12))
+>value : Symbol(value, Decl(genericFunctionInference1.ts, 18, 25))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 18, 12))
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 18, 46))
+>list : Symbol(list, Decl(genericFunctionInference1.ts, 2, 124))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 18, 46))
+>box : Symbol(box, Decl(genericFunctionInference1.ts, 4, 36))
+
+const f13: <T>(x: T) => { value: T[] } = pipe(list, x => box(x));
+>f13 : Symbol(f13, Decl(genericFunctionInference1.ts, 19, 5))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 19, 12))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 19, 15))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 19, 12))
+>value : Symbol(value, Decl(genericFunctionInference1.ts, 19, 25))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 19, 12))
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+>list : Symbol(list, Decl(genericFunctionInference1.ts, 2, 124))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 19, 51))
+>box : Symbol(box, Decl(genericFunctionInference1.ts, 4, 36))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 19, 51))
+
+const f14: <T>(x: T) => { value: T[] } = pipe(x => list(x), x => box(x))
+>f14 : Symbol(f14, Decl(genericFunctionInference1.ts, 20, 5))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 20, 12))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 20, 15))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 20, 12))
+>value : Symbol(value, Decl(genericFunctionInference1.ts, 20, 25))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 20, 12))
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 20, 46))
+>list : Symbol(list, Decl(genericFunctionInference1.ts, 2, 124))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 20, 46))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 20, 59))
+>box : Symbol(box, Decl(genericFunctionInference1.ts, 4, 36))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 20, 59))
+
+const f15: <T>(x: T) => { value: T[] } = pipe(list, pipe(box));
+>f15 : Symbol(f15, Decl(genericFunctionInference1.ts, 21, 5))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 21, 12))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 21, 15))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 21, 12))
+>value : Symbol(value, Decl(genericFunctionInference1.ts, 21, 25))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 21, 12))
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+>list : Symbol(list, Decl(genericFunctionInference1.ts, 2, 124))
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+>box : Symbol(box, Decl(genericFunctionInference1.ts, 4, 36))
+
+const f16: <T>(x: T) => { value: T[] } = pipe(x => list(x), pipe(box));
+>f16 : Symbol(f16, Decl(genericFunctionInference1.ts, 22, 5))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 22, 12))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 22, 15))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 22, 12))
+>value : Symbol(value, Decl(genericFunctionInference1.ts, 22, 25))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 22, 12))
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 22, 46))
+>list : Symbol(list, Decl(genericFunctionInference1.ts, 2, 124))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 22, 46))
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+>box : Symbol(box, Decl(genericFunctionInference1.ts, 4, 36))
+
+const f17: <T>(x: T) => { value: T[] } = pipe(x => list(x), pipe(x => box(x)));
+>f17 : Symbol(f17, Decl(genericFunctionInference1.ts, 23, 5))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 23, 12))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 23, 15))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 23, 12))
+>value : Symbol(value, Decl(genericFunctionInference1.ts, 23, 25))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 23, 12))
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 23, 46))
+>list : Symbol(list, Decl(genericFunctionInference1.ts, 2, 124))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 23, 46))
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 23, 65))
+>box : Symbol(box, Decl(genericFunctionInference1.ts, 4, 36))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 23, 65))
+
+// #29904.2
+
+const fn20 = pipe((_a?: {}) => 1);
+>fn20 : Symbol(fn20, Decl(genericFunctionInference1.ts, 27, 5))
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+>_a : Symbol(_a, Decl(genericFunctionInference1.ts, 27, 19))
+
+// #29904.3
+
+type Fn = (n: number) => number;
+>Fn : Symbol(Fn, Decl(genericFunctionInference1.ts, 27, 34))
+>n : Symbol(n, Decl(genericFunctionInference1.ts, 31, 11))
+
+const fn30: Fn = pipe(
+>fn30 : Symbol(fn30, Decl(genericFunctionInference1.ts, 32, 5))
+>Fn : Symbol(Fn, Decl(genericFunctionInference1.ts, 27, 34))
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+
+    x => x + 1,
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 32, 22))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 32, 22))
+
+    x => x * 2,
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 33, 15))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 33, 15))
+
+);
+
+const promise = Promise.resolve(1);
+>promise : Symbol(promise, Decl(genericFunctionInference1.ts, 37, 5))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+
+promise.then(
+>promise.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+>promise : Symbol(promise, Decl(genericFunctionInference1.ts, 37, 5))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --))
+
+    pipe(
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+
+        x => x + 1,
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 39, 9))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 39, 9))
+
+        x => x * 2,
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 40, 19))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 40, 19))
+
+    ),
+);
+
+// #29904.4
+
+declare const getString: () => string;
+>getString : Symbol(getString, Decl(genericFunctionInference1.ts, 47, 13))
+
+declare const orUndefined: (name: string) => string | undefined;
+>orUndefined : Symbol(orUndefined, Decl(genericFunctionInference1.ts, 48, 13))
+>name : Symbol(name, Decl(genericFunctionInference1.ts, 48, 28))
+
+declare const identity: <T>(value: T) => T;
+>identity : Symbol(identity, Decl(genericFunctionInference1.ts, 49, 13))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 49, 25))
+>value : Symbol(value, Decl(genericFunctionInference1.ts, 49, 28))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 49, 25))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 49, 25))
+
+const fn40 = pipe(
+>fn40 : Symbol(fn40, Decl(genericFunctionInference1.ts, 51, 5))
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+
+    getString,
+>getString : Symbol(getString, Decl(genericFunctionInference1.ts, 47, 13))
+
+    string => orUndefined(string),
+>string : Symbol(string, Decl(genericFunctionInference1.ts, 52, 14))
+>orUndefined : Symbol(orUndefined, Decl(genericFunctionInference1.ts, 48, 13))
+>string : Symbol(string, Decl(genericFunctionInference1.ts, 52, 14))
+
+    identity,
+>identity : Symbol(identity, Decl(genericFunctionInference1.ts, 49, 13))
+
+);
+
+// #29904.6
+
+declare const getArray: () => string[];
+>getArray : Symbol(getArray, Decl(genericFunctionInference1.ts, 59, 13))
+
+declare const first: <T>(ts: T[]) => T;
+>first : Symbol(first, Decl(genericFunctionInference1.ts, 60, 13))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 60, 22))
+>ts : Symbol(ts, Decl(genericFunctionInference1.ts, 60, 25))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 60, 22))
+>T : Symbol(T, Decl(genericFunctionInference1.ts, 60, 22))
+
+const fn60 = pipe(
+>fn60 : Symbol(fn60, Decl(genericFunctionInference1.ts, 62, 5))
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+
+    getArray,
+>getArray : Symbol(getArray, Decl(genericFunctionInference1.ts, 59, 13))
+
+    x => x,
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 63, 13))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 63, 13))
+
+    first,
+>first : Symbol(first, Decl(genericFunctionInference1.ts, 60, 13))
+
+);
+
+const fn61 = pipe(
+>fn61 : Symbol(fn61, Decl(genericFunctionInference1.ts, 68, 5))
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+
+    getArray,
+>getArray : Symbol(getArray, Decl(genericFunctionInference1.ts, 59, 13))
+
+    identity,
+>identity : Symbol(identity, Decl(genericFunctionInference1.ts, 49, 13))
+
+    first,
+>first : Symbol(first, Decl(genericFunctionInference1.ts, 60, 13))
+
+);
+
+const fn62 = pipe(
+>fn62 : Symbol(fn62, Decl(genericFunctionInference1.ts, 74, 5))
+>pipe : Symbol(pipe, Decl(genericFunctionInference1.ts, 0, 0), Decl(genericFunctionInference1.ts, 0, 84), Decl(genericFunctionInference1.ts, 1, 104))
+
+    getArray,
+>getArray : Symbol(getArray, Decl(genericFunctionInference1.ts, 59, 13))
+
+    x => x,
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 75, 13))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 75, 13))
+
+    x => first(x),
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 76, 11))
+>first : Symbol(first, Decl(genericFunctionInference1.ts, 60, 13))
+>x : Symbol(x, Decl(genericFunctionInference1.ts, 76, 11))
+
+);
+
diff --git a/tests/baselines/reference/genericFunctionInference1.types b/tests/baselines/reference/genericFunctionInference1.types
new file mode 100644
index 00000000000..037e4a49718
--- /dev/null
+++ b/tests/baselines/reference/genericFunctionInference1.types
@@ -0,0 +1,397 @@
+=== tests/cases/compiler/genericFunctionInference1.ts ===
+declare function pipe<A extends any[], B>(ab: (...args: A) => B): (...args: A) => B;
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+>ab : (...args: A) => B
+>args : A
+>args : A
+
+declare function pipe<A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C;
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+>ab : (...args: A) => B
+>args : A
+>bc : (b: B) => C
+>b : B
+>args : A
+
+declare function pipe<A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D;
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+>ab : (...args: A) => B
+>args : A
+>bc : (b: B) => C
+>b : B
+>cd : (c: C) => D
+>c : C
+>args : A
+
+declare function list<T>(a: T): T[];
+>list : <T>(a: T) => T[]
+>a : T
+
+declare function box<V>(x: V): { value: V };
+>box : <V>(x: V) => { value: V; }
+>x : V
+>value : V
+
+const f00 = pipe(list);
+>f00 : (a: any) => any[]
+>pipe(list) : (a: any) => any[]
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+>list : <T>(a: T) => T[]
+
+const f01 = pipe(list, box);
+>f01 : (a: any) => { value: any[]; }
+>pipe(list, box) : (a: any) => { value: any[]; }
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+>list : <T>(a: T) => T[]
+>box : <V>(x: V) => { value: V; }
+
+const f02 = pipe(x => list(x), box);
+>f02 : (x: any) => { value: any[]; }
+>pipe(x => list(x), box) : (x: any) => { value: any[]; }
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+>x => list(x) : (x: any) => any[]
+>x : any
+>list(x) : any[]
+>list : <T>(a: T) => T[]
+>x : any
+>box : <V>(x: V) => { value: V; }
+
+const f03 = pipe(list, x => box(x));
+>f03 : (a: any) => { value: any[]; }
+>pipe(list, x => box(x)) : (a: any) => { value: any[]; }
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+>list : <T>(a: T) => T[]
+>x => box(x) : (x: any[]) => { value: any[]; }
+>x : any[]
+>box(x) : { value: any[]; }
+>box : <V>(x: V) => { value: V; }
+>x : any[]
+
+const f04 = pipe(x => list(x), x => box(x))
+>f04 : (x: any) => { value: any[]; }
+>pipe(x => list(x), x => box(x)) : (x: any) => { value: any[]; }
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+>x => list(x) : (x: any) => any[]
+>x : any
+>list(x) : any[]
+>list : <T>(a: T) => T[]
+>x : any
+>x => box(x) : (x: any[]) => { value: any[]; }
+>x : any[]
+>box(x) : { value: any[]; }
+>box : <V>(x: V) => { value: V; }
+>x : any[]
+
+const f05 = pipe(list, pipe(box));
+>f05 : (a: any) => { value: any[]; }
+>pipe(list, pipe(box)) : (a: any) => { value: any[]; }
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+>list : <T>(a: T) => T[]
+>pipe(box) : (x: any[]) => { value: any[]; }
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+>box : <V>(x: V) => { value: V; }
+
+const f06 = pipe(x => list(x), pipe(box));
+>f06 : (x: any) => { value: any[]; }
+>pipe(x => list(x), pipe(box)) : (x: any) => { value: any[]; }
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+>x => list(x) : (x: any) => any[]
+>x : any
+>list(x) : any[]
+>list : <T>(a: T) => T[]
+>x : any
+>pipe(box) : (x: any[]) => { value: any[]; }
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+>box : <V>(x: V) => { value: V; }
+
+const f07 = pipe(x => list(x), pipe(x => box(x)));
+>f07 : (x: any) => { value: any[]; }
+>pipe(x => list(x), pipe(x => box(x))) : (x: any) => { value: any[]; }
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+>x => list(x) : (x: any) => any[]
+>x : any
+>list(x) : any[]
+>list : <T>(a: T) => T[]
+>x : any
+>pipe(x => box(x)) : (x: any[]) => { value: any[]; }
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+>x => box(x) : (x: any[]) => { value: any[]; }
+>x : any[]
+>box(x) : { value: any[]; }
+>box : <V>(x: V) => { value: V; }
+>x : any[]
+
+const f10: <T>(x: T) => T[] = pipe(list);
+>f10 : <T>(x: T) => T[]
+>x : T
+>pipe(list) : (a: T) => T[]
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+>list : <T>(a: T) => T[]
+
+const f11: <T>(x: T) => { value: T[] } = pipe(list, box);
+>f11 : <T>(x: T) => { value: T[]; }
+>x : T
+>value : T[]
+>pipe(list, box) : (a: T) => { value: T[]; }
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+>list : <T>(a: T) => T[]
+>box : <V>(x: V) => { value: V; }
+
+const f12: <T>(x: T) => { value: T[] } = pipe(x => list(x), box);
+>f12 : <T>(x: T) => { value: T[]; }
+>x : T
+>value : T[]
+>pipe(x => list(x), box) : (x: T) => { value: T[]; }
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+>x => list(x) : (x: T) => T[]
+>x : T
+>list(x) : T[]
+>list : <T>(a: T) => T[]
+>x : T
+>box : <V>(x: V) => { value: V; }
+
+const f13: <T>(x: T) => { value: T[] } = pipe(list, x => box(x));
+>f13 : <T>(x: T) => { value: T[]; }
+>x : T
+>value : T[]
+>pipe(list, x => box(x)) : (a: T) => { value: T[]; }
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+>list : <T>(a: T) => T[]
+>x => box(x) : (x: T[]) => { value: T[]; }
+>x : T[]
+>box(x) : { value: T[]; }
+>box : <V>(x: V) => { value: V; }
+>x : T[]
+
+const f14: <T>(x: T) => { value: T[] } = pipe(x => list(x), x => box(x))
+>f14 : <T>(x: T) => { value: T[]; }
+>x : T
+>value : T[]
+>pipe(x => list(x), x => box(x)) : (x: T) => { value: T[]; }
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+>x => list(x) : (x: T) => T[]
+>x : T
+>list(x) : T[]
+>list : <T>(a: T) => T[]
+>x : T
+>x => box(x) : (x: T[]) => { value: T[]; }
+>x : T[]
+>box(x) : { value: T[]; }
+>box : <V>(x: V) => { value: V; }
+>x : T[]
+
+const f15: <T>(x: T) => { value: T[] } = pipe(list, pipe(box));
+>f15 : <T>(x: T) => { value: T[]; }
+>x : T
+>value : T[]
+>pipe(list, pipe(box)) : (a: T) => { value: T[]; }
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+>list : <T>(a: T) => T[]
+>pipe(box) : (x: T[]) => { value: T[]; }
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+>box : <V>(x: V) => { value: V; }
+
+const f16: <T>(x: T) => { value: T[] } = pipe(x => list(x), pipe(box));
+>f16 : <T>(x: T) => { value: T[]; }
+>x : T
+>value : T[]
+>pipe(x => list(x), pipe(box)) : (x: T) => { value: T[]; }
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+>x => list(x) : (x: T) => T[]
+>x : T
+>list(x) : T[]
+>list : <T>(a: T) => T[]
+>x : T
+>pipe(box) : (x: T[]) => { value: T[]; }
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+>box : <V>(x: V) => { value: V; }
+
+const f17: <T>(x: T) => { value: T[] } = pipe(x => list(x), pipe(x => box(x)));
+>f17 : <T>(x: T) => { value: T[]; }
+>x : T
+>value : T[]
+>pipe(x => list(x), pipe(x => box(x))) : (x: T) => { value: T[]; }
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+>x => list(x) : (x: T) => T[]
+>x : T
+>list(x) : T[]
+>list : <T>(a: T) => T[]
+>x : T
+>pipe(x => box(x)) : (x: T[]) => { value: T[]; }
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+>x => box(x) : (x: T[]) => { value: T[]; }
+>x : T[]
+>box(x) : { value: T[]; }
+>box : <V>(x: V) => { value: V; }
+>x : T[]
+
+// #29904.2
+
+const fn20 = pipe((_a?: {}) => 1);
+>fn20 : (_a?: {} | undefined) => number
+>pipe((_a?: {}) => 1) : (_a?: {} | undefined) => number
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+>(_a?: {}) => 1 : (_a?: {} | undefined) => number
+>_a : {} | undefined
+>1 : 1
+
+// #29904.3
+
+type Fn = (n: number) => number;
+>Fn : Fn
+>n : number
+
+const fn30: Fn = pipe(
+>fn30 : Fn
+>pipe(    x => x + 1,    x => x * 2,) : (x: number) => number
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+
+    x => x + 1,
+>x => x + 1 : (x: number) => number
+>x : number
+>x + 1 : number
+>x : number
+>1 : 1
+
+    x => x * 2,
+>x => x * 2 : (x: number) => number
+>x : number
+>x * 2 : number
+>x : number
+>2 : 2
+
+);
+
+const promise = Promise.resolve(1);
+>promise : Promise<number>
+>Promise.resolve(1) : Promise<number>
+>Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>Promise : PromiseConstructor
+>resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
+>1 : 1
+
+promise.then(
+>promise.then(    pipe(        x => x + 1,        x => x * 2,    ),) : Promise<number>
+>promise.then : <TResult1 = number, TResult2 = never>(onfulfilled?: ((value: number) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+>promise : Promise<number>
+>then : <TResult1 = number, TResult2 = never>(onfulfilled?: ((value: number) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>
+
+    pipe(
+>pipe(        x => x + 1,        x => x * 2,    ) : (x: number) => number
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+
+        x => x + 1,
+>x => x + 1 : (x: number) => number
+>x : number
+>x + 1 : number
+>x : number
+>1 : 1
+
+        x => x * 2,
+>x => x * 2 : (x: number) => number
+>x : number
+>x * 2 : number
+>x : number
+>2 : 2
+
+    ),
+);
+
+// #29904.4
+
+declare const getString: () => string;
+>getString : () => string
+
+declare const orUndefined: (name: string) => string | undefined;
+>orUndefined : (name: string) => string | undefined
+>name : string
+
+declare const identity: <T>(value: T) => T;
+>identity : <T>(value: T) => T
+>value : T
+
+const fn40 = pipe(
+>fn40 : () => string | undefined
+>pipe(    getString,    string => orUndefined(string),    identity,) : () => string | undefined
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+
+    getString,
+>getString : () => string
+
+    string => orUndefined(string),
+>string => orUndefined(string) : (string: string) => string | undefined
+>string : string
+>orUndefined(string) : string | undefined
+>orUndefined : (name: string) => string | undefined
+>string : string
+
+    identity,
+>identity : <T>(value: T) => T
+
+);
+
+// #29904.6
+
+declare const getArray: () => string[];
+>getArray : () => string[]
+
+declare const first: <T>(ts: T[]) => T;
+>first : <T>(ts: T[]) => T
+>ts : T[]
+
+const fn60 = pipe(
+>fn60 : () => string
+>pipe(    getArray,    x => x,    first,) : () => string
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+
+    getArray,
+>getArray : () => string[]
+
+    x => x,
+>x => x : (x: string[]) => string[]
+>x : string[]
+>x : string[]
+
+    first,
+>first : <T>(ts: T[]) => T
+
+);
+
+const fn61 = pipe(
+>fn61 : () => string
+>pipe(    getArray,    identity,    first,) : () => string
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+
+    getArray,
+>getArray : () => string[]
+
+    identity,
+>identity : <T>(value: T) => T
+
+    first,
+>first : <T>(ts: T[]) => T
+
+);
+
+const fn62 = pipe(
+>fn62 : () => string
+>pipe(    getArray,    x => x,    x => first(x),) : () => string
+>pipe : { <A extends any[], B>(ab: (...args: A) => B): (...args: A) => B; <A extends any[], B, C>(ab: (...args: A) => B, bc: (b: B) => C): (...args: A) => C; <A extends any[], B, C, D>(ab: (...args: A) => B, bc: (b: B) => C, cd: (c: C) => D): (...args: A) => D; }
+
+    getArray,
+>getArray : () => string[]
+
+    x => x,
+>x => x : (x: string[]) => string[]
+>x : string[]
+>x : string[]
+
+    x => first(x),
+>x => first(x) : (x: string[]) => string
+>x : string[]
+>first(x) : string
+>first : <T>(ts: T[]) => T
+>x : string[]
+
+);
+