Update baselines.

Author: kpdonn

tests/baselines/reference/conditionalTypes1.js

@@ -499,10 +499,9 @@ declare type T15 = Extract<Options, {
 declare function f5<T extends Options, K extends string>(p: K): Extract<T, {
     k: K;
 }>;
-declare let x0: {
+declare let x0: Extract<T, {
     k: "a";
-    a: number;
-};
+}>;
 declare type OptionsOfKind<K extends Options["k"]> = Extract<Options, {
     k: K;
 }>;

tests/baselines/reference/conditionalTypes1.types

@@ -187,8 +187,8 @@ declare function f5<T extends Options, K extends string>(p: K): Extract<T, { k:
 >K : K
 
 let x0 = f5("a");  // { k: "a", a: number }
->x0 : { k: "a"; a: number; }
->f5("a") : { k: "a"; a: number; }
+>x0 : Extract<T, { k: "a"; }>
+>f5("a") : Extract<T, { k: "a"; }>
 >f5 : <T extends Options, K extends string>(p: K) => Extract<T, { k: K; }>
 >"a" : "a"
 

tests/baselines/reference/contextualTypingOfTooShortOverloads.types

@@ -7,9 +7,9 @@ var use: Overload;
 use((req, res) => {});
 >use((req, res) => {}) : void
 >use : Overload
->(req, res) => {} : (req: any, res: any) => void
->req : any
->res : any
+>(req, res) => {} : (req: number, res: number) => void
+>req : number
+>res : number
 
 interface Overload {
 >Overload : Overload
@@ -33,11 +33,11 @@ app.use((err: any, req, res, next) => { return; });
 >app.use : IRouterHandler<MyApp> & IRouterMatcher<MyApp>
 >app : MyApp
 >use : IRouterHandler<MyApp> & IRouterMatcher<MyApp>
->(err: any, req, res, next) => { return; } : (err: any, req: any, res: any, next: any) => void
+>(err: any, req, res, next) => { return; } : (err: any, req: Request, res: Response, next: NextFunction) => void
 >err : any
->req : any
->res : any
->next : any
+>req : Request
+>res : Response
+>next : NextFunction
 
 
 interface MyApp {

tests/baselines/reference/genericContextualTypes1.types

@@ -136,7 +136,7 @@ const f02: <A>(x: A) => A[] = wrap(list);
 >x : A
 >A : A
 >A : A
->wrap(list) : (a: A) => A[]
+>wrap(list) : <A>(a: A) => A[]
 >wrap : <A, B>(f: (a: A) => B) => (a: A) => B
 >list : <T>(a: T) => T[]
 
@@ -180,7 +180,7 @@ const f11: <T>(x: T) => Box<T[]> = compose(list, box);
 >T : T
 >Box : Box<T>
 >T : T
->compose(list, box) : (a: T) => Box<T[]>
+>compose(list, box) : <T>(a: T) => Box<T[]>
 >compose : <A, B, C>(f: (a: A) => B, g: (b: B) => C) => (a: A) => C
 >list : <T>(a: T) => T[]
 >box : <V>(x: V) => Box<V>
@@ -212,7 +212,7 @@ const f13: <T>(x: Box<T[]>) => T = compose(unbox, unlist);
 >Box : Box<T>
 >T : T
 >T : T
->compose(unbox, unlist) : (a: Box<T[]>) => T
+>compose(unbox, unlist) : <T>(a: Box<T[]>) => T
 >compose : <A, B, C>(f: (a: A) => B, g: (b: B) => C) => (a: A) => C
 >unbox : <W>(x: Box<W>) => W
 >unlist : <T>(a: T[]) => T
@@ -281,7 +281,7 @@ const f22: <A>(a: A[]) => A[] = arrayMap(identity);
 >a : A[]
 >A : A
 >A : A
->arrayMap(identity) : (a: A[]) => A[]
+>arrayMap(identity) : <A>(a: A[]) => A[]
 >arrayMap : <T, U>(f: (x: T) => U) => (a: T[]) => U[]
 >identity : <T>(x: T) => T
 
@@ -340,7 +340,7 @@ const f40: <A, B>(b: B, a: A) => [A, B] = flip(zip);
 >A : A
 >A : A
 >B : B
->flip(zip) : (y: B, x: A) => [A, B]
+>flip(zip) : <A, B>(y: B, x: A) => [A, B]
 >flip : <X, Y, Z>(f: (x: X, y: Y) => Z) => (y: Y, x: X) => Z
 >zip : <A, B>(a: A, b: B) => [A, B]
 

tests/baselines/reference/genericTypeParameterEquivalence2strict.errors.txt

@@ -161,8 +161,8 @@ function curry1<A, B, C>(f: (a: A, b: B) => C): (ax: A) => (bx: B) => C {
 }
 
 var cfilter = curry1(filter);
->cfilter : any
->curry1(filter) : any
+>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[]
 
@@ -171,26 +171,26 @@ declare function strBool(str: string): boolean
 >str : string
 
 const filterer = cfilter(strBool);
->filterer : any
->cfilter(strBool) : any
->cfilter : any
+>filterer : (bx: string[]) => string[]
+>cfilter(strBool) : (bx: string[]) => string[]
+>cfilter : <A>(ax: (a: A) => boolean) => (bx: A[]) => A[]
 >strBool : (str: string) => boolean
 
 const expectFilterer: (a: string[]) => string[] = filterer;
 >expectFilterer : (a: string[]) => string[]
 >a : string[]
->filterer : any
+>filterer : (bx: string[]) => string[]
 
 const filtered = filterer(["hello"]);
->filtered : any
->filterer(["hello"]) : any
->filterer : any
+>filtered : string[]
+>filterer(["hello"]) : string[]
+>filterer : (bx: string[]) => string[]
 >["hello"] : string[]
 >"hello" : "hello"
 
 const expectFiltered: string[] = filtered;
 >expectFiltered : string[]
->filtered : any
+>filtered : string[]
 
 // compose :: (b->c) -> (a->b) -> (a->c)
 // length :: [a] -> Num
@@ -210,11 +210,11 @@ function countWhere_1<A>(pred: (a: A) => boolean): (a: A[]) => number {
 >A : A
 
     return compose(length2, cfilter(pred));
->compose(length2, cfilter(pred)) : any
+>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) : any
->cfilter : any
+>cfilter(pred) : (bx: A[]) => A[]
+>cfilter : <A>(ax: (a: A) => boolean) => (bx: A[]) => A[]
 >pred : (a: A) => boolean
 }
 
@@ -228,14 +228,14 @@ function countWhere_2<A>(pred: (a: A) => boolean): (a: A[]) => number {
 >A : A
 
     var where = cfilter(pred);
->where : any
->cfilter(pred) : any
->cfilter : any
+>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) : any
+>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 : any
+>where : (bx: A[]) => A[]
 }

tests/baselines/reference/genericTypeParameterEquivalence2strict.types

@@ -94,7 +94,7 @@ type T12 = ReturnType<(<T>() => T)>;  // {}
 >T : T
 
 type T13 = ReturnType<(<T extends U, U extends number[]>() => T)>;  // number[]
->T13 : number[]
+>T13 : ReturnType<(<T extends U, U extends number[]>() => T)>
 >ReturnType : ReturnType<T>
 >T : T
 >U : U

tests/baselines/reference/inferTypes1.types

@@ -30,8 +30,8 @@ var zipWith: <T, S, U>(a: T[], b: S[], f: (x: T) => (y: S) => U) => U[];
 >U : U
 
 var result = zipWith([1, 2], ['a', 'b'], pair);
->result : { x: number; y: {}; }[]
->zipWith([1, 2], ['a', 'b'], pair) : { x: number; y: {}; }[]
+>result : { x: number; y: string; }[]
+>zipWith([1, 2], ['a', 'b'], pair) : { x: number; y: string; }[]
 >zipWith : <T, S, U>(a: T[], b: S[], f: (x: T) => (y: S) => U) => U[]
 >[1, 2] : number[]
 >1 : 1
@@ -44,8 +44,8 @@ var result = zipWith([1, 2], ['a', 'b'], pair);
 var i = result[0].x; // number
 >i : number
 >result[0].x : number
->result[0] : { x: number; y: {}; }
->result : { x: number; y: {}; }[]
+>result[0] : { x: number; y: string; }
+>result : { x: number; y: string; }[]
 >0 : 0
 >x : number