From 0c647c3d1442f41269abbed9bd48c7bfcd698730 Mon Sep 17 00:00:00 2001 From: Ron Buckton Date: Mon, 27 Jun 2016 15:34:15 -0700 Subject: [PATCH] Added es5 conformance tests for awaiting a call --- .../reference/awaitCallExpression1_es5.js | 27 ++++++++ .../awaitCallExpression1_es5.symbols | 59 +++++++++++++++++ .../reference/awaitCallExpression1_es5.types | 62 +++++++++++++++++ .../reference/awaitCallExpression2_es5.js | 33 ++++++++++ .../awaitCallExpression2_es5.symbols | 59 +++++++++++++++++ .../reference/awaitCallExpression2_es5.types | 63 ++++++++++++++++++ .../reference/awaitCallExpression3_es5.js | 34 ++++++++++ .../awaitCallExpression3_es5.symbols | 59 +++++++++++++++++ .../reference/awaitCallExpression3_es5.types | 63 ++++++++++++++++++ .../reference/awaitCallExpression4_es5.js | 32 +++++++++ .../awaitCallExpression4_es5.symbols | 59 +++++++++++++++++ .../reference/awaitCallExpression4_es5.types | 64 ++++++++++++++++++ .../reference/awaitCallExpression5_es5.js | 27 ++++++++ .../awaitCallExpression5_es5.symbols | 61 +++++++++++++++++ .../reference/awaitCallExpression5_es5.types | 64 ++++++++++++++++++ .../reference/awaitCallExpression6_es5.js | 33 ++++++++++ .../awaitCallExpression6_es5.symbols | 61 +++++++++++++++++ .../reference/awaitCallExpression6_es5.types | 65 ++++++++++++++++++ .../reference/awaitCallExpression7_es5.js | 34 ++++++++++ .../awaitCallExpression7_es5.symbols | 61 +++++++++++++++++ .../reference/awaitCallExpression7_es5.types | 65 ++++++++++++++++++ .../reference/awaitCallExpression8_es5.js | 32 +++++++++ .../awaitCallExpression8_es5.symbols | 61 +++++++++++++++++ .../reference/awaitCallExpression8_es5.types | 66 +++++++++++++++++++ .../awaitCallExpression1_es5.ts | 16 +++++ .../awaitCallExpression2_es5.ts | 16 +++++ .../awaitCallExpression3_es5.ts | 16 +++++ .../awaitCallExpression4_es5.ts | 16 +++++ .../awaitCallExpression5_es5.ts | 16 +++++ .../awaitCallExpression6_es5.ts | 16 +++++ .../awaitCallExpression7_es5.ts | 16 +++++ .../awaitCallExpression8_es5.ts | 16 +++++ 32 files changed, 1372 insertions(+) create mode 100644 tests/baselines/reference/awaitCallExpression1_es5.js create mode 100644 tests/baselines/reference/awaitCallExpression1_es5.symbols create mode 100644 tests/baselines/reference/awaitCallExpression1_es5.types create mode 100644 tests/baselines/reference/awaitCallExpression2_es5.js create mode 100644 tests/baselines/reference/awaitCallExpression2_es5.symbols create mode 100644 tests/baselines/reference/awaitCallExpression2_es5.types create mode 100644 tests/baselines/reference/awaitCallExpression3_es5.js create mode 100644 tests/baselines/reference/awaitCallExpression3_es5.symbols create mode 100644 tests/baselines/reference/awaitCallExpression3_es5.types create mode 100644 tests/baselines/reference/awaitCallExpression4_es5.js create mode 100644 tests/baselines/reference/awaitCallExpression4_es5.symbols create mode 100644 tests/baselines/reference/awaitCallExpression4_es5.types create mode 100644 tests/baselines/reference/awaitCallExpression5_es5.js create mode 100644 tests/baselines/reference/awaitCallExpression5_es5.symbols create mode 100644 tests/baselines/reference/awaitCallExpression5_es5.types create mode 100644 tests/baselines/reference/awaitCallExpression6_es5.js create mode 100644 tests/baselines/reference/awaitCallExpression6_es5.symbols create mode 100644 tests/baselines/reference/awaitCallExpression6_es5.types create mode 100644 tests/baselines/reference/awaitCallExpression7_es5.js create mode 100644 tests/baselines/reference/awaitCallExpression7_es5.symbols create mode 100644 tests/baselines/reference/awaitCallExpression7_es5.types create mode 100644 tests/baselines/reference/awaitCallExpression8_es5.js create mode 100644 tests/baselines/reference/awaitCallExpression8_es5.symbols create mode 100644 tests/baselines/reference/awaitCallExpression8_es5.types create mode 100644 tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression1_es5.ts create mode 100644 tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression2_es5.ts create mode 100644 tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression3_es5.ts create mode 100644 tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression4_es5.ts create mode 100644 tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression5_es5.ts create mode 100644 tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression6_es5.ts create mode 100644 tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression7_es5.ts create mode 100644 tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression8_es5.ts diff --git a/tests/baselines/reference/awaitCallExpression1_es5.js b/tests/baselines/reference/awaitCallExpression1_es5.js new file mode 100644 index 00000000000..d1f1a5ea7b1 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression1_es5.js @@ -0,0 +1,27 @@ +//// [awaitCallExpression1_es5.ts] +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare function before(): void; +declare function after(): void; +async function func(): Promise { + before(); + var b = fn(a, a, a); + after(); +} + +//// [awaitCallExpression1_es5.js] +function func() { + return __awaiter(this, void 0, Promise, function () { + var b; + return __generator(function (_a) { + before(); + b = fn(a, a, a); + after(); + return [2 /*return*/]; + }); + }); +} diff --git a/tests/baselines/reference/awaitCallExpression1_es5.symbols b/tests/baselines/reference/awaitCallExpression1_es5.symbols new file mode 100644 index 00000000000..b172db760e3 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression1_es5.symbols @@ -0,0 +1,59 @@ +=== tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression1_es5.ts === +declare var a: boolean; +>a : Symbol(a, Decl(awaitCallExpression1_es5.ts, 0, 11)) + +declare var p: Promise; +>p : Symbol(p, Decl(awaitCallExpression1_es5.ts, 1, 11)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : Symbol(fn, Decl(awaitCallExpression1_es5.ts, 1, 32)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression1_es5.ts, 2, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression1_es5.ts, 2, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression1_es5.ts, 2, 49)) + +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +>o : Symbol(o, Decl(awaitCallExpression1_es5.ts, 3, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression1_es5.ts, 3, 16)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression1_es5.ts, 3, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression1_es5.ts, 3, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression1_es5.ts, 3, 49)) + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Symbol(pfn, Decl(awaitCallExpression1_es5.ts, 4, 11)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression1_es5.ts, 4, 28)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression1_es5.ts, 4, 42)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression1_es5.ts, 4, 57)) + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Symbol(po, Decl(awaitCallExpression1_es5.ts, 5, 11)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>fn : Symbol(fn, Decl(awaitCallExpression1_es5.ts, 5, 25)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression1_es5.ts, 5, 29)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression1_es5.ts, 5, 43)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression1_es5.ts, 5, 58)) + +declare function before(): void; +>before : Symbol(before, Decl(awaitCallExpression1_es5.ts, 5, 84)) + +declare function after(): void; +>after : Symbol(after, Decl(awaitCallExpression1_es5.ts, 6, 32)) + +async function func(): Promise { +>func : Symbol(func, Decl(awaitCallExpression1_es5.ts, 7, 31)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + before(); +>before : Symbol(before, Decl(awaitCallExpression1_es5.ts, 5, 84)) + + var b = fn(a, a, a); +>b : Symbol(b, Decl(awaitCallExpression1_es5.ts, 10, 7)) +>fn : Symbol(fn, Decl(awaitCallExpression1_es5.ts, 1, 32)) +>a : Symbol(a, Decl(awaitCallExpression1_es5.ts, 0, 11)) +>a : Symbol(a, Decl(awaitCallExpression1_es5.ts, 0, 11)) +>a : Symbol(a, Decl(awaitCallExpression1_es5.ts, 0, 11)) + + after(); +>after : Symbol(after, Decl(awaitCallExpression1_es5.ts, 6, 32)) +} diff --git a/tests/baselines/reference/awaitCallExpression1_es5.types b/tests/baselines/reference/awaitCallExpression1_es5.types new file mode 100644 index 00000000000..8e712443cab --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression1_es5.types @@ -0,0 +1,62 @@ +=== tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression1_es5.ts === +declare var a: boolean; +>a : boolean + +declare var p: Promise; +>p : Promise +>Promise : Promise + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var 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 +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Promise<(arg0: boolean, arg1: boolean, arg2: boolean) => void> +>Promise : Promise +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }> +>Promise : Promise +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare function before(): void; +>before : () => void + +declare function after(): void; +>after : () => void + +async function func(): Promise { +>func : () => Promise +>Promise : Promise + + before(); +>before() : void +>before : () => void + + var b = fn(a, a, a); +>b : void +>fn(a, a, a) : void +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>a : boolean +>a : boolean +>a : boolean + + after(); +>after() : void +>after : () => void +} diff --git a/tests/baselines/reference/awaitCallExpression2_es5.js b/tests/baselines/reference/awaitCallExpression2_es5.js new file mode 100644 index 00000000000..399dead0084 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression2_es5.js @@ -0,0 +1,33 @@ +//// [awaitCallExpression2_es5.ts] +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare function before(): void; +declare function after(): void; +async function func(): Promise { + before(); + var b = fn(await p, a, a); + after(); +} + +//// [awaitCallExpression2_es5.js] +function func() { + return __awaiter(this, void 0, Promise, function () { + var b, _a, _b; + return __generator(function (_c) { + switch (_c.label) { + case 0: + before(); + _a = fn; + return [4 /*yield*/, p]; + case 1: + b = _a.apply(void 0, [_c.sent(), a, a]); + after(); + return [2 /*return*/]; + } + }); + }); +} diff --git a/tests/baselines/reference/awaitCallExpression2_es5.symbols b/tests/baselines/reference/awaitCallExpression2_es5.symbols new file mode 100644 index 00000000000..95e1f650030 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression2_es5.symbols @@ -0,0 +1,59 @@ +=== tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression2_es5.ts === +declare var a: boolean; +>a : Symbol(a, Decl(awaitCallExpression2_es5.ts, 0, 11)) + +declare var p: Promise; +>p : Symbol(p, Decl(awaitCallExpression2_es5.ts, 1, 11)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : Symbol(fn, Decl(awaitCallExpression2_es5.ts, 1, 32)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression2_es5.ts, 2, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression2_es5.ts, 2, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression2_es5.ts, 2, 49)) + +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +>o : Symbol(o, Decl(awaitCallExpression2_es5.ts, 3, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression2_es5.ts, 3, 16)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression2_es5.ts, 3, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression2_es5.ts, 3, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression2_es5.ts, 3, 49)) + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Symbol(pfn, Decl(awaitCallExpression2_es5.ts, 4, 11)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression2_es5.ts, 4, 28)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression2_es5.ts, 4, 42)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression2_es5.ts, 4, 57)) + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Symbol(po, Decl(awaitCallExpression2_es5.ts, 5, 11)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>fn : Symbol(fn, Decl(awaitCallExpression2_es5.ts, 5, 25)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression2_es5.ts, 5, 29)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression2_es5.ts, 5, 43)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression2_es5.ts, 5, 58)) + +declare function before(): void; +>before : Symbol(before, Decl(awaitCallExpression2_es5.ts, 5, 84)) + +declare function after(): void; +>after : Symbol(after, Decl(awaitCallExpression2_es5.ts, 6, 32)) + +async function func(): Promise { +>func : Symbol(func, Decl(awaitCallExpression2_es5.ts, 7, 31)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + before(); +>before : Symbol(before, Decl(awaitCallExpression2_es5.ts, 5, 84)) + + var b = fn(await p, a, a); +>b : Symbol(b, Decl(awaitCallExpression2_es5.ts, 10, 7)) +>fn : Symbol(fn, Decl(awaitCallExpression2_es5.ts, 1, 32)) +>p : Symbol(p, Decl(awaitCallExpression2_es5.ts, 1, 11)) +>a : Symbol(a, Decl(awaitCallExpression2_es5.ts, 0, 11)) +>a : Symbol(a, Decl(awaitCallExpression2_es5.ts, 0, 11)) + + after(); +>after : Symbol(after, Decl(awaitCallExpression2_es5.ts, 6, 32)) +} diff --git a/tests/baselines/reference/awaitCallExpression2_es5.types b/tests/baselines/reference/awaitCallExpression2_es5.types new file mode 100644 index 00000000000..5fd85ce3921 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression2_es5.types @@ -0,0 +1,63 @@ +=== tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression2_es5.ts === +declare var a: boolean; +>a : boolean + +declare var p: Promise; +>p : Promise +>Promise : Promise + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var 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 +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Promise<(arg0: boolean, arg1: boolean, arg2: boolean) => void> +>Promise : Promise +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }> +>Promise : Promise +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare function before(): void; +>before : () => void + +declare function after(): void; +>after : () => void + +async function func(): Promise { +>func : () => Promise +>Promise : Promise + + before(); +>before() : void +>before : () => void + + var b = fn(await p, a, a); +>b : void +>fn(await p, a, a) : void +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>await p : boolean +>p : Promise +>a : boolean +>a : boolean + + after(); +>after() : void +>after : () => void +} diff --git a/tests/baselines/reference/awaitCallExpression3_es5.js b/tests/baselines/reference/awaitCallExpression3_es5.js new file mode 100644 index 00000000000..5b14075a373 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression3_es5.js @@ -0,0 +1,34 @@ +//// [awaitCallExpression3_es5.ts] +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare function before(): void; +declare function after(): void; +async function func(): Promise { + before(); + var b = fn(a, await p, a); + after(); +} + +//// [awaitCallExpression3_es5.js] +function func() { + return __awaiter(this, void 0, Promise, function () { + var b, _a, _b; + return __generator(function (_c) { + switch (_c.label) { + case 0: + before(); + _a = fn; + _b = [a]; + return [4 /*yield*/, p]; + case 1: + b = _a.apply(void 0, _b.concat([_c.sent(), a])); + after(); + return [2 /*return*/]; + } + }); + }); +} diff --git a/tests/baselines/reference/awaitCallExpression3_es5.symbols b/tests/baselines/reference/awaitCallExpression3_es5.symbols new file mode 100644 index 00000000000..2c18507340a --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression3_es5.symbols @@ -0,0 +1,59 @@ +=== tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression3_es5.ts === +declare var a: boolean; +>a : Symbol(a, Decl(awaitCallExpression3_es5.ts, 0, 11)) + +declare var p: Promise; +>p : Symbol(p, Decl(awaitCallExpression3_es5.ts, 1, 11)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : Symbol(fn, Decl(awaitCallExpression3_es5.ts, 1, 32)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression3_es5.ts, 2, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression3_es5.ts, 2, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression3_es5.ts, 2, 49)) + +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +>o : Symbol(o, Decl(awaitCallExpression3_es5.ts, 3, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression3_es5.ts, 3, 16)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression3_es5.ts, 3, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression3_es5.ts, 3, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression3_es5.ts, 3, 49)) + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Symbol(pfn, Decl(awaitCallExpression3_es5.ts, 4, 11)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression3_es5.ts, 4, 28)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression3_es5.ts, 4, 42)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression3_es5.ts, 4, 57)) + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Symbol(po, Decl(awaitCallExpression3_es5.ts, 5, 11)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>fn : Symbol(fn, Decl(awaitCallExpression3_es5.ts, 5, 25)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression3_es5.ts, 5, 29)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression3_es5.ts, 5, 43)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression3_es5.ts, 5, 58)) + +declare function before(): void; +>before : Symbol(before, Decl(awaitCallExpression3_es5.ts, 5, 84)) + +declare function after(): void; +>after : Symbol(after, Decl(awaitCallExpression3_es5.ts, 6, 32)) + +async function func(): Promise { +>func : Symbol(func, Decl(awaitCallExpression3_es5.ts, 7, 31)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + before(); +>before : Symbol(before, Decl(awaitCallExpression3_es5.ts, 5, 84)) + + var b = fn(a, await p, a); +>b : Symbol(b, Decl(awaitCallExpression3_es5.ts, 10, 7)) +>fn : Symbol(fn, Decl(awaitCallExpression3_es5.ts, 1, 32)) +>a : Symbol(a, Decl(awaitCallExpression3_es5.ts, 0, 11)) +>p : Symbol(p, Decl(awaitCallExpression3_es5.ts, 1, 11)) +>a : Symbol(a, Decl(awaitCallExpression3_es5.ts, 0, 11)) + + after(); +>after : Symbol(after, Decl(awaitCallExpression3_es5.ts, 6, 32)) +} diff --git a/tests/baselines/reference/awaitCallExpression3_es5.types b/tests/baselines/reference/awaitCallExpression3_es5.types new file mode 100644 index 00000000000..d2d851c1dae --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression3_es5.types @@ -0,0 +1,63 @@ +=== tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression3_es5.ts === +declare var a: boolean; +>a : boolean + +declare var p: Promise; +>p : Promise +>Promise : Promise + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var 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 +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Promise<(arg0: boolean, arg1: boolean, arg2: boolean) => void> +>Promise : Promise +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }> +>Promise : Promise +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare function before(): void; +>before : () => void + +declare function after(): void; +>after : () => void + +async function func(): Promise { +>func : () => Promise +>Promise : Promise + + before(); +>before() : void +>before : () => void + + var b = fn(a, await p, a); +>b : void +>fn(a, await p, a) : void +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>a : boolean +>await p : boolean +>p : Promise +>a : boolean + + after(); +>after() : void +>after : () => void +} diff --git a/tests/baselines/reference/awaitCallExpression4_es5.js b/tests/baselines/reference/awaitCallExpression4_es5.js new file mode 100644 index 00000000000..8202598b828 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression4_es5.js @@ -0,0 +1,32 @@ +//// [awaitCallExpression4_es5.ts] +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare function before(): void; +declare function after(): void; +async function func(): Promise { + before(); + var b = (await pfn)(a, a, a); + after(); +} + +//// [awaitCallExpression4_es5.js] +function func() { + return __awaiter(this, void 0, Promise, function () { + var b; + return __generator(function (_a) { + switch (_a.label) { + case 0: + before(); + return [4 /*yield*/, pfn]; + case 1: + b = (_a.sent())(a, a, a); + after(); + return [2 /*return*/]; + } + }); + }); +} diff --git a/tests/baselines/reference/awaitCallExpression4_es5.symbols b/tests/baselines/reference/awaitCallExpression4_es5.symbols new file mode 100644 index 00000000000..46a5b942956 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression4_es5.symbols @@ -0,0 +1,59 @@ +=== tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression4_es5.ts === +declare var a: boolean; +>a : Symbol(a, Decl(awaitCallExpression4_es5.ts, 0, 11)) + +declare var p: Promise; +>p : Symbol(p, Decl(awaitCallExpression4_es5.ts, 1, 11)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : Symbol(fn, Decl(awaitCallExpression4_es5.ts, 1, 32)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression4_es5.ts, 2, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression4_es5.ts, 2, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression4_es5.ts, 2, 49)) + +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +>o : Symbol(o, Decl(awaitCallExpression4_es5.ts, 3, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression4_es5.ts, 3, 16)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression4_es5.ts, 3, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression4_es5.ts, 3, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression4_es5.ts, 3, 49)) + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Symbol(pfn, Decl(awaitCallExpression4_es5.ts, 4, 11)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression4_es5.ts, 4, 28)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression4_es5.ts, 4, 42)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression4_es5.ts, 4, 57)) + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Symbol(po, Decl(awaitCallExpression4_es5.ts, 5, 11)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>fn : Symbol(fn, Decl(awaitCallExpression4_es5.ts, 5, 25)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression4_es5.ts, 5, 29)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression4_es5.ts, 5, 43)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression4_es5.ts, 5, 58)) + +declare function before(): void; +>before : Symbol(before, Decl(awaitCallExpression4_es5.ts, 5, 84)) + +declare function after(): void; +>after : Symbol(after, Decl(awaitCallExpression4_es5.ts, 6, 32)) + +async function func(): Promise { +>func : Symbol(func, Decl(awaitCallExpression4_es5.ts, 7, 31)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + before(); +>before : Symbol(before, Decl(awaitCallExpression4_es5.ts, 5, 84)) + + var b = (await pfn)(a, a, a); +>b : Symbol(b, Decl(awaitCallExpression4_es5.ts, 10, 7)) +>pfn : Symbol(pfn, Decl(awaitCallExpression4_es5.ts, 4, 11)) +>a : Symbol(a, Decl(awaitCallExpression4_es5.ts, 0, 11)) +>a : Symbol(a, Decl(awaitCallExpression4_es5.ts, 0, 11)) +>a : Symbol(a, Decl(awaitCallExpression4_es5.ts, 0, 11)) + + after(); +>after : Symbol(after, Decl(awaitCallExpression4_es5.ts, 6, 32)) +} diff --git a/tests/baselines/reference/awaitCallExpression4_es5.types b/tests/baselines/reference/awaitCallExpression4_es5.types new file mode 100644 index 00000000000..0b510c46998 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression4_es5.types @@ -0,0 +1,64 @@ +=== tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression4_es5.ts === +declare var a: boolean; +>a : boolean + +declare var p: Promise; +>p : Promise +>Promise : Promise + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var 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 +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Promise<(arg0: boolean, arg1: boolean, arg2: boolean) => void> +>Promise : Promise +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }> +>Promise : Promise +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare function before(): void; +>before : () => void + +declare function after(): void; +>after : () => void + +async function func(): Promise { +>func : () => Promise +>Promise : Promise + + before(); +>before() : void +>before : () => void + + var b = (await pfn)(a, a, a); +>b : void +>(await pfn)(a, a, a) : void +>(await pfn) : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>await pfn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>pfn : Promise<(arg0: boolean, arg1: boolean, arg2: boolean) => void> +>a : boolean +>a : boolean +>a : boolean + + after(); +>after() : void +>after : () => void +} diff --git a/tests/baselines/reference/awaitCallExpression5_es5.js b/tests/baselines/reference/awaitCallExpression5_es5.js new file mode 100644 index 00000000000..387dabc1df3 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression5_es5.js @@ -0,0 +1,27 @@ +//// [awaitCallExpression5_es5.ts] +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare function before(): void; +declare function after(): void; +async function func(): Promise { + before(); + var b = o.fn(a, a, a); + after(); +} + +//// [awaitCallExpression5_es5.js] +function func() { + return __awaiter(this, void 0, Promise, function () { + var b; + return __generator(function (_a) { + before(); + b = o.fn(a, a, a); + after(); + return [2 /*return*/]; + }); + }); +} diff --git a/tests/baselines/reference/awaitCallExpression5_es5.symbols b/tests/baselines/reference/awaitCallExpression5_es5.symbols new file mode 100644 index 00000000000..9f34c3e9fe8 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression5_es5.symbols @@ -0,0 +1,61 @@ +=== tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression5_es5.ts === +declare var a: boolean; +>a : Symbol(a, Decl(awaitCallExpression5_es5.ts, 0, 11)) + +declare var p: Promise; +>p : Symbol(p, Decl(awaitCallExpression5_es5.ts, 1, 11)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : Symbol(fn, Decl(awaitCallExpression5_es5.ts, 1, 32)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression5_es5.ts, 2, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression5_es5.ts, 2, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression5_es5.ts, 2, 49)) + +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +>o : Symbol(o, Decl(awaitCallExpression5_es5.ts, 3, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression5_es5.ts, 3, 16)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression5_es5.ts, 3, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression5_es5.ts, 3, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression5_es5.ts, 3, 49)) + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Symbol(pfn, Decl(awaitCallExpression5_es5.ts, 4, 11)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression5_es5.ts, 4, 28)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression5_es5.ts, 4, 42)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression5_es5.ts, 4, 57)) + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Symbol(po, Decl(awaitCallExpression5_es5.ts, 5, 11)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>fn : Symbol(fn, Decl(awaitCallExpression5_es5.ts, 5, 25)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression5_es5.ts, 5, 29)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression5_es5.ts, 5, 43)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression5_es5.ts, 5, 58)) + +declare function before(): void; +>before : Symbol(before, Decl(awaitCallExpression5_es5.ts, 5, 84)) + +declare function after(): void; +>after : Symbol(after, Decl(awaitCallExpression5_es5.ts, 6, 32)) + +async function func(): Promise { +>func : Symbol(func, Decl(awaitCallExpression5_es5.ts, 7, 31)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + before(); +>before : Symbol(before, Decl(awaitCallExpression5_es5.ts, 5, 84)) + + var b = o.fn(a, a, a); +>b : Symbol(b, Decl(awaitCallExpression5_es5.ts, 10, 7)) +>o.fn : Symbol(fn, Decl(awaitCallExpression5_es5.ts, 3, 16)) +>o : Symbol(o, Decl(awaitCallExpression5_es5.ts, 3, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression5_es5.ts, 3, 16)) +>a : Symbol(a, Decl(awaitCallExpression5_es5.ts, 0, 11)) +>a : Symbol(a, Decl(awaitCallExpression5_es5.ts, 0, 11)) +>a : Symbol(a, Decl(awaitCallExpression5_es5.ts, 0, 11)) + + after(); +>after : Symbol(after, Decl(awaitCallExpression5_es5.ts, 6, 32)) +} diff --git a/tests/baselines/reference/awaitCallExpression5_es5.types b/tests/baselines/reference/awaitCallExpression5_es5.types new file mode 100644 index 00000000000..b4b6d947275 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression5_es5.types @@ -0,0 +1,64 @@ +=== tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression5_es5.ts === +declare var a: boolean; +>a : boolean + +declare var p: Promise; +>p : Promise +>Promise : Promise + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var 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 +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Promise<(arg0: boolean, arg1: boolean, arg2: boolean) => void> +>Promise : Promise +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }> +>Promise : Promise +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare function before(): void; +>before : () => void + +declare function after(): void; +>after : () => void + +async function func(): Promise { +>func : () => Promise +>Promise : Promise + + before(); +>before() : void +>before : () => void + + var b = o.fn(a, a, a); +>b : void +>o.fn(a, a, a) : 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 +>a : boolean +>a : boolean +>a : boolean + + after(); +>after() : void +>after : () => void +} diff --git a/tests/baselines/reference/awaitCallExpression6_es5.js b/tests/baselines/reference/awaitCallExpression6_es5.js new file mode 100644 index 00000000000..3c2910135e7 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression6_es5.js @@ -0,0 +1,33 @@ +//// [awaitCallExpression6_es5.ts] +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare function before(): void; +declare function after(): void; +async function func(): Promise { + before(); + var b = o.fn(await p, a, a); + after(); +} + +//// [awaitCallExpression6_es5.js] +function func() { + return __awaiter(this, void 0, Promise, function () { + var b, _a, _b, _c; + return __generator(function (_d) { + switch (_d.label) { + case 0: + before(); + _b = (_a = o).fn; + return [4 /*yield*/, p]; + case 1: + b = _b.apply(_a, [_d.sent(), a, a]); + after(); + return [2 /*return*/]; + } + }); + }); +} diff --git a/tests/baselines/reference/awaitCallExpression6_es5.symbols b/tests/baselines/reference/awaitCallExpression6_es5.symbols new file mode 100644 index 00000000000..fc3ae4cbdbb --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression6_es5.symbols @@ -0,0 +1,61 @@ +=== tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression6_es5.ts === +declare var a: boolean; +>a : Symbol(a, Decl(awaitCallExpression6_es5.ts, 0, 11)) + +declare var p: Promise; +>p : Symbol(p, Decl(awaitCallExpression6_es5.ts, 1, 11)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : Symbol(fn, Decl(awaitCallExpression6_es5.ts, 1, 32)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression6_es5.ts, 2, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression6_es5.ts, 2, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression6_es5.ts, 2, 49)) + +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +>o : Symbol(o, Decl(awaitCallExpression6_es5.ts, 3, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression6_es5.ts, 3, 16)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression6_es5.ts, 3, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression6_es5.ts, 3, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression6_es5.ts, 3, 49)) + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Symbol(pfn, Decl(awaitCallExpression6_es5.ts, 4, 11)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression6_es5.ts, 4, 28)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression6_es5.ts, 4, 42)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression6_es5.ts, 4, 57)) + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Symbol(po, Decl(awaitCallExpression6_es5.ts, 5, 11)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>fn : Symbol(fn, Decl(awaitCallExpression6_es5.ts, 5, 25)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression6_es5.ts, 5, 29)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression6_es5.ts, 5, 43)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression6_es5.ts, 5, 58)) + +declare function before(): void; +>before : Symbol(before, Decl(awaitCallExpression6_es5.ts, 5, 84)) + +declare function after(): void; +>after : Symbol(after, Decl(awaitCallExpression6_es5.ts, 6, 32)) + +async function func(): Promise { +>func : Symbol(func, Decl(awaitCallExpression6_es5.ts, 7, 31)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + before(); +>before : Symbol(before, Decl(awaitCallExpression6_es5.ts, 5, 84)) + + var b = o.fn(await p, a, a); +>b : Symbol(b, Decl(awaitCallExpression6_es5.ts, 10, 7)) +>o.fn : Symbol(fn, Decl(awaitCallExpression6_es5.ts, 3, 16)) +>o : Symbol(o, Decl(awaitCallExpression6_es5.ts, 3, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression6_es5.ts, 3, 16)) +>p : Symbol(p, Decl(awaitCallExpression6_es5.ts, 1, 11)) +>a : Symbol(a, Decl(awaitCallExpression6_es5.ts, 0, 11)) +>a : Symbol(a, Decl(awaitCallExpression6_es5.ts, 0, 11)) + + after(); +>after : Symbol(after, Decl(awaitCallExpression6_es5.ts, 6, 32)) +} diff --git a/tests/baselines/reference/awaitCallExpression6_es5.types b/tests/baselines/reference/awaitCallExpression6_es5.types new file mode 100644 index 00000000000..e34839f3c15 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression6_es5.types @@ -0,0 +1,65 @@ +=== tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression6_es5.ts === +declare var a: boolean; +>a : boolean + +declare var p: Promise; +>p : Promise +>Promise : Promise + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var 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 +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Promise<(arg0: boolean, arg1: boolean, arg2: boolean) => void> +>Promise : Promise +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }> +>Promise : Promise +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare function before(): void; +>before : () => void + +declare function after(): void; +>after : () => void + +async function func(): Promise { +>func : () => Promise +>Promise : Promise + + before(); +>before() : void +>before : () => void + + var b = o.fn(await p, a, a); +>b : void +>o.fn(await p, a, a) : 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 +>await p : boolean +>p : Promise +>a : boolean +>a : boolean + + after(); +>after() : void +>after : () => void +} diff --git a/tests/baselines/reference/awaitCallExpression7_es5.js b/tests/baselines/reference/awaitCallExpression7_es5.js new file mode 100644 index 00000000000..0f3056e48fa --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression7_es5.js @@ -0,0 +1,34 @@ +//// [awaitCallExpression7_es5.ts] +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare function before(): void; +declare function after(): void; +async function func(): Promise { + before(); + var b = o.fn(a, await p, a); + after(); +} + +//// [awaitCallExpression7_es5.js] +function func() { + return __awaiter(this, void 0, Promise, function () { + var b, _a, _b, _c; + return __generator(function (_d) { + switch (_d.label) { + case 0: + before(); + _b = (_a = o).fn; + _c = [a]; + return [4 /*yield*/, p]; + case 1: + b = _b.apply(_a, _c.concat([_d.sent(), a])); + after(); + return [2 /*return*/]; + } + }); + }); +} diff --git a/tests/baselines/reference/awaitCallExpression7_es5.symbols b/tests/baselines/reference/awaitCallExpression7_es5.symbols new file mode 100644 index 00000000000..96a7252ef04 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression7_es5.symbols @@ -0,0 +1,61 @@ +=== tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression7_es5.ts === +declare var a: boolean; +>a : Symbol(a, Decl(awaitCallExpression7_es5.ts, 0, 11)) + +declare var p: Promise; +>p : Symbol(p, Decl(awaitCallExpression7_es5.ts, 1, 11)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : Symbol(fn, Decl(awaitCallExpression7_es5.ts, 1, 32)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression7_es5.ts, 2, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression7_es5.ts, 2, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression7_es5.ts, 2, 49)) + +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +>o : Symbol(o, Decl(awaitCallExpression7_es5.ts, 3, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression7_es5.ts, 3, 16)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression7_es5.ts, 3, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression7_es5.ts, 3, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression7_es5.ts, 3, 49)) + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Symbol(pfn, Decl(awaitCallExpression7_es5.ts, 4, 11)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression7_es5.ts, 4, 28)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression7_es5.ts, 4, 42)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression7_es5.ts, 4, 57)) + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Symbol(po, Decl(awaitCallExpression7_es5.ts, 5, 11)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>fn : Symbol(fn, Decl(awaitCallExpression7_es5.ts, 5, 25)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression7_es5.ts, 5, 29)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression7_es5.ts, 5, 43)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression7_es5.ts, 5, 58)) + +declare function before(): void; +>before : Symbol(before, Decl(awaitCallExpression7_es5.ts, 5, 84)) + +declare function after(): void; +>after : Symbol(after, Decl(awaitCallExpression7_es5.ts, 6, 32)) + +async function func(): Promise { +>func : Symbol(func, Decl(awaitCallExpression7_es5.ts, 7, 31)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + before(); +>before : Symbol(before, Decl(awaitCallExpression7_es5.ts, 5, 84)) + + var b = o.fn(a, await p, a); +>b : Symbol(b, Decl(awaitCallExpression7_es5.ts, 10, 7)) +>o.fn : Symbol(fn, Decl(awaitCallExpression7_es5.ts, 3, 16)) +>o : Symbol(o, Decl(awaitCallExpression7_es5.ts, 3, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression7_es5.ts, 3, 16)) +>a : Symbol(a, Decl(awaitCallExpression7_es5.ts, 0, 11)) +>p : Symbol(p, Decl(awaitCallExpression7_es5.ts, 1, 11)) +>a : Symbol(a, Decl(awaitCallExpression7_es5.ts, 0, 11)) + + after(); +>after : Symbol(after, Decl(awaitCallExpression7_es5.ts, 6, 32)) +} diff --git a/tests/baselines/reference/awaitCallExpression7_es5.types b/tests/baselines/reference/awaitCallExpression7_es5.types new file mode 100644 index 00000000000..9d220c6c8b8 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression7_es5.types @@ -0,0 +1,65 @@ +=== tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression7_es5.ts === +declare var a: boolean; +>a : boolean + +declare var p: Promise; +>p : Promise +>Promise : Promise + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var 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 +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Promise<(arg0: boolean, arg1: boolean, arg2: boolean) => void> +>Promise : Promise +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }> +>Promise : Promise +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare function before(): void; +>before : () => void + +declare function after(): void; +>after : () => void + +async function func(): Promise { +>func : () => Promise +>Promise : Promise + + before(); +>before() : void +>before : () => void + + var b = o.fn(a, await p, a); +>b : void +>o.fn(a, await p, a) : 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 +>a : boolean +>await p : boolean +>p : Promise +>a : boolean + + after(); +>after() : void +>after : () => void +} diff --git a/tests/baselines/reference/awaitCallExpression8_es5.js b/tests/baselines/reference/awaitCallExpression8_es5.js new file mode 100644 index 00000000000..bcb7a7f8d7b --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression8_es5.js @@ -0,0 +1,32 @@ +//// [awaitCallExpression8_es5.ts] +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare function before(): void; +declare function after(): void; +async function func(): Promise { + before(); + var b = (await po).fn(a, a, a); + after(); +} + +//// [awaitCallExpression8_es5.js] +function func() { + return __awaiter(this, void 0, Promise, function () { + var b; + return __generator(function (_a) { + switch (_a.label) { + case 0: + before(); + return [4 /*yield*/, po]; + case 1: + b = (_a.sent()).fn(a, a, a); + after(); + return [2 /*return*/]; + } + }); + }); +} diff --git a/tests/baselines/reference/awaitCallExpression8_es5.symbols b/tests/baselines/reference/awaitCallExpression8_es5.symbols new file mode 100644 index 00000000000..50b564481b9 --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression8_es5.symbols @@ -0,0 +1,61 @@ +=== tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression8_es5.ts === +declare var a: boolean; +>a : Symbol(a, Decl(awaitCallExpression8_es5.ts, 0, 11)) + +declare var p: Promise; +>p : Symbol(p, Decl(awaitCallExpression8_es5.ts, 1, 11)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : Symbol(fn, Decl(awaitCallExpression8_es5.ts, 1, 32)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression8_es5.ts, 2, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression8_es5.ts, 2, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression8_es5.ts, 2, 49)) + +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +>o : Symbol(o, Decl(awaitCallExpression8_es5.ts, 3, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression8_es5.ts, 3, 16)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression8_es5.ts, 3, 20)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression8_es5.ts, 3, 34)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression8_es5.ts, 3, 49)) + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Symbol(pfn, Decl(awaitCallExpression8_es5.ts, 4, 11)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression8_es5.ts, 4, 28)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression8_es5.ts, 4, 42)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression8_es5.ts, 4, 57)) + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Symbol(po, Decl(awaitCallExpression8_es5.ts, 5, 11)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>fn : Symbol(fn, Decl(awaitCallExpression8_es5.ts, 5, 25)) +>arg0 : Symbol(arg0, Decl(awaitCallExpression8_es5.ts, 5, 29)) +>arg1 : Symbol(arg1, Decl(awaitCallExpression8_es5.ts, 5, 43)) +>arg2 : Symbol(arg2, Decl(awaitCallExpression8_es5.ts, 5, 58)) + +declare function before(): void; +>before : Symbol(before, Decl(awaitCallExpression8_es5.ts, 5, 84)) + +declare function after(): void; +>after : Symbol(after, Decl(awaitCallExpression8_es5.ts, 6, 32)) + +async function func(): Promise { +>func : Symbol(func, Decl(awaitCallExpression8_es5.ts, 7, 31)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + before(); +>before : Symbol(before, Decl(awaitCallExpression8_es5.ts, 5, 84)) + + var b = (await po).fn(a, a, a); +>b : Symbol(b, Decl(awaitCallExpression8_es5.ts, 10, 7)) +>(await po).fn : Symbol(fn, Decl(awaitCallExpression8_es5.ts, 5, 25)) +>po : Symbol(po, Decl(awaitCallExpression8_es5.ts, 5, 11)) +>fn : Symbol(fn, Decl(awaitCallExpression8_es5.ts, 5, 25)) +>a : Symbol(a, Decl(awaitCallExpression8_es5.ts, 0, 11)) +>a : Symbol(a, Decl(awaitCallExpression8_es5.ts, 0, 11)) +>a : Symbol(a, Decl(awaitCallExpression8_es5.ts, 0, 11)) + + after(); +>after : Symbol(after, Decl(awaitCallExpression8_es5.ts, 6, 32)) +} diff --git a/tests/baselines/reference/awaitCallExpression8_es5.types b/tests/baselines/reference/awaitCallExpression8_es5.types new file mode 100644 index 00000000000..1b2fa16d1fc --- /dev/null +++ b/tests/baselines/reference/awaitCallExpression8_es5.types @@ -0,0 +1,66 @@ +=== tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression8_es5.ts === +declare var a: boolean; +>a : boolean + +declare var p: Promise; +>p : Promise +>Promise : Promise + +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var 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 +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>pfn : Promise<(arg0: boolean, arg1: boolean, arg2: boolean) => void> +>Promise : Promise +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +>po : Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }> +>Promise : Promise +>fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>arg0 : boolean +>arg1 : boolean +>arg2 : boolean + +declare function before(): void; +>before : () => void + +declare function after(): void; +>after : () => void + +async function func(): Promise { +>func : () => Promise +>Promise : Promise + + before(); +>before() : void +>before : () => void + + var b = (await po).fn(a, a, a); +>b : 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; } +>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 +>a : boolean + + after(); +>after() : void +>after : () => void +} diff --git a/tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression1_es5.ts b/tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression1_es5.ts new file mode 100644 index 00000000000..8f133327c02 --- /dev/null +++ b/tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression1_es5.ts @@ -0,0 +1,16 @@ +// @target: ES5 +// @lib: es5,es2015.promise +// @noEmitHelpers: true +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare function before(): void; +declare function after(): void; +async function func(): Promise { + before(); + var b = fn(a, a, a); + after(); +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression2_es5.ts b/tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression2_es5.ts new file mode 100644 index 00000000000..b6949b97fcf --- /dev/null +++ b/tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression2_es5.ts @@ -0,0 +1,16 @@ +// @target: ES5 +// @lib: es5,es2015.promise +// @noEmitHelpers: true +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare function before(): void; +declare function after(): void; +async function func(): Promise { + before(); + var b = fn(await p, a, a); + after(); +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression3_es5.ts b/tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression3_es5.ts new file mode 100644 index 00000000000..10eef215ccc --- /dev/null +++ b/tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression3_es5.ts @@ -0,0 +1,16 @@ +// @target: ES5 +// @lib: es5,es2015.promise +// @noEmitHelpers: true +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare function before(): void; +declare function after(): void; +async function func(): Promise { + before(); + var b = fn(a, await p, a); + after(); +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression4_es5.ts b/tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression4_es5.ts new file mode 100644 index 00000000000..9e2159e5730 --- /dev/null +++ b/tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression4_es5.ts @@ -0,0 +1,16 @@ +// @target: ES5 +// @lib: es5,es2015.promise +// @noEmitHelpers: true +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare function before(): void; +declare function after(): void; +async function func(): Promise { + before(); + var b = (await pfn)(a, a, a); + after(); +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression5_es5.ts b/tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression5_es5.ts new file mode 100644 index 00000000000..19415c30de5 --- /dev/null +++ b/tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression5_es5.ts @@ -0,0 +1,16 @@ +// @target: ES5 +// @lib: es5,es2015.promise +// @noEmitHelpers: true +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare function before(): void; +declare function after(): void; +async function func(): Promise { + before(); + var b = o.fn(a, a, a); + after(); +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression6_es5.ts b/tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression6_es5.ts new file mode 100644 index 00000000000..23804c47a32 --- /dev/null +++ b/tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression6_es5.ts @@ -0,0 +1,16 @@ +// @target: ES5 +// @lib: es5,es2015.promise +// @noEmitHelpers: true +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare function before(): void; +declare function after(): void; +async function func(): Promise { + before(); + var b = o.fn(await p, a, a); + after(); +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression7_es5.ts b/tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression7_es5.ts new file mode 100644 index 00000000000..5227f480c8e --- /dev/null +++ b/tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression7_es5.ts @@ -0,0 +1,16 @@ +// @target: ES5 +// @lib: es5,es2015.promise +// @noEmitHelpers: true +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare function before(): void; +declare function after(): void; +async function func(): Promise { + before(); + var b = o.fn(a, await p, a); + after(); +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression8_es5.ts b/tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression8_es5.ts new file mode 100644 index 00000000000..ab47d34aac0 --- /dev/null +++ b/tests/cases/conformance/async/es5/awaitCallExpression/awaitCallExpression8_es5.ts @@ -0,0 +1,16 @@ +// @target: ES5 +// @lib: es5,es2015.promise +// @noEmitHelpers: true +declare var a: boolean; +declare var p: Promise; +declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; +declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; +declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; +declare function before(): void; +declare function after(): void; +async function func(): Promise { + before(); + var b = (await po).fn(a, a, a); + after(); +} \ No newline at end of file