Accepting new baselines

tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.types

@@ -11,6 +11,7 @@ class C {
       var fn = async () => await other.apply(this, arguments);      
 >fn : () => Promise<any>
 >async () => await other.apply(this, arguments) : () => Promise<any>
+>await other.apply(this, arguments) : any
 >other.apply(this, arguments) : any
 >other.apply : (thisArg: any, argArray?: any) => any
 >other : () => void

tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.types

@@ -8,6 +8,7 @@ class C {
       var fn = async () => await this;      
 >fn : () => Promise<this>
 >async () => await this : () => Promise<this>
+>await this : this
 >this : this
    }
 }

tests/baselines/reference/awaitBinaryExpression1_es6.symbols

@@ -13,6 +13,7 @@ async function func(): Promise<void> {
     "before";
     var b = await p || a;
 >b : Symbol(b, Decl(awaitBinaryExpression1_es6.ts, 4, 7))
+>p : Symbol(p, Decl(awaitBinaryExpression1_es6.ts, 1, 11))
 >a : Symbol(a, Decl(awaitBinaryExpression1_es6.ts, 0, 11))
 
     "after";

tests/baselines/reference/awaitBinaryExpression1_es6.types

@@ -16,7 +16,8 @@ async function func(): Promise<void> {
     var b = await p || a;
 >b : boolean
 >await p || a : boolean
->p : any
+>await p : boolean
+>p : Promise<boolean>
 >a : boolean
 
     "after";

tests/baselines/reference/awaitBinaryExpression2_es6.symbols

@@ -13,6 +13,7 @@ async function func(): Promise<void> {
     "before";
     var b = await p && a;
 >b : Symbol(b, Decl(awaitBinaryExpression2_es6.ts, 4, 7))
+>p : Symbol(p, Decl(awaitBinaryExpression2_es6.ts, 1, 11))
 >a : Symbol(a, Decl(awaitBinaryExpression2_es6.ts, 0, 11))
 
     "after";

tests/baselines/reference/awaitBinaryExpression2_es6.types

@@ -16,7 +16,8 @@ async function func(): Promise<void> {
     var b = await p && a;
 >b : boolean
 >await p && a : boolean
->p : any
+>await p : boolean
+>p : Promise<boolean>
 >a : boolean
 
     "after";

tests/baselines/reference/awaitBinaryExpression3_es6.symbols

@@ -13,6 +13,7 @@ async function func(): Promise<void> {
     "before";
     var b = await p + a;
 >b : Symbol(b, Decl(awaitBinaryExpression3_es6.ts, 4, 7))
+>p : Symbol(p, Decl(awaitBinaryExpression3_es6.ts, 1, 11))
 >a : Symbol(a, Decl(awaitBinaryExpression3_es6.ts, 0, 11))
 
     "after";

tests/baselines/reference/awaitBinaryExpression3_es6.types

@@ -16,7 +16,8 @@ async function func(): Promise<void> {
     var b = await p + a;
 >b : number
 >await p + a : number
->p : any
+>await p : number
+>p : Promise<number>
 >a : number
 
     "after";

tests/baselines/reference/awaitBinaryExpression4_es6.symbols

@@ -13,6 +13,7 @@ async function func(): Promise<void> {
     "before";
     var b = await p, a;
 >b : Symbol(b, Decl(awaitBinaryExpression4_es6.ts, 4, 7))
+>p : Symbol(p, Decl(awaitBinaryExpression4_es6.ts, 1, 11))
 >a : Symbol(a, Decl(awaitBinaryExpression4_es6.ts, 4, 20))
 
     "after";

tests/baselines/reference/awaitBinaryExpression4_es6.types

@@ -15,7 +15,8 @@ async function func(): Promise<void> {
 
     var b = await p, a;
 >b : boolean
->p : any
+>await p : boolean
+>p : Promise<boolean>
 >a : any
 
     "after";

tests/baselines/reference/awaitBinaryExpression5_es6.symbols

@@ -19,6 +19,7 @@ async function func(): Promise<void> {
 >o.a : Symbol(a, Decl(awaitBinaryExpression5_es6.ts, 4, 12))
 >o : Symbol(o, Decl(awaitBinaryExpression5_es6.ts, 4, 7))
 >a : Symbol(a, Decl(awaitBinaryExpression5_es6.ts, 4, 12))
+>p : Symbol(p, Decl(awaitBinaryExpression5_es6.ts, 1, 11))
 
     "after";
 }

tests/baselines/reference/awaitBinaryExpression5_es6.types

@@ -22,7 +22,8 @@ async function func(): Promise<void> {
 >o.a : boolean
 >o : { a: boolean; }
 >a : boolean
->p : any
+>await p : boolean
+>p : Promise<boolean>
 
     "after";
 >"after" : string

tests/baselines/reference/awaitCallExpression2_es6.symbols

@@ -42,6 +42,7 @@ async function func(): Promise<void> {
     var b = fn(await p, a, a);
 >b : Symbol(b, Decl(awaitCallExpression2_es6.ts, 8, 7))
 >fn : Symbol(fn, Decl(awaitCallExpression2_es6.ts, 1, 32))
+>p : Symbol(p, Decl(awaitCallExpression2_es6.ts, 1, 11))
 >a : Symbol(a, Decl(awaitCallExpression2_es6.ts, 0, 11))
 >a : Symbol(a, Decl(awaitCallExpression2_es6.ts, 0, 11))
 

tests/baselines/reference/awaitCallExpression2_es6.types

@@ -45,7 +45,8 @@ async function func(): Promise<void> {
 >b : void
 >fn(await p, a, a) : void
 >fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
->p : any
+>await p : boolean
+>p : Promise<boolean>
 >a : boolean
 >a : boolean
 

tests/baselines/reference/awaitCallExpression3_es6.symbols

@@ -43,6 +43,7 @@ async function func(): Promise<void> {
 >b : Symbol(b, Decl(awaitCallExpression3_es6.ts, 8, 7))
 >fn : Symbol(fn, Decl(awaitCallExpression3_es6.ts, 1, 32))
 >a : Symbol(a, Decl(awaitCallExpression3_es6.ts, 0, 11))
+>p : Symbol(p, Decl(awaitCallExpression3_es6.ts, 1, 11))
 >a : Symbol(a, Decl(awaitCallExpression3_es6.ts, 0, 11))
 
     "after";

tests/baselines/reference/awaitCallExpression3_es6.types

@@ -46,7 +46,8 @@ async function func(): Promise<void> {
 >fn(a, await p, a) : void
 >fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
 >a : boolean
->p : any
+>await p : boolean
+>p : Promise<boolean>
 >a : boolean
 
     "after";

tests/baselines/reference/awaitCallExpression4_es6.symbols

@@ -41,6 +41,7 @@ async function func(): Promise<void> {
     "before";
     var b = (await pfn)(a, a, a);
 >b : Symbol(b, Decl(awaitCallExpression4_es6.ts, 8, 7))
+>pfn : Symbol(pfn, Decl(awaitCallExpression4_es6.ts, 4, 11))
 >a : Symbol(a, Decl(awaitCallExpression4_es6.ts, 0, 11))
 >a : Symbol(a, Decl(awaitCallExpression4_es6.ts, 0, 11))
 >a : Symbol(a, Decl(awaitCallExpression4_es6.ts, 0, 11))

tests/baselines/reference/awaitCallExpression4_es6.types

@@ -45,7 +45,8 @@ async function func(): Promise<void> {
 >b : void
 >(await pfn)(a, a, a) : void
 >(await pfn) : (arg0: boolean, arg1: boolean, arg2: boolean) => void
->pfn : any
+>await pfn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
+>pfn : Promise<(arg0: boolean, arg1: boolean, arg2: boolean) => void>
 >a : boolean
 >a : boolean
 >a : boolean

tests/baselines/reference/awaitCallExpression6_es6.symbols

@@ -44,6 +44,7 @@ async function func(): Promise<void> {
 >o.fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 3, 16))
 >o : Symbol(o, Decl(awaitCallExpression6_es6.ts, 3, 11))
 >fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 3, 16))
+>p : Symbol(p, Decl(awaitCallExpression6_es6.ts, 1, 11))
 >a : Symbol(a, Decl(awaitCallExpression6_es6.ts, 0, 11))
 >a : Symbol(a, Decl(awaitCallExpression6_es6.ts, 0, 11))
 

tests/baselines/reference/awaitCallExpression6_es6.types

@@ -47,7 +47,8 @@ async function func(): Promise<void> {
 >o.fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
 >o : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }
 >fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
->p : any
+>await p : boolean
+>p : Promise<boolean>
 >a : boolean
 >a : boolean
 

tests/baselines/reference/awaitCallExpression7_es6.symbols

@@ -45,6 +45,7 @@ async function func(): Promise<void> {
 >o : Symbol(o, Decl(awaitCallExpression7_es6.ts, 3, 11))
 >fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 3, 16))
 >a : Symbol(a, Decl(awaitCallExpression7_es6.ts, 0, 11))
+>p : Symbol(p, Decl(awaitCallExpression7_es6.ts, 1, 11))
 >a : Symbol(a, Decl(awaitCallExpression7_es6.ts, 0, 11))
 
     "after";

tests/baselines/reference/awaitCallExpression7_es6.types

@@ -48,7 +48,8 @@ async function func(): Promise<void> {
 >o : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }
 >fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
 >a : boolean
->p : any
+>await p : boolean
+>p : Promise<boolean>
 >a : boolean
 
     "after";

tests/baselines/reference/awaitCallExpression8_es6.symbols

@@ -42,6 +42,7 @@ async function func(): Promise<void> {
     var b = (await po).fn(a, a, a);
 >b : Symbol(b, Decl(awaitCallExpression8_es6.ts, 8, 7))
 >(await po).fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 5, 25))
+>po : Symbol(po, Decl(awaitCallExpression8_es6.ts, 5, 11))
 >fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 5, 25))
 >a : Symbol(a, Decl(awaitCallExpression8_es6.ts, 0, 11))
 >a : Symbol(a, Decl(awaitCallExpression8_es6.ts, 0, 11))

tests/baselines/reference/awaitCallExpression8_es6.types

@@ -46,7 +46,8 @@ async function func(): Promise<void> {
 >(await po).fn(a, a, a) : void
 >(await po).fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
 >(await po) : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }
->po : any
+>await po : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }
+>po : Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>
 >fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void
 >a : boolean
 >a : boolean

tests/baselines/reference/awaitUnion_es6.symbols

@@ -24,16 +24,21 @@ async function f() {
 
 	let await_a = await a;
 >await_a : Symbol(await_a, Decl(awaitUnion_es6.ts, 6, 4))
+>a : Symbol(a, Decl(awaitUnion_es6.ts, 0, 11))
 
 	let await_b = await b;
 >await_b : Symbol(await_b, Decl(awaitUnion_es6.ts, 7, 4))
+>b : Symbol(b, Decl(awaitUnion_es6.ts, 1, 11))
 
 	let await_c = await c;
 >await_c : Symbol(await_c, Decl(awaitUnion_es6.ts, 8, 4))
+>c : Symbol(c, Decl(awaitUnion_es6.ts, 2, 11))
 
 	let await_d = await d;
 >await_d : Symbol(await_d, Decl(awaitUnion_es6.ts, 9, 4))
+>d : Symbol(d, Decl(awaitUnion_es6.ts, 3, 11))
 
 	let await_e = await e; 
 >await_e : Symbol(await_e, Decl(awaitUnion_es6.ts, 10, 4))
+>e : Symbol(e, Decl(awaitUnion_es6.ts, 4, 11))
 }

tests/baselines/reference/awaitUnion_es6.types

@@ -24,21 +24,26 @@ async function f() {
 
 	let await_a = await a;
 >await_a : number | string
->a : any
+>await a : number | string
+>a : number | string
 
 	let await_b = await b;
 >await_b : number | string
->b : any
+>await b : number | string
+>b : PromiseLike<number> | PromiseLike<string>
 
 	let await_c = await c;
 >await_c : number | string
->c : any
+>await c : number | string
+>c : PromiseLike<number | string>
 
 	let await_d = await d;
 >await_d : number | string
->d : any
+>await d : number | string
+>d : number | PromiseLike<string>
 
 	let await_e = await e; 
 >await_e : number | string
->e : any
+>await e : number | string
+>e : number | PromiseLike<number | string>
 }