Accept new baselines

Author: ahejlsberg

tests/baselines/reference/contextualTypingWithGenericSignature.types

@@ -16,9 +16,9 @@ var f2: {
 };
 
 f2 = (x, y) => { return x }
->f2 = (x, y) => { return x } : (x: T, y: U) => T
+>f2 = (x, y) => { return x } : <T, U>(x: T, y: U) => T
 >f2 : <T, U>(x: T, y: U) => T
->(x, y) => { return x } : (x: T, y: U) => T
+>(x, y) => { return x } : <T, U>(x: T, y: U) => T
 >x : T
 >y : U
 >x : T

tests/baselines/reference/genericContextualTypes1.types

@@ -125,7 +125,7 @@ const f01: <A>(x: A) => A[] = x => [x];
 >x : A
 >A : A
 >A : A
->x => [x] : (x: A) => A[]
+>x => [x] : <A>(x: A) => A[]
 >x : A
 >[x] : A[]
 >x : A
@@ -356,7 +356,7 @@ type fn = <A>(a: A) => A;
 const fn: fn = a => a;
 >fn : fn
 >fn : fn
->a => a : (a: A) => A
+>a => a : <A>(a: A) => A
 >a : A
 >a : A
 

tests/baselines/reference/genericFunctionHasFreshTypeArgs.types

@@ -9,11 +9,11 @@ function f(p: <T>(x: T) => void) { };
 f(x => f(y => x = y));
 >f(x => f(y => x = y)) : void
 >f : (p: <T>(x: T) => void) => void
->x => f(y => x = y) : (x: T) => void
+>x => f(y => x = y) : <T>(x: T) => void
 >x : T
 >f(y => x = y) : void
 >f : (p: <T>(x: T) => void) => void
->y => x = y : (y: T) => T
+>y => x = y : <T>(y: T) => T
 >y : T
 >x = y : T
 >x : T

tests/baselines/reference/genericTypeAssertions3.types

@@ -6,8 +6,8 @@ var r = < <T>(x: T) => T > ((x) => { return null; }); // bug was 'could not find
 >x : T
 >T : T
 >T : T
->((x) => { return null; }) : (x: T) => any
->(x) => { return null; } : (x: T) => any
+>((x) => { return null; }) : <T>(x: T) => any
+>(x) => { return null; } : <T>(x: T) => any
 >x : T
 >null : null
 

tests/baselines/reference/implicitAnyGenericTypeInference.types

@@ -18,11 +18,11 @@ var c: Comparer<any>;
 >Comparer : Comparer<T>
 
 c = { compareTo: (x, y) => { return y; } };
->c = { compareTo: (x, y) => { return y; } } : { compareTo: (x: any, y: U) => U; }
+>c = { compareTo: (x, y) => { return y; } } : { compareTo: <U>(x: any, y: U) => U; }
 >c : Comparer<any>
->{ compareTo: (x, y) => { return y; } } : { compareTo: (x: any, y: U) => U; }
->compareTo : (x: any, y: U) => U
->(x, y) => { return y; } : (x: any, y: U) => U
+>{ compareTo: (x, y) => { return y; } } : { compareTo: <U>(x: any, y: U) => U; }
+>compareTo : <U>(x: any, y: U) => U
+>(x, y) => { return y; } : <U>(x: any, y: U) => U
 >x : any
 >y : U
 >y : U