Accept new baselines

tests/baselines/reference/contextualSignatureInstantiation1.types

@@ -15,8 +15,8 @@ var e = <K>(x: string, y?: K) => x.length;
 >length : number
 
 var r99 = map(e); // should be {}[] for S since a generic lambda is not inferentially typed
->r99 : (a: {}[]) => number[]
->map(e) : (a: {}[]) => number[]
+>r99 : <K>(a: string[]) => number[]
+>map(e) : <K>(a: string[]) => number[]
 >map : <S, T>(f: (x: S) => T) => (a: S[]) => T[]
 >e : <K>(x: string, y?: K) => number
 
@@ -37,8 +37,8 @@ var e2 = <K>(x: string, y?: K) => x.length;
 >length : number
 
 var r100 = map2(e2); // type arg inference should fail for S since a generic lambda is not inferentially typed. Falls back to { length: number }
->r100 : (a: { length: number; }[]) => number[]
->map2(e2) : (a: { length: number; }[]) => number[]
+>r100 : <K>(a: string[]) => number[]
+>map2(e2) : <K>(a: string[]) => number[]
 >map2 : <S extends { length: number; }, T>(f: (x: S) => T) => (a: S[]) => T[]
 >e2 : <K>(x: string, y?: K) => number
 

tests/baselines/reference/contextualSignatureInstantiation2.types

@@ -31,8 +31,8 @@ var id: <T>(x:T) => T;
 >x : T
 
 var r23 = dot(id)(id);
->r23 : (_: {}) => {}
->dot(id)(id) : (_: {}) => {}
+>r23 : <T>(_: T) => {}
+>dot(id)(id) : <T>(_: T) => {}
 >dot(id) : <U>(g: (_: U) => {}) => (_: U) => {}
 >dot : <T, S>(f: (_: T) => S) => <U>(g: (_: U) => T) => (_: U) => S
 >id : <T>(x: T) => T

tests/baselines/reference/genericFunctionInference1.types

@@ -33,14 +33,14 @@ declare function box<V>(x: V): { value: V };
 >value : V
 
 const f00 = pipe(list);
->f00 : (a: any) => any[]
->pipe(list) : (a: any) => any[]
+>f00 : <T>(a: T) => T[]
+>pipe(list) : <T>(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 f01 = pipe(list, box);
->f01 : (a: any) => { value: any[]; }
->pipe(list, box) : (a: any) => { value: any[]; }
+>f01 : <T>(a: T) => { value: T[]; }
+>pipe(list, box) : <T>(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; }
@@ -57,15 +57,15 @@ const f02 = pipe(x => list(x), box);
 >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[]; }
+>f03 : <T>(a: T) => { value: T[]; }
+>pipe(list, x => box(x)) : <T>(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: any[]) => { value: any[]; }
->x : any[]
->box(x) : { value: any[]; }
+>x => box(x) : (x: T[]) => { value: T[]; }
+>x : T[]
+>box(x) : { value: T[]; }
 >box : <V>(x: V) => { value: V; }
->x : any[]
+>x : T[]
 
 const f04 = pipe(x => list(x), x => box(x))
 >f04 : (x: any) => { value: any[]; }
@@ -83,11 +83,11 @@ const f04 = pipe(x => list(x), x => box(x))
 >x : any[]
 
 const f05 = pipe(list, pipe(box));
->f05 : (a: any) => { value: any[]; }
->pipe(list, pipe(box)) : (a: any) => { value: any[]; }
+>f05 : <T>(a: T) => { value: T[]; }
+>pipe(list, pipe(box)) : <T>(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: any[]) => { value: any[]; }
+>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; }
 

tests/baselines/reference/genericTypeParameterEquivalence2.types

@@ -129,8 +129,8 @@ function curry1<A, B, C>(f: (a: A, b: B) => C): (ax: A) => (bx: B) => C {
 }
 
 var cfilter = curry1(filter);
->cfilter : (ax: {}) => (bx: {}) => {}[]
->curry1(filter) : (ax: {}) => (bx: {}) => {}[]
+>cfilter : <A>(ax: (a: A) => boolean) => (bx: A[]) => A[]
+>curry1(filter) : <A>(ax: (a: A) => boolean) => (bx: A[]) => A[]
 >curry1 : <A, B, C>(f: (a: A, b: B) => C) => (ax: A) => (bx: B) => C
 >filter : <A>(f: (a: A) => boolean, ar: A[]) => A[]
 
@@ -149,11 +149,11 @@ function countWhere_1<A>(pred: (a: A) => boolean): (a: A[]) => number {
 >a : A[]
 
     return compose(length2, cfilter(pred));
->compose(length2, cfilter(pred)) : (a: {}) => number
+>compose(length2, cfilter(pred)) : (a: A[]) => number
 >compose : <A, B, C>(f: (b: B) => C, g: (a: A) => B) => (a: A) => C
 >length2 : <A>(ar: A[]) => number
->cfilter(pred) : (bx: {}) => {}[]
->cfilter : (ax: {}) => (bx: {}) => {}[]
+>cfilter(pred) : (bx: A[]) => A[]
+>cfilter : <A>(ax: (a: A) => boolean) => (bx: A[]) => A[]
 >pred : (a: A) => boolean
 }
 
@@ -164,14 +164,14 @@ function countWhere_2<A>(pred: (a: A) => boolean): (a: A[]) => number {
 >a : A[]
 
     var where = cfilter(pred);
->where : (bx: {}) => {}[]
->cfilter(pred) : (bx: {}) => {}[]
->cfilter : (ax: {}) => (bx: {}) => {}[]
+>where : (bx: A[]) => A[]
+>cfilter(pred) : (bx: A[]) => A[]
+>cfilter : <A>(ax: (a: A) => boolean) => (bx: A[]) => A[]
 >pred : (a: A) => boolean
 
     return compose(length2, where);
->compose(length2, where) : (a: {}) => number
+>compose(length2, where) : (a: A[]) => number
 >compose : <A, B, C>(f: (b: B) => C, g: (a: A) => B) => (a: A) => C
 >length2 : <A>(ar: A[]) => number
->where : (bx: {}) => {}[]
+>where : (bx: A[]) => A[]
 }