Fix async function emit for lexical arguments

src/compiler/checker.ts

@@ -5765,6 +5765,7 @@ namespace ts {
                 
                 if (node.parserContextFlags & ParserContextFlags.Await) {
                     getNodeLinks(container).flags |= NodeCheckFlags.CaptureArguments;
+                    getNodeLinks(node).flags |= NodeCheckFlags.LexicalArguments;
                 }
             }
 

src/compiler/emitter.ts

@@ -49,11 +49,10 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };`;
 
         const awaiterHelper = `
-var __awaiter = (this && this.__awaiter) || function (args, generator) {
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promise, generator) {
-    var PromiseConstructor = args[1] || Promise;
+    return new Promise(function (resolve, reject) {
-    return new PromiseConstructor(function (resolve, reject) {
+        generator = generator.call(thisArg, _arguments);
-        generator = generator.call(args[0], args[2]);
+        function cast(value) { return value instanceof Promise && value.constructor === Promise ? value : new Promise(function (resolve) { resolve(value); }); }
-        function cast(value) { return value instanceof PromiseConstructor ? value : new PromiseConstructor(function (resolve) { resolve(value); }); }
         function onfulfill(value) { try { step("next", value); } catch (e) { reject(e); } }
         function onreject(value) { try { step("throw", value); } catch (e) { reject(e); } }
         function step(verb, value) {
@@ -1239,6 +1238,11 @@ var __awaiter = (this && this.__awaiter) || function (args, generator) {
             }
 
             function emitExpressionIdentifier(node: Identifier) {
+                if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.LexicalArguments) {
+                    write("_arguments");
+                    return;
+                }
+                
                 let container = resolver.getReferencedExportContainer(node);
                 if (container) {
                     if (container.kind === SyntaxKind.SourceFile) {
@@ -3374,9 +3378,9 @@ var __awaiter = (this && this.__awaiter) || function (args, generator) {
                 //  let a = async (b) => { await b; }
                 //
                 //  // output
-                //  let a = (b) => __awaiter([this], function* (b) {
+                //  let a = (b) => __awaiter(this, void 0, void 0, function* () {
                 //      yield b;
-                //  }, this);
+                //  });
                 //
                 // The emit for an async arrow with a lexical `arguments` binding might be:
                 //
@@ -3384,7 +3388,7 @@ var __awaiter = (this && this.__awaiter) || function (args, generator) {
                 //  let a = async (b) => { await arguments[0]; }
                 //
                 //  // output
-                //  let a = (b) => __awaiter([this, arguments], function* (arguments) {
+                //  let a = (b) => __awaiter(this, arguments, void 0, function* (arguments) {
                 //      yield arguments[0];
                 //  });
                 //
@@ -3398,9 +3402,9 @@ var __awaiter = (this && this.__awaiter) || function (args, generator) {
                 //
                 //  // output
                 //  let a = function (b) {
-                //      return __awaiter([this], function* () {
+                //      return __awaiter(this, void 0, void 0, function* () {
                 //          yield b;
-                //      }, this);
+                //      });
                 //  }
                 //
                 // The emit for an async function expression with a lexical `arguments` binding
@@ -3413,8 +3417,8 @@ var __awaiter = (this && this.__awaiter) || function (args, generator) {
                 //
                 //  // output
                 //  let a = function (b) {
-                //      return __awaiter([this, arguments], function* (arguments) {
+                //      return __awaiter(this, arguments, void 0, function* (_arguments) {
-                //          yield arguments[0];
+                //          yield _arguments[0];
                 //      });
                 //  }
                 //
@@ -3428,8 +3432,8 @@ var __awaiter = (this && this.__awaiter) || function (args, generator) {
                 //
                 //  // output
                 //  let a = function (b) {
-                //      return __awaiter([this, arguments, MyPromise], function* (arguments) {
+                //      return __awaiter(this, arguments, MyPromise, function* (_arguments) {
-                //          yield arguments[0];
+                //          yield _arguments[0];
                 //      });
                 //  }
                 //
@@ -3443,23 +3447,28 @@ var __awaiter = (this && this.__awaiter) || function (args, generator) {
                     write("return");
                 }
                 
-                write(" __awaiter([this");
+                write(" __awaiter(this");
-                if (promiseConstructor || hasLexicalArguments) {
+                if (hasLexicalArguments) {
+                    write(", arguments");
+                }
+                else {
+                    write(", void 0");
+                }
+
+                if (promiseConstructor) {
                     write(", ");
-                    if (promiseConstructor) {
+                    emitNodeWithoutSourceMap(promiseConstructor);
-                        emitNodeWithoutSourceMap(promiseConstructor);
+                }
-                    }
+                else {
-                    if (hasLexicalArguments) {
+                    write(", Promise");
-                        write(", arguments");
-                    }
                 }
                 
                 // Emit the call to __awaiter.
                 if (hasLexicalArguments) {
-                    write("], function* (arguments)");
+                    write(", function* (_arguments)");
                 }
                 else {
-                    write("], function* ()");
+                    write(", function* ()");
                 }
                 
                 // Emit the signature and body for the inner generator function.

src/compiler/types.ts

@@ -1595,12 +1595,13 @@ namespace ts {
         SuperInstance               = 0x00000100,  // Instance 'super' reference
         SuperStatic                 = 0x00000200,  // Static 'super' reference
         ContextChecked              = 0x00000400,  // Contextual types have been assigned
-        CaptureArguments            = 0x00000800,  // Lexical 'arguments' used in body (for async functions)
+        LexicalArguments            = 0x00000800,
+        CaptureArguments            = 0x00001000,  // Lexical 'arguments' used in body (for async functions)
 
         // Values for enum members have been computed, and any errors have been reported for them.
-        EnumValuesComputed          = 0x00001000,
+        EnumValuesComputed          = 0x00002000,
-        BlockScopedBindingInLoop    = 0x00002000,
+        BlockScopedBindingInLoop    = 0x00004000,
-        LexicalModuleMergesWithClass= 0x00004000,  // Instantiated lexical module declaration is merged with a previous class declaration.
+        LexicalModuleMergesWithClass= 0x00008000,  // Instantiated lexical module declaration is merged with a previous class declaration.
     }
 
     /* @internal */ 

tests/baselines/reference/asyncArrowFunction1_es6.js

@@ -4,5 +4,5 @@ var foo = async (): Promise<void> => {
 };
 
 //// [asyncArrowFunction1_es6.js]
-var foo = () => __awaiter([this, Promise], function* () {
+var foo = () => __awaiter(this, void 0, Promise, function* () {
 });

tests/baselines/reference/asyncArrowFunction6_es6.js

@@ -4,5 +4,5 @@ var foo = async (a = await): Promise<void> => {
 }
 
 //// [asyncArrowFunction6_es6.js]
-var foo = (a = yield ) => __awaiter([this, Promise], function* () {
+var foo = (a = yield ) => __awaiter(this, void 0, Promise, function* () {
 });

tests/baselines/reference/asyncArrowFunction7_es6.js

@@ -7,8 +7,8 @@ var bar = async (): Promise<void> => {
 }
 
 //// [asyncArrowFunction7_es6.js]
-var bar = () => __awaiter([this, Promise], function* () {
+var bar = () => __awaiter(this, void 0, Promise, function* () {
     // 'await' here is an identifier, and not an await expression.
-    var foo = (a = yield ) => __awaiter([this, Promise], function* () {
+    var foo = (a = yield ) => __awaiter(this, void 0, Promise, function* () {
     });
 });

tests/baselines/reference/asyncArrowFunction8_es6.js

@@ -5,6 +5,6 @@ var foo = async (): Promise<void> => {
 }
 
 //// [asyncArrowFunction8_es6.js]
-var foo = () => __awaiter([this, Promise], function* () {
+var foo = () => __awaiter(this, void 0, Promise, function* () {
     var v = { [yield ]: foo };
 });

tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.js

@@ -11,6 +11,6 @@ class C {
 class C {
     method() {
         function other() { }
-        var fn = () => __awaiter([this, , arguments], function* (arguments) { return yield other.apply(this, arguments); });
+        var fn = () => __awaiter(this, arguments, Promise, function* (_arguments) { return yield other.apply(this, _arguments); });
     }
 }

tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.js

@@ -9,6 +9,6 @@ class C {
 //// [asyncArrowFunctionCapturesThis_es6.js]
 class C {
     method() {
-        var fn = () => __awaiter([this], function* () { return yield this; });
+        var fn = () => __awaiter(this, void 0, Promise, function* () { return yield this; });
     }
 }

tests/baselines/reference/asyncAwaitIsolatedModules_es6.js

@@ -40,11 +40,10 @@ module M {
 }
 
 //// [asyncAwaitIsolatedModules_es6.js]
-var __awaiter = (this && this.__awaiter) || function (args, generator) {
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promise, generator) {
-    var PromiseConstructor = args[1] || Promise;
+    return new Promise(function (resolve, reject) {
-    return new PromiseConstructor(function (resolve, reject) {
+        generator = generator.call(thisArg, _arguments);
-        generator = generator.call(args[0], args[2]);
+        function cast(value) { return value instanceof Promise && value.constructor === Promise ? value : new Promise(function (resolve) { resolve(value); }); }
-        function cast(value) { return value instanceof PromiseConstructor ? value : new PromiseConstructor(function (resolve) { resolve(value); }); }
         function onfulfill(value) { try { step("next", value); } catch (e) { reject(e); } }
         function onreject(value) { try { step("throw", value); } catch (e) { reject(e); } }
         function step(verb, value) {
@@ -55,65 +54,65 @@ var __awaiter = (this && this.__awaiter) || function (args, generator) {
     });
 };
 function f0() {
-    return __awaiter([this], function* () { });
+    return __awaiter(this, void 0, Promise, function* () { });
 }
 function f1() {
-    return __awaiter([this, Promise], function* () { });
+    return __awaiter(this, void 0, Promise, function* () { });
 }
 function f3() {
-    return __awaiter([this, MyPromise], function* () { });
+    return __awaiter(this, void 0, MyPromise, function* () { });
 }
 let f4 = function () {
-    return __awaiter([this], function* () { });
+    return __awaiter(this, void 0, Promise, function* () { });
 };
 let f5 = function () {
-    return __awaiter([this, Promise], function* () { });
+    return __awaiter(this, void 0, Promise, function* () { });
 };
 let f6 = function () {
-    return __awaiter([this, MyPromise], function* () { });
+    return __awaiter(this, void 0, MyPromise, function* () { });
 };
-let f7 = () => __awaiter([this], function* () { });
+let f7 = () => __awaiter(this, void 0, Promise, function* () { });
-let f8 = () => __awaiter([this, Promise], function* () { });
+let f8 = () => __awaiter(this, void 0, Promise, function* () { });
-let f9 = () => __awaiter([this, MyPromise], function* () { });
+let f9 = () => __awaiter(this, void 0, MyPromise, function* () { });
-let f10 = () => __awaiter([this], function* () { return p; });
+let f10 = () => __awaiter(this, void 0, Promise, function* () { return p; });
-let f11 = () => __awaiter([this], function* () { return mp; });
+let f11 = () => __awaiter(this, void 0, Promise, function* () { return mp; });
-let f12 = () => __awaiter([this, Promise], function* () { return mp; });
+let f12 = () => __awaiter(this, void 0, Promise, function* () { return mp; });
-let f13 = () => __awaiter([this, MyPromise], function* () { return p; });
+let f13 = () => __awaiter(this, void 0, MyPromise, function* () { return p; });
 let o = {
     m1() {
-        return __awaiter([this], function* () { });
+        return __awaiter(this, void 0, Promise, function* () { });
     },
     m2() {
-        return __awaiter([this, Promise], function* () { });
+        return __awaiter(this, void 0, Promise, function* () { });
     },
     m3() {
-        return __awaiter([this, MyPromise], function* () { });
+        return __awaiter(this, void 0, MyPromise, function* () { });
     }
 };
 class C {
     m1() {
-        return __awaiter([this], function* () { });
+        return __awaiter(this, void 0, Promise, function* () { });
     }
     m2() {
-        return __awaiter([this, Promise], function* () { });
+        return __awaiter(this, void 0, Promise, function* () { });
     }
     m3() {
-        return __awaiter([this, MyPromise], function* () { });
+        return __awaiter(this, void 0, MyPromise, function* () { });
     }
     static m4() {
-        return __awaiter([this], function* () { });
+        return __awaiter(this, void 0, Promise, function* () { });
     }
     static m5() {
-        return __awaiter([this, Promise], function* () { });
+        return __awaiter(this, void 0, Promise, function* () { });
     }
     static m6() {
-        return __awaiter([this, MyPromise], function* () { });
+        return __awaiter(this, void 0, MyPromise, function* () { });
     }
 }
 var M;
 (function (M) {
     function f1() {
-        return __awaiter([this], function* () { });
+        return __awaiter(this, void 0, Promise, function* () { });
     }
     M.f1 = f1;
 })(M || (M = {}));

tests/baselines/reference/asyncAwait_es6.js

@@ -40,11 +40,10 @@ module M {
 }
 
 //// [asyncAwait_es6.js]
-var __awaiter = (this && this.__awaiter) || function (args, generator) {
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promise, generator) {
-    var PromiseConstructor = args[1] || Promise;
+    return new Promise(function (resolve, reject) {
-    return new PromiseConstructor(function (resolve, reject) {
+        generator = generator.call(thisArg, _arguments);
-        generator = generator.call(args[0], args[2]);
+        function cast(value) { return value instanceof Promise && value.constructor === Promise ? value : new Promise(function (resolve) { resolve(value); }); }
-        function cast(value) { return value instanceof PromiseConstructor ? value : new PromiseConstructor(function (resolve) { resolve(value); }); }
         function onfulfill(value) { try { step("next", value); } catch (e) { reject(e); } }
         function onreject(value) { try { step("throw", value); } catch (e) { reject(e); } }
         function step(verb, value) {
@@ -55,65 +54,65 @@ var __awaiter = (this && this.__awaiter) || function (args, generator) {
     });
 };
 function f0() {
-    return __awaiter([this], function* () { });
+    return __awaiter(this, void 0, Promise, function* () { });
 }
 function f1() {
-    return __awaiter([this, Promise], function* () { });
+    return __awaiter(this, void 0, Promise, function* () { });
 }
 function f3() {
-    return __awaiter([this, MyPromise], function* () { });
+    return __awaiter(this, void 0, MyPromise, function* () { });
 }
 let f4 = function () {
-    return __awaiter([this], function* () { });
+    return __awaiter(this, void 0, Promise, function* () { });
 };
 let f5 = function () {
-    return __awaiter([this, Promise], function* () { });
+    return __awaiter(this, void 0, Promise, function* () { });
 };
 let f6 = function () {
-    return __awaiter([this, MyPromise], function* () { });
+    return __awaiter(this, void 0, MyPromise, function* () { });
 };
-let f7 = () => __awaiter([this], function* () { });
+let f7 = () => __awaiter(this, void 0, Promise, function* () { });
-let f8 = () => __awaiter([this, Promise], function* () { });
+let f8 = () => __awaiter(this, void 0, Promise, function* () { });
-let f9 = () => __awaiter([this, MyPromise], function* () { });
+let f9 = () => __awaiter(this, void 0, MyPromise, function* () { });
-let f10 = () => __awaiter([this], function* () { return p; });
+let f10 = () => __awaiter(this, void 0, Promise, function* () { return p; });
-let f11 = () => __awaiter([this], function* () { return mp; });
+let f11 = () => __awaiter(this, void 0, Promise, function* () { return mp; });
-let f12 = () => __awaiter([this, Promise], function* () { return mp; });
+let f12 = () => __awaiter(this, void 0, Promise, function* () { return mp; });
-let f13 = () => __awaiter([this, MyPromise], function* () { return p; });
+let f13 = () => __awaiter(this, void 0, MyPromise, function* () { return p; });
 let o = {
     m1() {
-        return __awaiter([this], function* () { });
+        return __awaiter(this, void 0, Promise, function* () { });
     },
     m2() {
-        return __awaiter([this, Promise], function* () { });
+        return __awaiter(this, void 0, Promise, function* () { });
     },
     m3() {
-        return __awaiter([this, MyPromise], function* () { });
+        return __awaiter(this, void 0, MyPromise, function* () { });
     }
 };
 class C {
     m1() {
-        return __awaiter([this], function* () { });
+        return __awaiter(this, void 0, Promise, function* () { });
     }
     m2() {
-        return __awaiter([this, Promise], function* () { });
+        return __awaiter(this, void 0, Promise, function* () { });
     }
     m3() {
-        return __awaiter([this, MyPromise], function* () { });
+        return __awaiter(this, void 0, MyPromise, function* () { });
     }
     static m4() {
-        return __awaiter([this], function* () { });
+        return __awaiter(this, void 0, Promise, function* () { });
     }
     static m5() {
-        return __awaiter([this, Promise], function* () { });
+        return __awaiter(this, void 0, Promise, function* () { });
     }
     static m6() {
-        return __awaiter([this, MyPromise], function* () { });
+        return __awaiter(this, void 0, MyPromise, function* () { });
     }
 }
 var M;
 (function (M) {
     function f1() {
-        return __awaiter([this], function* () { });
+        return __awaiter(this, void 0, Promise, function* () { });
     }
     M.f1 = f1;
 })(M || (M = {}));

tests/baselines/reference/asyncFunctionDeclaration11_es6.js

@@ -4,6 +4,6 @@ async function await(): Promise<void> {
 
 //// [asyncFunctionDeclaration11_es6.js]
 function await() {
-    return __awaiter([this, Promise], function* () {
+    return __awaiter(this, void 0, Promise, function* () {
     });
 }

tests/baselines/reference/asyncFunctionDeclaration13_es6.js

@@ -7,7 +7,7 @@ async function foo(): Promise<void> {
 
 //// [asyncFunctionDeclaration13_es6.js]
 function foo() {
-    return __awaiter([this, Promise], function* () {
+    return __awaiter(this, void 0, Promise, function* () {
         // Legal to use 'await' in a type context.
         var v;
     });

tests/baselines/reference/asyncFunctionDeclaration14_es6.js

@@ -5,7 +5,7 @@ async function foo(): Promise<void> {
 
 //// [asyncFunctionDeclaration14_es6.js]
 function foo() {
-    return __awaiter([this, Promise], function* () {
+    return __awaiter(this, void 0, Promise, function* () {
         return;
     });
 }

tests/baselines/reference/asyncFunctionDeclaration1_es6.js

@@ -4,6 +4,6 @@ async function foo(): Promise<void> {
 
 //// [asyncFunctionDeclaration1_es6.js]
 function foo() {
-    return __awaiter([this, Promise], function* () {
+    return __awaiter(this, void 0, Promise, function* () {
     });
 }

tests/baselines/reference/asyncFunctionDeclaration6_es6.js

@@ -4,6 +4,6 @@ async function foo(a = await): Promise<void> {
 
 //// [asyncFunctionDeclaration6_es6.js]
 function foo(a = yield ) {
-    return __awaiter([this, Promise], function* () {
+    return __awaiter(this, void 0, Promise, function* () {
     });
 }

tests/baselines/reference/asyncFunctionDeclaration7_es6.js

@@ -7,10 +7,10 @@ async function bar(): Promise<void> {
 
 //// [asyncFunctionDeclaration7_es6.js]
 function bar() {
-    return __awaiter([this, Promise], function* () {
+    return __awaiter(this, void 0, Promise, function* () {
         // 'await' here is an identifier, and not a yield expression.
         function foo(a = yield ) {
-            return __awaiter([this, Promise], function* () {
+            return __awaiter(this, void 0, Promise, function* () {
             });
         }
     });

tests/baselines/reference/asyncFunctionDeclaration9_es6.js

@@ -5,7 +5,7 @@ async function foo(): Promise<void> {
 
 //// [asyncFunctionDeclaration9_es6.js]
 function foo() {
-    return __awaiter([this, Promise], function* () {
+    return __awaiter(this, void 0, Promise, function* () {
         var v = { [yield ]: foo };
     });
 }

tests/baselines/reference/awaitBinaryExpression1_es6.js

@@ -9,7 +9,7 @@ async function func(): Promise<void> {
 
 //// [awaitBinaryExpression1_es6.js]
 function func() {
-    return __awaiter([this, Promise], function* () {
+    return __awaiter(this, void 0, Promise, function* () {
         "before";
         var b = (yield p) || a;
         "after";

tests/baselines/reference/awaitBinaryExpression2_es6.js

@@ -9,7 +9,7 @@ async function func(): Promise<void> {
 
 //// [awaitBinaryExpression2_es6.js]
 function func() {
-    return __awaiter([this, Promise], function* () {
+    return __awaiter(this, void 0, Promise, function* () {
         "before";
         var b = (yield p) && a;
         "after";

tests/baselines/reference/awaitBinaryExpression3_es6.js

@@ -9,7 +9,7 @@ async function func(): Promise<void> {
 
 //// [awaitBinaryExpression3_es6.js]
 function func() {
-    return __awaiter([this, Promise], function* () {
+    return __awaiter(this, void 0, Promise, function* () {
         "before";
         var b = (yield p) + a;
         "after";

tests/baselines/reference/awaitBinaryExpression4_es6.js

@@ -9,7 +9,7 @@ async function func(): Promise<void> {
 
 //// [awaitBinaryExpression4_es6.js]
 function func() {
-    return __awaiter([this, Promise], function* () {
+    return __awaiter(this, void 0, Promise, function* () {
         "before";
         var b = yield p, a;
         "after";

tests/baselines/reference/awaitBinaryExpression5_es6.js

@@ -10,7 +10,7 @@ async function func(): Promise<void> {
 
 //// [awaitBinaryExpression5_es6.js]
 function func() {
-    return __awaiter([this, Promise], function* () {
+    return __awaiter(this, void 0, Promise, function* () {
         "before";
         var o;
         o.a = yield p;

tests/baselines/reference/awaitCallExpression1_es6.js

@@ -13,7 +13,7 @@ async function func(): Promise<void> {
 
 //// [awaitCallExpression1_es6.js]
 function func() {
-    return __awaiter([this, Promise], function* () {
+    return __awaiter(this, void 0, Promise, function* () {
         "before";
         var b = fn(a, a, a);
         "after";

tests/baselines/reference/awaitCallExpression2_es6.js

@@ -13,7 +13,7 @@ async function func(): Promise<void> {
 
 //// [awaitCallExpression2_es6.js]
 function func() {
-    return __awaiter([this, Promise], function* () {
+    return __awaiter(this, void 0, Promise, function* () {
         "before";
         var b = fn(yield p, a, a);
         "after";

tests/baselines/reference/awaitCallExpression3_es6.js

@@ -13,7 +13,7 @@ async function func(): Promise<void> {
 
 //// [awaitCallExpression3_es6.js]
 function func() {
-    return __awaiter([this, Promise], function* () {
+    return __awaiter(this, void 0, Promise, function* () {
         "before";
         var b = fn(a, yield p, a);
         "after";

tests/baselines/reference/awaitCallExpression4_es6.js

@@ -13,7 +13,7 @@ async function func(): Promise<void> {
 
 //// [awaitCallExpression4_es6.js]
 function func() {
-    return __awaiter([this, Promise], function* () {
+    return __awaiter(this, void 0, Promise, function* () {
         "before";
         var b = (yield pfn)(a, a, a);
         "after";

tests/baselines/reference/awaitCallExpression5_es6.js

@@ -13,7 +13,7 @@ async function func(): Promise<void> {
 
 //// [awaitCallExpression5_es6.js]
 function func() {
-    return __awaiter([this, Promise], function* () {
+    return __awaiter(this, void 0, Promise, function* () {
         "before";
         var b = o.fn(a, a, a);
         "after";

tests/baselines/reference/awaitCallExpression6_es6.js

@@ -13,7 +13,7 @@ async function func(): Promise<void> {
 
 //// [awaitCallExpression6_es6.js]
 function func() {
-    return __awaiter([this, Promise], function* () {
+    return __awaiter(this, void 0, Promise, function* () {
         "before";
         var b = o.fn(yield p, a, a);
         "after";

tests/baselines/reference/awaitCallExpression7_es6.js

@@ -13,7 +13,7 @@ async function func(): Promise<void> {
 
 //// [awaitCallExpression7_es6.js]
 function func() {
-    return __awaiter([this, Promise], function* () {
+    return __awaiter(this, void 0, Promise, function* () {
         "before";
         var b = o.fn(a, yield p, a);
         "after";

tests/baselines/reference/awaitCallExpression8_es6.js

@@ -13,7 +13,7 @@ async function func(): Promise<void> {
 
 //// [awaitCallExpression8_es6.js]
 function func() {
-    return __awaiter([this, Promise], function* () {
+    return __awaiter(this, void 0, Promise, function* () {
         "before";
         var b = (yield po).fn(a, a, a);
         "after";

tests/baselines/reference/awaitUnion_es6.js

@@ -14,7 +14,7 @@ async function f() {
 
 //// [awaitUnion_es6.js]
 function f() {
-    return __awaiter([this], function* () {
+    return __awaiter(this, void 0, Promise, function* () {
         let await_a = yield a;
         let await_b = yield b;
         let await_c = yield c;