test(es): Freeze as es2015 to verify base transforms (#2468)

.github/workflows/cargo.yml

@@ -228,6 +228,7 @@ jobs:
           cargo test --color always -p ${{ matrix.crate }}
 
       - name: Run cargo test (concurrent)
+        if: runner.os != 'Windows'
         shell: bash
         run: |
           ./scripts/ci/test-concurrent.sh ${{ matrix.crate }}

Cargo.lock

@@ -3533,7 +3533,7 @@ checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
 
 [[package]]
 name = "wasm"
-version = "1.2.99"
+version = "1.2.100"
 dependencies = [
  "anyhow",
  "console_error_panic_hook",

package.json

@@ -1,6 +1,6 @@
 {
     "name": "@swc/core",
-    "version": "1.2.99",
+    "version": "1.2.100",
     "description": "Super-fast alternative for babel",
     "homepage": "https://swc.rs",
     "main": "./index.js",

tests/tsc-references/async/es2017/asyncArrowFunction/arrowFunctionWithParameterNameAsync_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,4 @@
+// @target: ES5
+// @noEmitHelpers: true
+const x = (async)=>async
+;

tests/tsc-references/async/es2017/asyncArrowFunction/asyncArrowFunction10_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,35 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+// @target: es2017
+// @noEmitHelpers: true
+var foo = _asyncToGenerator(function*() {
+    // Legal to use 'await' in a type context.
+    var v;
+});

tests/tsc-references/async/es2017/asyncArrowFunction/asyncArrowFunction10_es2017/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,25 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+!function(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(void 0);
+        });
+    };
+}(function*() {
+});

tests/tsc-references/async/es2017/asyncArrowFunction/asyncArrowFunction1_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,33 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+// @target: es2017
+// @noEmitHelpers: true
+var foo = _asyncToGenerator(function*() {
+});

tests/tsc-references/async/es2017/asyncArrowFunction/asyncArrowFunction1_es2017/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,25 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+!function(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(void 0);
+        });
+    };
+}(function*() {
+});

tests/tsc-references/async/es2017/asyncArrowFunction/asyncArrowFunction2_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,4 @@
+// @target: es2017
+// @noEmitHelpers: true
+var f = (_await)=>{
+};

tests/tsc-references/async/es2017/asyncArrowFunction/asyncArrowFunction3_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,4 @@
+// @target: es2017
+// @noEmitHelpers: true
+function f(_await = _await) {
+}

tests/tsc-references/async/es2017/asyncArrowFunction/asyncArrowFunction4_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,4 @@
+// @target: es2017
+// @noEmitHelpers: true
+var _await = ()=>{
+};

tests/tsc-references/async/es2017/asyncArrowFunction/asyncArrowFunctionCapturesArguments_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,40 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+// @target: es2017
+// @noEmitHelpers: true
+class C {
+    method() {
+        function other() {
+        }
+        var fn = _asyncToGenerator((function*() {
+            return yield other.apply(this, arguments);
+        }).bind(this)).bind(this);
+    }
+}

tests/tsc-references/async/es2017/asyncArrowFunction/asyncArrowFunctionCapturesThis_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,38 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+// @target: es2017
+// @noEmitHelpers: true
+class C {
+    method() {
+        var fn = _asyncToGenerator((function*() {
+            return yield this;
+        }).bind(this)).bind(this);
+    }
+}

tests/tsc-references/async/es2017/asyncArrowFunction/asyncArrowFunction_allowJs/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,51 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+// @allowJs: true
+// @checkJs: true
+// @noEmit: true
+// @target: es2017
+// @filename: file.js
+// Error (good)
+/** @type {function(): string} */ const a = ()=>0
+;
+// Error (good)
+/** @type {function(): string} */ const b = _asyncToGenerator(function*() {
+    return 0;
+});
+// No error (bad)
+/** @type {function(): string} */ const c = _asyncToGenerator(function*() {
+    return 0;
+});
+/** @type {function(function(): string): void} */ const f = (p)=>{
+};
+// Error (good)
+f(_asyncToGenerator(function*() {
+    return 0;
+}));

tests/tsc-references/async/es2017/asyncArrowFunction/asyncArrowFunction_allowJs/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,31 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(void 0);
+        });
+    };
+}
+_asyncToGenerator(function*() {
+    return 0;
+}), _asyncToGenerator(function*() {
+    return 0;
+}), _asyncToGenerator(function*() {
+    return 0;
+});

tests/tsc-references/async/es2017/asyncArrowFunction/asyncUnParenthesizedArrowFunction_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,35 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+const x = _asyncToGenerator(function*(i) {
+    return yield someOtherFunction(i);
+});
+const x1 = _asyncToGenerator(function*(i) {
+    return yield someOtherFunction(i);
+});

tests/tsc-references/async/es2017/asyncArrowFunction/asyncUnParenthesizedArrowFunction_es2017/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,29 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(void 0);
+        });
+    };
+}
+_asyncToGenerator(function*(i) {
+    return yield someOtherFunction(i);
+}), _asyncToGenerator(function*(i) {
+    return yield someOtherFunction(i);
+});

tests/tsc-references/async/es2017/asyncAwaitIsolatedModules_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,148 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _f0() {
+    _f0 = _asyncToGenerator(function*() {
+    });
+    return _f0.apply(this, arguments);
+}
+function f0() {
+    return _f0.apply(this, arguments);
+}
+function _f1() {
+    _f1 = _asyncToGenerator(function*() {
+    });
+    return _f1.apply(this, arguments);
+}
+function f1() {
+    return _f1.apply(this, arguments);
+}
+function _f3() {
+    _f3 = _asyncToGenerator(function*() {
+    });
+    return _f3.apply(this, arguments);
+}
+function f3() {
+    return _f3.apply(this, arguments);
+}
+let f4 = function() {
+    var _ref = _asyncToGenerator(function*() {
+    });
+    return function() {
+        return _ref.apply(this, arguments);
+    };
+}();
+let f5 = function() {
+    var _ref = _asyncToGenerator(function*() {
+    });
+    return function() {
+        return _ref.apply(this, arguments);
+    };
+}();
+let f6 = function() {
+    var _ref = _asyncToGenerator(function*() {
+    });
+    return function() {
+        return _ref.apply(this, arguments);
+    };
+}();
+let f7 = _asyncToGenerator(function*() {
+});
+let f8 = _asyncToGenerator(function*() {
+});
+let f9 = _asyncToGenerator(function*() {
+});
+let f10 = _asyncToGenerator(function*() {
+    return p;
+});
+let f11 = _asyncToGenerator(function*() {
+    return mp;
+});
+let f12 = _asyncToGenerator(function*() {
+    return mp;
+});
+let f13 = _asyncToGenerator(function*() {
+    return p;
+});
+let o = {
+    m1 () {
+        return _asyncToGenerator(function*() {
+        })();
+    },
+    m2 () {
+        return _asyncToGenerator(function*() {
+        })();
+    },
+    m3 () {
+        return _asyncToGenerator(function*() {
+        })();
+    }
+};
+class C {
+    m1() {
+        return _asyncToGenerator(function*() {
+        })();
+    }
+    m2() {
+        return _asyncToGenerator(function*() {
+        })();
+    }
+    m3() {
+        return _asyncToGenerator(function*() {
+        })();
+    }
+    static m4() {
+        return _asyncToGenerator(function*() {
+        })();
+    }
+    static m5() {
+        return _asyncToGenerator(function*() {
+        })();
+    }
+    static m6() {
+        return _asyncToGenerator(function*() {
+        })();
+    }
+}
+var M;
+(function(M) {
+    function _f1() {
+        _f1 = _asyncToGenerator(function*() {
+        });
+        return _f1.apply(this, arguments);
+    }
+    function f1() {
+        return _f1.apply(this, arguments);
+    }
+    M.f1 = f1;
+})(M || (M = {
+}));
+// @target: es2017
+// @isolatedModules: true
+export { };

tests/tsc-references/async/es2017/asyncAwaitIsolatedModules_es2017/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,62 @@
+var M;
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(void 0);
+        });
+    };
+}
+function _f0() {
+    return (_f0 = _asyncToGenerator(function*() {
+    })).apply(this, arguments);
+}
+function _f1() {
+    return (_f1 = _asyncToGenerator(function*() {
+    })).apply(this, arguments);
+}
+function _f3() {
+    return (_f3 = _asyncToGenerator(function*() {
+    })).apply(this, arguments);
+}
+_asyncToGenerator(function*() {
+}), _asyncToGenerator(function*() {
+}), _asyncToGenerator(function*() {
+}), _asyncToGenerator(function*() {
+}), _asyncToGenerator(function*() {
+}), _asyncToGenerator(function*() {
+}), _asyncToGenerator(function*() {
+    return p;
+}), _asyncToGenerator(function*() {
+    return mp;
+}), _asyncToGenerator(function*() {
+    return mp;
+}), _asyncToGenerator(function*() {
+    return p;
+}), (function(M) {
+    function _f1() {
+        return (_f1 = _asyncToGenerator(function*() {
+        })).apply(this, arguments);
+    }
+    M.f1 = function() {
+        return _f1.apply(this, arguments);
+    };
+})(M || (M = {
+}));
+export { };

tests/tsc-references/async/es2017/asyncAwait_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,157 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _f0() {
+    _f0 = _asyncToGenerator(function*() {
+    });
+    return _f0.apply(this, arguments);
+}
+function f0() {
+    return _f0.apply(this, arguments);
+}
+function _f1() {
+    _f1 = _asyncToGenerator(function*() {
+    });
+    return _f1.apply(this, arguments);
+}
+function f1() {
+    return _f1.apply(this, arguments);
+}
+function _f3() {
+    _f3 = _asyncToGenerator(function*() {
+    });
+    return _f3.apply(this, arguments);
+}
+function f3() {
+    return _f3.apply(this, arguments);
+}
+let f4 = function() {
+    var _ref = _asyncToGenerator(function*() {
+    });
+    return function() {
+        return _ref.apply(this, arguments);
+    };
+}();
+let f5 = function() {
+    var _ref = _asyncToGenerator(function*() {
+    });
+    return function() {
+        return _ref.apply(this, arguments);
+    };
+}();
+let f6 = function() {
+    var _ref = _asyncToGenerator(function*() {
+    });
+    return function() {
+        return _ref.apply(this, arguments);
+    };
+}();
+let f7 = _asyncToGenerator(function*() {
+});
+let f8 = _asyncToGenerator(function*() {
+});
+let f9 = _asyncToGenerator(function*() {
+});
+let f10 = _asyncToGenerator(function*() {
+    return p;
+});
+let f11 = _asyncToGenerator(function*() {
+    return mp;
+});
+let f12 = _asyncToGenerator(function*() {
+    return mp;
+});
+let f13 = _asyncToGenerator(function*() {
+    return p;
+});
+let o = {
+    m1 () {
+        return _asyncToGenerator(function*() {
+        })();
+    },
+    m2 () {
+        return _asyncToGenerator(function*() {
+        })();
+    },
+    m3 () {
+        return _asyncToGenerator(function*() {
+        })();
+    }
+};
+class C {
+    m1() {
+        return _asyncToGenerator(function*() {
+        })();
+    }
+    m2() {
+        return _asyncToGenerator(function*() {
+        })();
+    }
+    m3() {
+        return _asyncToGenerator(function*() {
+        })();
+    }
+    static m4() {
+        return _asyncToGenerator(function*() {
+        })();
+    }
+    static m5() {
+        return _asyncToGenerator(function*() {
+        })();
+    }
+    static m6() {
+        return _asyncToGenerator(function*() {
+        })();
+    }
+}
+var M;
+(function(M) {
+    function _f1() {
+        _f1 = _asyncToGenerator(function*() {
+        });
+        return _f1.apply(this, arguments);
+    }
+    function f1() {
+        return _f1.apply(this, arguments);
+    }
+    M.f1 = f1;
+})(M || (M = {
+}));
+function _f14() {
+    _f14 = _asyncToGenerator(function*() {
+        block: {
+            yield 1;
+            break block;
+        }
+    });
+    return _f14.apply(this, arguments);
+}
+function f14() {
+    return _f14.apply(this, arguments);
+}

tests/tsc-references/async/es2017/asyncAwait_es2017/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,69 @@
+var M;
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(void 0);
+        });
+    };
+}
+function _f0() {
+    return (_f0 = _asyncToGenerator(function*() {
+    })).apply(this, arguments);
+}
+function _f1() {
+    return (_f1 = _asyncToGenerator(function*() {
+    })).apply(this, arguments);
+}
+function _f3() {
+    return (_f3 = _asyncToGenerator(function*() {
+    })).apply(this, arguments);
+}
+function _f14() {
+    return (_f14 = _asyncToGenerator(function*() {
+        block: {
+            yield 1;
+            break block;
+        }
+    })).apply(this, arguments);
+}
+_asyncToGenerator(function*() {
+}), _asyncToGenerator(function*() {
+}), _asyncToGenerator(function*() {
+}), _asyncToGenerator(function*() {
+}), _asyncToGenerator(function*() {
+}), _asyncToGenerator(function*() {
+}), _asyncToGenerator(function*() {
+    return p;
+}), _asyncToGenerator(function*() {
+    return mp;
+}), _asyncToGenerator(function*() {
+    return mp;
+}), _asyncToGenerator(function*() {
+    return p;
+}), (function(M) {
+    function _f1() {
+        return (_f1 = _asyncToGenerator(function*() {
+        })).apply(this, arguments);
+    }
+    M.f1 = function() {
+        return _f1.apply(this, arguments);
+    };
+})(M || (M = {
+}));

tests/tsc-references/async/es2017/asyncMethodWithSuperConflict_es6/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,99 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+// @target: es6
+class A {
+    x() {
+    }
+    y() {
+    }
+}
+class B extends A {
+    // async method with only call/get on 'super' does not require a binding
+    simple() {
+        var _super_x = (..._args)=>super.x(..._args)
+        , _super_y = (..._args)=>super.y(..._args)
+        , _super_method = (..._args)=>super["x"](..._args)
+        , _super_x1 = ()=>super.x
+        , _super_method1 = ()=>super["x"]
+        ;
+        return _asyncToGenerator(function*() {
+            const _super = null;
+            const _superIndex = null;
+            // call with property access
+            _super_x();
+            // call additional property.
+            _super_y();
+            // call with element access
+            _super_method();
+            // property access (read)
+            const a = _super_x1();
+            // element access (read)
+            const b = _super_method1();
+        })();
+    }
+    // async method with assignment/destructuring on 'super' requires a binding
+    advanced() {
+        var _super_x = (..._args)=>super.x(..._args)
+        , _super_method = (..._args)=>super["x"](..._args)
+        , _super_x3 = ()=>super.x
+        , _super_method3 = ()=>super["x"]
+        , _super_x4 = (_args)=>// property access (assign)
+            super.x = _args
+        , _super_method4 = (_args)=>// element access (assign)
+            super["x"] = _args
+        , _super_x5 = ()=>super.x
+        , _super_method5 = ()=>super["x"]
+        ;
+        return _asyncToGenerator(function*() {
+            const _super = null;
+            const _superIndex = null;
+            const f = ()=>{
+            };
+            // call with property access
+            _super_x();
+            // call with element access
+            _super_method();
+            // property access (read)
+            const a = _super_x3();
+            // element access (read)
+            const b = _super_method3();
+            _super_x4(f);
+            _super_method4(f);
+            // destructuring assign with property access
+            ({ f: _super_x5()  } = {
+                f
+            });
+            // destructuring assign with element access
+            ({ f: _super_method5()  } = {
+                f
+            });
+        })();
+    }
+}

tests/tsc-references/async/es2017/asyncMethodWithSuper_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,96 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+// @target: es2017
+// @noEmitHelpers: true
+class A {
+    x() {
+    }
+    y() {
+    }
+}
+class B extends A {
+    // async method with only call/get on 'super' does not require a binding
+    simple() {
+        var _super_x = (..._args)=>super.x(..._args)
+        , _super_y = (..._args)=>super.y(..._args)
+        , _super_method = (..._args)=>super["x"](..._args)
+        , _super_x1 = ()=>super.x
+        , _super_method1 = ()=>super["x"]
+        ;
+        return _asyncToGenerator(function*() {
+            // call with property access
+            _super_x();
+            // call additional property.
+            _super_y();
+            // call with element access
+            _super_method();
+            // property access (read)
+            const a = _super_x1();
+            // element access (read)
+            const b = _super_method1();
+        })();
+    }
+    // async method with assignment/destructuring on 'super' requires a binding
+    advanced() {
+        var _super_x = (..._args)=>super.x(..._args)
+        , _super_method = (..._args)=>super["x"](..._args)
+        , _super_x3 = ()=>super.x
+        , _super_method3 = ()=>super["x"]
+        , _super_x4 = (_args)=>// property access (assign)
+            super.x = _args
+        , _super_method4 = (_args)=>// element access (assign)
+            super["x"] = _args
+        , _super_x5 = ()=>super.x
+        , _super_method5 = ()=>super["x"]
+        ;
+        return _asyncToGenerator(function*() {
+            const f = ()=>{
+            };
+            // call with property access
+            _super_x();
+            // call with element access
+            _super_method();
+            // property access (read)
+            const a = _super_x3();
+            // element access (read)
+            const b = _super_method3();
+            _super_x4(f);
+            _super_method4(f);
+            // destructuring assign with property access
+            ({ f: _super_x5()  } = {
+                f
+            });
+            // destructuring assign with element access
+            ({ f: _super_method5()  } = {
+                f
+            });
+        })();
+    }
+}

tests/tsc-references/async/es2017/asyncUseStrict_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,39 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _func() {
+    _func = _asyncToGenerator(function*() {
+        "use strict";
+        var b = (yield p) || a;
+    });
+    return _func.apply(this, arguments);
+}
+function func() {
+    return _func.apply(this, arguments);
+}

tests/tsc-references/async/es2017/asyncUseStrict_es2017/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,29 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _func() {
+    return (_func = (function(fn) {
+        return function() {
+            var self = this, args = arguments;
+            return new Promise(function(resolve, reject) {
+                var gen = fn.apply(self, args);
+                function _next(value) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+                }
+                function _throw(err) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+                }
+                _next(void 0);
+            });
+        };
+    })(function*() {
+        "use strict";
+        yield p;
+    })).apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitBinaryExpression/awaitBinaryExpression1_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,40 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _func() {
+    _func = _asyncToGenerator(function*() {
+        before();
+        var b = (yield p) || a;
+        after();
+    });
+    return _func.apply(this, arguments);
+}
+function func() {
+    return _func.apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitBinaryExpression/awaitBinaryExpression1_es2017/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,28 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _func() {
+    return (_func = (function(fn) {
+        return function() {
+            var self = this, args = arguments;
+            return new Promise(function(resolve, reject) {
+                var gen = fn.apply(self, args);
+                function _next(value) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+                }
+                function _throw(err) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+                }
+                _next(void 0);
+            });
+        };
+    })(function*() {
+        before(), yield p, after();
+    })).apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitBinaryExpression/awaitBinaryExpression2_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,40 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _func() {
+    _func = _asyncToGenerator(function*() {
+        before();
+        var b = (yield p) && a;
+        after();
+    });
+    return _func.apply(this, arguments);
+}
+function func() {
+    return _func.apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitBinaryExpression/awaitBinaryExpression2_es2017/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,28 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _func() {
+    return (_func = (function(fn) {
+        return function() {
+            var self = this, args = arguments;
+            return new Promise(function(resolve, reject) {
+                var gen = fn.apply(self, args);
+                function _next(value) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+                }
+                function _throw(err) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+                }
+                _next(void 0);
+            });
+        };
+    })(function*() {
+        before(), yield p, after();
+    })).apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitBinaryExpression/awaitBinaryExpression3_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,40 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _func() {
+    _func = _asyncToGenerator(function*() {
+        before();
+        var b = (yield p) + a;
+        after();
+    });
+    return _func.apply(this, arguments);
+}
+function func() {
+    return _func.apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitBinaryExpression/awaitBinaryExpression3_es2017/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,28 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _func() {
+    return (_func = (function(fn) {
+        return function() {
+            var self = this, args = arguments;
+            return new Promise(function(resolve, reject) {
+                var gen = fn.apply(self, args);
+                function _next(value) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+                }
+                function _throw(err) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+                }
+                _next(void 0);
+            });
+        };
+    })(function*() {
+        before(), (yield p) + a, after();
+    })).apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitBinaryExpression/awaitBinaryExpression4_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,40 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _func() {
+    _func = _asyncToGenerator(function*() {
+        before();
+        var b = (yield p, a);
+        after();
+    });
+    return _func.apply(this, arguments);
+}
+function func() {
+    return _func.apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitBinaryExpression/awaitBinaryExpression4_es2017/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,28 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _func() {
+    return (_func = (function(fn) {
+        return function() {
+            var self = this, args = arguments;
+            return new Promise(function(resolve, reject) {
+                var gen = fn.apply(self, args);
+                function _next(value) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+                }
+                function _throw(err) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+                }
+                _next(void 0);
+            });
+        };
+    })(function*() {
+        before(), yield p, after();
+    })).apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitBinaryExpression/awaitBinaryExpression5_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,41 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _func() {
+    _func = _asyncToGenerator(function*() {
+        before();
+        var o;
+        o.a = yield p;
+        after();
+    });
+    return _func.apply(this, arguments);
+}
+function func() {
+    return _func.apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitBinaryExpression/awaitBinaryExpression5_es2017/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,29 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _func() {
+    return (_func = (function(fn) {
+        return function() {
+            var self = this, args = arguments;
+            return new Promise(function(resolve, reject) {
+                var gen = fn.apply(self, args);
+                function _next(value) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+                }
+                function _throw(err) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+                }
+                _next(void 0);
+            });
+        };
+    })(function*() {
+        var o;
+        before(), o.a = yield p, after();
+    })).apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitCallExpression/awaitCallExpression1_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,40 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _func() {
+    _func = _asyncToGenerator(function*() {
+        before();
+        var b = fn(a, a, a);
+        after();
+    });
+    return _func.apply(this, arguments);
+}
+function func() {
+    return _func.apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitCallExpression/awaitCallExpression1_es2017/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,28 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _func() {
+    return (_func = (function(fn) {
+        return function() {
+            var self = this, args = arguments;
+            return new Promise(function(resolve, reject) {
+                var gen = fn.apply(self, args);
+                function _next(value) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+                }
+                function _throw(err) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+                }
+                _next(void 0);
+            });
+        };
+    })(function*() {
+        before(), fn(a, a, a), after();
+    })).apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitCallExpression/awaitCallExpression2_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,40 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _func() {
+    _func = _asyncToGenerator(function*() {
+        before();
+        var b = fn((yield p), a, a);
+        after();
+    });
+    return _func.apply(this, arguments);
+}
+function func() {
+    return _func.apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitCallExpression/awaitCallExpression2_es2017/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,28 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _func() {
+    return (_func = (function(fn) {
+        return function() {
+            var self = this, args = arguments;
+            return new Promise(function(resolve, reject) {
+                var gen = fn.apply(self, args);
+                function _next(value) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+                }
+                function _throw(err) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+                }
+                _next(void 0);
+            });
+        };
+    })(function*() {
+        before(), fn((yield p), a, a), after();
+    })).apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitCallExpression/awaitCallExpression3_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,40 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _func() {
+    _func = _asyncToGenerator(function*() {
+        before();
+        var b = fn(a, (yield p), a);
+        after();
+    });
+    return _func.apply(this, arguments);
+}
+function func() {
+    return _func.apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitCallExpression/awaitCallExpression3_es2017/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,28 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _func() {
+    return (_func = (function(fn) {
+        return function() {
+            var self = this, args = arguments;
+            return new Promise(function(resolve, reject) {
+                var gen = fn.apply(self, args);
+                function _next(value) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+                }
+                function _throw(err) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+                }
+                _next(void 0);
+            });
+        };
+    })(function*() {
+        before(), fn(a, (yield p), a), after();
+    })).apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitCallExpression/awaitCallExpression4_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,40 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _func() {
+    _func = _asyncToGenerator(function*() {
+        before();
+        var b = yield pfn(a, a, a);
+        after();
+    });
+    return _func.apply(this, arguments);
+}
+function func() {
+    return _func.apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitCallExpression/awaitCallExpression4_es2017/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,28 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _func() {
+    return (_func = (function(fn) {
+        return function() {
+            var self = this, args = arguments;
+            return new Promise(function(resolve, reject) {
+                var gen = fn.apply(self, args);
+                function _next(value) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+                }
+                function _throw(err) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+                }
+                _next(void 0);
+            });
+        };
+    })(function*() {
+        before(), yield pfn(a, a, a), after();
+    })).apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitCallExpression/awaitCallExpression5_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,40 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _func() {
+    _func = _asyncToGenerator(function*() {
+        before();
+        var b = o.fn(a, a, a);
+        after();
+    });
+    return _func.apply(this, arguments);
+}
+function func() {
+    return _func.apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitCallExpression/awaitCallExpression5_es2017/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,28 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _func() {
+    return (_func = (function(fn) {
+        return function() {
+            var self = this, args = arguments;
+            return new Promise(function(resolve, reject) {
+                var gen = fn.apply(self, args);
+                function _next(value) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+                }
+                function _throw(err) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+                }
+                _next(void 0);
+            });
+        };
+    })(function*() {
+        before(), o.fn(a, a, a), after();
+    })).apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitCallExpression/awaitCallExpression6_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,40 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _func() {
+    _func = _asyncToGenerator(function*() {
+        before();
+        var b = o.fn((yield p), a, a);
+        after();
+    });
+    return _func.apply(this, arguments);
+}
+function func() {
+    return _func.apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitCallExpression/awaitCallExpression6_es2017/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,28 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _func() {
+    return (_func = (function(fn) {
+        return function() {
+            var self = this, args = arguments;
+            return new Promise(function(resolve, reject) {
+                var gen = fn.apply(self, args);
+                function _next(value) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+                }
+                function _throw(err) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+                }
+                _next(void 0);
+            });
+        };
+    })(function*() {
+        before(), o.fn((yield p), a, a), after();
+    })).apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitCallExpression/awaitCallExpression7_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,40 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _func() {
+    _func = _asyncToGenerator(function*() {
+        before();
+        var b = o.fn(a, (yield p), a);
+        after();
+    });
+    return _func.apply(this, arguments);
+}
+function func() {
+    return _func.apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitCallExpression/awaitCallExpression7_es2017/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,28 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _func() {
+    return (_func = (function(fn) {
+        return function() {
+            var self = this, args = arguments;
+            return new Promise(function(resolve, reject) {
+                var gen = fn.apply(self, args);
+                function _next(value) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+                }
+                function _throw(err) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+                }
+                _next(void 0);
+            });
+        };
+    })(function*() {
+        before(), o.fn(a, (yield p), a), after();
+    })).apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitCallExpression/awaitCallExpression8_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,40 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _func() {
+    _func = _asyncToGenerator(function*() {
+        before();
+        var b = (yield po).fn(a, a, a);
+        after();
+    });
+    return _func.apply(this, arguments);
+}
+function func() {
+    return _func.apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitCallExpression/awaitCallExpression8_es2017/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,28 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _func() {
+    return (_func = (function(fn) {
+        return function() {
+            var self = this, args = arguments;
+            return new Promise(function(resolve, reject) {
+                var gen = fn.apply(self, args);
+                function _next(value) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+                }
+                function _throw(err) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+                }
+                _next(void 0);
+            });
+        };
+    })(function*() {
+        before(), (yield po).fn(a, a, a), after();
+    })).apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitClassExpression_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,39 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _func() {
+    _func = _asyncToGenerator(function*() {
+        class D extends yield p {
+        }
+    });
+    return _func.apply(this, arguments);
+}
+function func() {
+    return _func.apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitClassExpression_es2017/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,29 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _func() {
+    return (_func = (function(fn) {
+        return function() {
+            var self = this, args = arguments;
+            return new Promise(function(resolve, reject) {
+                var gen = fn.apply(self, args);
+                function _next(value) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+                }
+                function _throw(err) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+                }
+                _next(void 0);
+            });
+        };
+    })(function*() {
+        class D extends yield p {
+        }
+    })).apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitInheritedPromise_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,38 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _f() {
+    _f = _asyncToGenerator(function*() {
+        yield a;
+    });
+    return _f.apply(this, arguments);
+}
+function f() {
+    return _f.apply(this, arguments);
+}

tests/tsc-references/async/es2017/awaitInheritedPromise_es2017/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,28 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _f() {
+    return (_f = (function(fn) {
+        return function() {
+            var self = this, args = arguments;
+            return new Promise(function(resolve, reject) {
+                var gen = fn.apply(self, args);
+                function _next(value) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+                }
+                function _throw(err) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+                }
+                _next(void 0);
+            });
+        };
+    })(function*() {
+        yield a;
+    })).apply(this, arguments);
+}

tests/tsc-references/async/es2017/await_unaryExpression_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,66 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _bar() {
+    _bar = // @target: es2017
+    _asyncToGenerator(function*() {
+        !(yield 42); // OK
+    });
+    return _bar.apply(this, arguments);
+}
+function bar() {
+    return _bar.apply(this, arguments);
+}
+function _bar1() {
+    _bar1 = _asyncToGenerator(function*() {
+        +(yield 42); // OK
+    });
+    return _bar1.apply(this, arguments);
+}
+function bar1() {
+    return _bar1.apply(this, arguments);
+}
+function _bar3() {
+    _bar3 = _asyncToGenerator(function*() {
+        -(yield 42); // OK
+    });
+    return _bar3.apply(this, arguments);
+}
+function bar3() {
+    return _bar3.apply(this, arguments);
+}
+function _bar4() {
+    _bar4 = _asyncToGenerator(function*() {
+        ~(yield 42); // OK
+    });
+    return _bar4.apply(this, arguments);
+}
+function bar4() {
+    return _bar4.apply(this, arguments);
+}

tests/tsc-references/async/es2017/await_unaryExpression_es2017/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,44 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(void 0);
+        });
+    };
+}
+function _bar() {
+    return (_bar = _asyncToGenerator(function*() {
+        yield 42;
+    })).apply(this, arguments);
+}
+function _bar1() {
+    return (_bar1 = _asyncToGenerator(function*() {
+        yield 42;
+    })).apply(this, arguments);
+}
+function _bar3() {
+    return (_bar3 = _asyncToGenerator(function*() {
+        yield 42;
+    })).apply(this, arguments);
+}
+function _bar4() {
+    return (_bar4 = _asyncToGenerator(function*() {
+        yield 42;
+    })).apply(this, arguments);
+}

tests/tsc-references/async/es2017/await_unaryExpression_es2017_1/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,75 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _bar() {
+    _bar = // @target: es2017
+    _asyncToGenerator(function*() {
+        !(yield 42); // OK
+    });
+    return _bar.apply(this, arguments);
+}
+function bar() {
+    return _bar.apply(this, arguments);
+}
+function _bar1() {
+    _bar1 = _asyncToGenerator(function*() {
+        delete (yield 42); // OK
+    });
+    return _bar1.apply(this, arguments);
+}
+function bar1() {
+    return _bar1.apply(this, arguments);
+}
+function _bar2() {
+    _bar2 = _asyncToGenerator(function*() {
+        delete (yield 42); // OK
+    });
+    return _bar2.apply(this, arguments);
+}
+function bar2() {
+    return _bar2.apply(this, arguments);
+}
+function _bar3() {
+    _bar3 = _asyncToGenerator(function*() {
+        void (yield 42);
+    });
+    return _bar3.apply(this, arguments);
+}
+function bar3() {
+    return _bar3.apply(this, arguments);
+}
+function _bar4() {
+    _bar4 = _asyncToGenerator(function*() {
+        +(yield 42);
+    });
+    return _bar4.apply(this, arguments);
+}
+function bar4() {
+    return _bar4.apply(this, arguments);
+}

tests/tsc-references/async/es2017/await_unaryExpression_es2017_1/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,49 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(void 0);
+        });
+    };
+}
+function _bar() {
+    return (_bar = _asyncToGenerator(function*() {
+        yield 42;
+    })).apply(this, arguments);
+}
+function _bar1() {
+    return (_bar1 = _asyncToGenerator(function*() {
+        delete (yield 42);
+    })).apply(this, arguments);
+}
+function _bar2() {
+    return (_bar2 = _asyncToGenerator(function*() {
+        delete (yield 42);
+    })).apply(this, arguments);
+}
+function _bar3() {
+    return (_bar3 = _asyncToGenerator(function*() {
+        yield 42;
+    })).apply(this, arguments);
+}
+function _bar4() {
+    return (_bar4 = _asyncToGenerator(function*() {
+        yield 42;
+    })).apply(this, arguments);
+}

tests/tsc-references/async/es2017/await_unaryExpression_es2017_2/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,57 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _bar1() {
+    _bar1 = // @target: es2017
+    _asyncToGenerator(function*() {
+        delete (yield 42);
+    });
+    return _bar1.apply(this, arguments);
+}
+function bar1() {
+    return _bar1.apply(this, arguments);
+}
+function _bar2() {
+    _bar2 = _asyncToGenerator(function*() {
+        delete (yield 42);
+    });
+    return _bar2.apply(this, arguments);
+}
+function bar2() {
+    return _bar2.apply(this, arguments);
+}
+function _bar3() {
+    _bar3 = _asyncToGenerator(function*() {
+        void (yield 42);
+    });
+    return _bar3.apply(this, arguments);
+}
+function bar3() {
+    return _bar3.apply(this, arguments);
+}

tests/tsc-references/async/es2017/await_unaryExpression_es2017_2/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,39 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(void 0);
+        });
+    };
+}
+function _bar1() {
+    return (_bar1 = _asyncToGenerator(function*() {
+        delete (yield 42);
+    })).apply(this, arguments);
+}
+function _bar2() {
+    return (_bar2 = _asyncToGenerator(function*() {
+        delete (yield 42);
+    })).apply(this, arguments);
+}
+function _bar3() {
+    return (_bar3 = _asyncToGenerator(function*() {
+        yield 42;
+    })).apply(this, arguments);
+}

tests/tsc-references/async/es2017/functionDeclarations/asyncFunctionDeclaration11_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,39 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _await() {
+    _await = // @target: es2017
+    // @noEmitHelpers: true
+    _asyncToGenerator(function*() {
+    });
+    return _await.apply(this, arguments);
+}
+function _await1() {
+    return _await.apply(this, arguments);
+}

tests/tsc-references/async/es2017/functionDeclarations/asyncFunctionDeclaration11_es2017/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,27 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _await() {
+    return (_await = (function(fn) {
+        return function() {
+            var self = this, args = arguments;
+            return new Promise(function(resolve, reject) {
+                var gen = fn.apply(self, args);
+                function _next(value) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+                }
+                function _throw(err) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+                }
+                _next(void 0);
+            });
+        };
+    })(function*() {
+    })).apply(this, arguments);
+}

tests/tsc-references/async/es2017/functionDeclarations/asyncFunctionDeclaration13_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,41 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _foo() {
+    _foo = // @target: es2017
+    // @noEmitHelpers: true
+    _asyncToGenerator(function*() {
+        // Legal to use 'await' in a type context.
+        var v;
+    });
+    return _foo.apply(this, arguments);
+}
+function foo() {
+    return _foo.apply(this, arguments);
+}

tests/tsc-references/async/es2017/functionDeclarations/asyncFunctionDeclaration13_es2017/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,27 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _foo() {
+    return (_foo = (function(fn) {
+        return function() {
+            var self = this, args = arguments;
+            return new Promise(function(resolve, reject) {
+                var gen = fn.apply(self, args);
+                function _next(value) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+                }
+                function _throw(err) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+                }
+                _next(void 0);
+            });
+        };
+    })(function*() {
+    })).apply(this, arguments);
+}

tests/tsc-references/async/es2017/functionDeclarations/asyncFunctionDeclaration14_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,40 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _foo() {
+    _foo = // @target: es2017
+    // @noEmitHelpers: true
+    _asyncToGenerator(function*() {
+        return;
+    });
+    return _foo.apply(this, arguments);
+}
+function foo() {
+    return _foo.apply(this, arguments);
+}

tests/tsc-references/async/es2017/functionDeclarations/asyncFunctionDeclaration14_es2017/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,27 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _foo() {
+    return (_foo = (function(fn) {
+        return function() {
+            var self = this, args = arguments;
+            return new Promise(function(resolve, reject) {
+                var gen = fn.apply(self, args);
+                function _next(value) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+                }
+                function _throw(err) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+                }
+                _next(void 0);
+            });
+        };
+    })(function*() {
+    })).apply(this, arguments);
+}

tests/tsc-references/async/es2017/functionDeclarations/asyncFunctionDeclaration1_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,39 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _foo() {
+    _foo = // @target: es2017
+    // @noEmitHelpers: true
+    _asyncToGenerator(function*() {
+    });
+    return _foo.apply(this, arguments);
+}
+function foo() {
+    return _foo.apply(this, arguments);
+}

tests/tsc-references/async/es2017/functionDeclarations/asyncFunctionDeclaration1_es2017/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,27 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _foo() {
+    return (_foo = (function(fn) {
+        return function() {
+            var self = this, args = arguments;
+            return new Promise(function(resolve, reject) {
+                var gen = fn.apply(self, args);
+                function _next(value) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+                }
+                function _throw(err) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+                }
+                _next(void 0);
+            });
+        };
+    })(function*() {
+    })).apply(this, arguments);
+}

tests/tsc-references/async/es2017/functionDeclarations/asyncFunctionDeclaration2_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,4 @@
+// @target: es2017
+// @noEmitHelpers: true
+function f(_await) {
+}

tests/tsc-references/async/es2017/functionDeclarations/asyncFunctionDeclaration3_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,4 @@
+// @target: es2017
+// @noEmitHelpers: true
+function f(_await = _await) {
+}

tests/tsc-references/async/es2017/functionDeclarations/asyncFunctionDeclaration4_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,4 @@
+// @target: es2017
+// @noEmitHelpers: true
+function _await() {
+}

tests/tsc-references/async/es2017/functionDeclarations/asyncFunctionDeclaration8_es2017/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,5 @@
+// @target: es2017
+// @noEmitHelpers: true
+var v = {
+    [await]: foo
+};

tests/tsc-references/async/es5/asyncAliasReturnType_es5/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,37 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _f() {
+    _f = _asyncToGenerator(function*() {
+    });
+    return _f.apply(this, arguments);
+}
+function f() {
+    return _f.apply(this, arguments);
+}

tests/tsc-references/async/es5/asyncAliasReturnType_es5/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,27 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _f() {
+    return (_f = (function(fn) {
+        return function() {
+            var self = this, args = arguments;
+            return new Promise(function(resolve, reject) {
+                var gen = fn.apply(self, args);
+                function _next(value) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+                }
+                function _throw(err) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+                }
+                _next(void 0);
+            });
+        };
+    })(function*() {
+    })).apply(this, arguments);
+}

tests/tsc-references/async/es5/asyncArrowFunction/arrowFunctionWithParameterNameAsync_es5/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,5 @@
+// @target: ES5
+// @lib: es5,es2015.promise
+// @noEmitHelpers: true
+const x = (async)=>async
+;

tests/tsc-references/async/es5/asyncArrowFunction/asyncArrowFunction10_es5/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,36 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+// @target: ES5
+// @lib: es5,es2015.promise
+// @noEmitHelpers: true
+var foo = _asyncToGenerator(function*() {
+    // Legal to use 'await' in a type context.
+    var v;
+});

tests/tsc-references/async/es5/asyncArrowFunction/asyncArrowFunction10_es5/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,25 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+!function(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(void 0);
+        });
+    };
+}(function*() {
+});

tests/tsc-references/async/es5/asyncArrowFunction/asyncArrowFunction11_es5/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,43 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+// @target: es5
+// @lib: esnext, dom
+// @downlevelIteration: true
+// https://github.com/Microsoft/TypeScript/issues/24722
+class A {
+    constructor(){
+        this.b = _asyncToGenerator((function*(...args) {
+            yield Promise.resolve();
+            const obj = {
+                ["a"]: ()=>this
+            }; // computed property name after `await` triggers case
+        }).bind(this)).bind(this);
+    }
+}

tests/tsc-references/async/es5/asyncArrowFunction/asyncArrowFunction1_es5/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,34 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+// @target: ES5
+// @lib: es5,es2015.promise
+// @noEmitHelpers: true
+var foo = _asyncToGenerator(function*() {
+});

tests/tsc-references/async/es5/asyncArrowFunction/asyncArrowFunction1_es5/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,25 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+!function(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(void 0);
+        });
+    };
+}(function*() {
+});

tests/tsc-references/async/es5/asyncArrowFunction/asyncArrowFunction2_es5/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,5 @@
+// @target: ES5
+// @lib: es5,es2015.promise
+// @noEmitHelpers: true
+var f = (_await)=>{
+};

tests/tsc-references/async/es5/asyncArrowFunction/asyncArrowFunction3_es5/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,5 @@
+// @target: ES5
+// @lib: es5,es2015.promise
+// @noEmitHelpers: true
+function f(_await = _await) {
+}

tests/tsc-references/async/es5/asyncArrowFunction/asyncArrowFunction4_es5/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,5 @@
+// @target: ES5
+// @lib: es5,es2015.promise
+// @noEmitHelpers: true
+var _await = ()=>{
+};

tests/tsc-references/async/es5/asyncArrowFunction/asyncArrowFunctionCapturesArguments_es5/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,41 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+// @target: ES5
+// @lib: es5,es2015.promise
+// @noEmitHelpers: true
+class C {
+    method() {
+        function other() {
+        }
+        var fn = _asyncToGenerator((function*() {
+            return yield other.apply(this, arguments);
+        }).bind(this)).bind(this);
+    }
+}

tests/tsc-references/async/es5/asyncArrowFunction/asyncArrowFunctionCapturesThis_es5/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,39 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+// @target: ES5
+// @lib: es5,es2015.promise
+// @noEmitHelpers: true
+class C {
+    method() {
+        var fn = _asyncToGenerator((function*() {
+            return yield this;
+        }).bind(this)).bind(this);
+    }
+}

tests/tsc-references/async/es5/asyncArrowFunction/asyncUnParenthesizedArrowFunction_es5/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,35 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+const x = _asyncToGenerator(function*(i) {
+    return yield someOtherFunction(i);
+});
+const x1 = _asyncToGenerator(function*(i) {
+    return yield someOtherFunction(i);
+});

tests/tsc-references/async/es5/asyncArrowFunction/asyncUnParenthesizedArrowFunction_es5/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,29 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(void 0);
+        });
+    };
+}
+_asyncToGenerator(function*(i) {
+    return yield someOtherFunction(i);
+}), _asyncToGenerator(function*(i) {
+    return yield someOtherFunction(i);
+});

tests/tsc-references/async/es5/asyncAwaitIsolatedModules_es5/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,149 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _f0() {
+    _f0 = _asyncToGenerator(function*() {
+    });
+    return _f0.apply(this, arguments);
+}
+function f0() {
+    return _f0.apply(this, arguments);
+}
+function _f1() {
+    _f1 = _asyncToGenerator(function*() {
+    });
+    return _f1.apply(this, arguments);
+}
+function f1() {
+    return _f1.apply(this, arguments);
+}
+function _f3() {
+    _f3 = _asyncToGenerator(function*() {
+    });
+    return _f3.apply(this, arguments);
+}
+function f3() {
+    return _f3.apply(this, arguments);
+}
+let f4 = function() {
+    var _ref = _asyncToGenerator(function*() {
+    });
+    return function() {
+        return _ref.apply(this, arguments);
+    };
+}();
+let f5 = function() {
+    var _ref = _asyncToGenerator(function*() {
+    });
+    return function() {
+        return _ref.apply(this, arguments);
+    };
+}();
+let f6 = function() {
+    var _ref = _asyncToGenerator(function*() {
+    });
+    return function() {
+        return _ref.apply(this, arguments);
+    };
+}();
+let f7 = _asyncToGenerator(function*() {
+});
+let f8 = _asyncToGenerator(function*() {
+});
+let f9 = _asyncToGenerator(function*() {
+});
+let f10 = _asyncToGenerator(function*() {
+    return p;
+});
+let f11 = _asyncToGenerator(function*() {
+    return mp;
+});
+let f12 = _asyncToGenerator(function*() {
+    return mp;
+});
+let f13 = _asyncToGenerator(function*() {
+    return p;
+});
+let o = {
+    m1 () {
+        return _asyncToGenerator(function*() {
+        })();
+    },
+    m2 () {
+        return _asyncToGenerator(function*() {
+        })();
+    },
+    m3 () {
+        return _asyncToGenerator(function*() {
+        })();
+    }
+};
+class C {
+    m1() {
+        return _asyncToGenerator(function*() {
+        })();
+    }
+    m2() {
+        return _asyncToGenerator(function*() {
+        })();
+    }
+    m3() {
+        return _asyncToGenerator(function*() {
+        })();
+    }
+    static m4() {
+        return _asyncToGenerator(function*() {
+        })();
+    }
+    static m5() {
+        return _asyncToGenerator(function*() {
+        })();
+    }
+    static m6() {
+        return _asyncToGenerator(function*() {
+        })();
+    }
+}
+var M;
+(function(M) {
+    function _f1() {
+        _f1 = _asyncToGenerator(function*() {
+        });
+        return _f1.apply(this, arguments);
+    }
+    function f1() {
+        return _f1.apply(this, arguments);
+    }
+    M.f1 = f1;
+})(M || (M = {
+}));
+// @target: ES5
+// @lib: es5,es2015.promise
+// @isolatedModules: true
+export { };

tests/tsc-references/async/es5/asyncAwaitIsolatedModules_es5/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,62 @@
+var M;
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(void 0);
+        });
+    };
+}
+function _f0() {
+    return (_f0 = _asyncToGenerator(function*() {
+    })).apply(this, arguments);
+}
+function _f1() {
+    return (_f1 = _asyncToGenerator(function*() {
+    })).apply(this, arguments);
+}
+function _f3() {
+    return (_f3 = _asyncToGenerator(function*() {
+    })).apply(this, arguments);
+}
+_asyncToGenerator(function*() {
+}), _asyncToGenerator(function*() {
+}), _asyncToGenerator(function*() {
+}), _asyncToGenerator(function*() {
+}), _asyncToGenerator(function*() {
+}), _asyncToGenerator(function*() {
+}), _asyncToGenerator(function*() {
+    return p;
+}), _asyncToGenerator(function*() {
+    return mp;
+}), _asyncToGenerator(function*() {
+    return mp;
+}), _asyncToGenerator(function*() {
+    return p;
+}), (function(M) {
+    function _f1() {
+        return (_f1 = _asyncToGenerator(function*() {
+        })).apply(this, arguments);
+    }
+    M.f1 = function() {
+        return _f1.apply(this, arguments);
+    };
+})(M || (M = {
+}));
+export { };

tests/tsc-references/async/es5/asyncAwaitNestedClasses_es5/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,50 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+var _class;
+// @target: ES5
+// @lib: es5,es2015.promise
+// @noEmitHelpers: true
+// https://github.com/Microsoft/TypeScript/issues/20744
+class A {
+}
+A.B = (_class = class B {
+    static func2() {
+        return new Promise((resolve)=>{
+            resolve(null);
+        });
+    }
+}, _class.C = class C {
+    static func() {
+        return _asyncToGenerator(function*() {
+            yield _class.func2();
+        })();
+    }
+}, _class);
+A.B.C.func();

tests/tsc-references/async/es5/asyncAwaitNestedClasses_es5/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,39 @@
+var _class;
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+class A {
+}
+(_class = class {
+    static func2() {
+        return new Promise((resolve)=>{
+            resolve(null);
+        });
+    }
+}).C = class {
+    static func() {
+        return (function(fn) {
+            return function() {
+                var self = this, args = arguments;
+                return new Promise(function(resolve, reject) {
+                    var gen = fn.apply(self, args);
+                    function _next(value) {
+                        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+                    }
+                    function _throw(err) {
+                        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+                    }
+                    _next(void 0);
+                });
+            };
+        })(function*() {
+            yield _class.func2();
+        })();
+    }
+}, A.B = _class, A.B.C.func();

tests/tsc-references/async/es5/asyncAwait_es5/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,157 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _f0() {
+    _f0 = _asyncToGenerator(function*() {
+    });
+    return _f0.apply(this, arguments);
+}
+function f0() {
+    return _f0.apply(this, arguments);
+}
+function _f1() {
+    _f1 = _asyncToGenerator(function*() {
+    });
+    return _f1.apply(this, arguments);
+}
+function f1() {
+    return _f1.apply(this, arguments);
+}
+function _f3() {
+    _f3 = _asyncToGenerator(function*() {
+    });
+    return _f3.apply(this, arguments);
+}
+function f3() {
+    return _f3.apply(this, arguments);
+}
+let f4 = function() {
+    var _ref = _asyncToGenerator(function*() {
+    });
+    return function() {
+        return _ref.apply(this, arguments);
+    };
+}();
+let f5 = function() {
+    var _ref = _asyncToGenerator(function*() {
+    });
+    return function() {
+        return _ref.apply(this, arguments);
+    };
+}();
+let f6 = function() {
+    var _ref = _asyncToGenerator(function*() {
+    });
+    return function() {
+        return _ref.apply(this, arguments);
+    };
+}();
+let f7 = _asyncToGenerator(function*() {
+});
+let f8 = _asyncToGenerator(function*() {
+});
+let f9 = _asyncToGenerator(function*() {
+});
+let f10 = _asyncToGenerator(function*() {
+    return p;
+});
+let f11 = _asyncToGenerator(function*() {
+    return mp;
+});
+let f12 = _asyncToGenerator(function*() {
+    return mp;
+});
+let f13 = _asyncToGenerator(function*() {
+    return p;
+});
+let o = {
+    m1 () {
+        return _asyncToGenerator(function*() {
+        })();
+    },
+    m2 () {
+        return _asyncToGenerator(function*() {
+        })();
+    },
+    m3 () {
+        return _asyncToGenerator(function*() {
+        })();
+    }
+};
+class C {
+    m1() {
+        return _asyncToGenerator(function*() {
+        })();
+    }
+    m2() {
+        return _asyncToGenerator(function*() {
+        })();
+    }
+    m3() {
+        return _asyncToGenerator(function*() {
+        })();
+    }
+    static m4() {
+        return _asyncToGenerator(function*() {
+        })();
+    }
+    static m5() {
+        return _asyncToGenerator(function*() {
+        })();
+    }
+    static m6() {
+        return _asyncToGenerator(function*() {
+        })();
+    }
+}
+var M;
+(function(M) {
+    function _f1() {
+        _f1 = _asyncToGenerator(function*() {
+        });
+        return _f1.apply(this, arguments);
+    }
+    function f1() {
+        return _f1.apply(this, arguments);
+    }
+    M.f1 = f1;
+})(M || (M = {
+}));
+function _f14() {
+    _f14 = _asyncToGenerator(function*() {
+        block: {
+            yield 1;
+            break block;
+        }
+    });
+    return _f14.apply(this, arguments);
+}
+function f14() {
+    return _f14.apply(this, arguments);
+}

tests/tsc-references/async/es5/asyncAwait_es5/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,69 @@
+var M;
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(void 0);
+        });
+    };
+}
+function _f0() {
+    return (_f0 = _asyncToGenerator(function*() {
+    })).apply(this, arguments);
+}
+function _f1() {
+    return (_f1 = _asyncToGenerator(function*() {
+    })).apply(this, arguments);
+}
+function _f3() {
+    return (_f3 = _asyncToGenerator(function*() {
+    })).apply(this, arguments);
+}
+function _f14() {
+    return (_f14 = _asyncToGenerator(function*() {
+        block: {
+            yield 1;
+            break block;
+        }
+    })).apply(this, arguments);
+}
+_asyncToGenerator(function*() {
+}), _asyncToGenerator(function*() {
+}), _asyncToGenerator(function*() {
+}), _asyncToGenerator(function*() {
+}), _asyncToGenerator(function*() {
+}), _asyncToGenerator(function*() {
+}), _asyncToGenerator(function*() {
+    return p;
+}), _asyncToGenerator(function*() {
+    return mp;
+}), _asyncToGenerator(function*() {
+    return mp;
+}), _asyncToGenerator(function*() {
+    return p;
+}), (function(M) {
+    function _f1() {
+        return (_f1 = _asyncToGenerator(function*() {
+        })).apply(this, arguments);
+    }
+    M.f1 = function() {
+        return _f1.apply(this, arguments);
+    };
+})(M || (M = {
+}));

tests/tsc-references/async/es5/asyncImportedPromise_es5/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,42 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+// @target: es5
+// @lib: es5,es2015.promise
+// @module: commonjs
+// @filename: task.ts
+export class Task extends Promise {
+}
+class Test {
+    example() {
+        return _asyncToGenerator(function*() {
+            return;
+        })();
+    }
+}

tests/tsc-references/async/es5/asyncImportedPromise_es5/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,2 @@
+export class Task extends Promise {
+}

tests/tsc-references/async/es5/asyncMethodWithSuper_es5/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,97 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+// @target: ES5
+// @lib: es5,es2015.promise
+// @noEmitHelpers: true
+class A {
+    x() {
+    }
+    y() {
+    }
+}
+class B extends A {
+    // async method with only call/get on 'super' does not require a binding
+    simple() {
+        var _super_x = (..._args)=>super.x(..._args)
+        , _super_y = (..._args)=>super.y(..._args)
+        , _super_method = (..._args)=>super["x"](..._args)
+        , _super_x1 = ()=>super.x
+        , _super_method1 = ()=>super["x"]
+        ;
+        return _asyncToGenerator(function*() {
+            // call with property access
+            _super_x();
+            // call additional property.
+            _super_y();
+            // call with element access
+            _super_method();
+            // property access (read)
+            const a = _super_x1();
+            // element access (read)
+            const b = _super_method1();
+        })();
+    }
+    // async method with assignment/destructuring on 'super' requires a binding
+    advanced() {
+        var _super_x = (..._args)=>super.x(..._args)
+        , _super_method = (..._args)=>super["x"](..._args)
+        , _super_x3 = ()=>super.x
+        , _super_method3 = ()=>super["x"]
+        , _super_x4 = (_args)=>// property access (assign)
+            super.x = _args
+        , _super_method4 = (_args)=>// element access (assign)
+            super["x"] = _args
+        , _super_x5 = ()=>super.x
+        , _super_method5 = ()=>super["x"]
+        ;
+        return _asyncToGenerator(function*() {
+            const f = ()=>{
+            };
+            // call with property access
+            _super_x();
+            // call with element access
+            _super_method();
+            // property access (read)
+            const a = _super_x3();
+            // element access (read)
+            const b = _super_method3();
+            _super_x4(f);
+            _super_method4(f);
+            // destructuring assign with property access
+            ({ f: _super_x5()  } = {
+                f
+            });
+            // destructuring assign with element access
+            ({ f: _super_method5()  } = {
+                f
+            });
+        })();
+    }
+}

tests/tsc-references/async/es5/asyncMultiFile_es5/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,43 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _f() {
+    _f = // @target: es5
+    // @lib: es5,es2015.promise
+    // @filename: a.ts
+    _asyncToGenerator(function*() {
+    });
+    return _f.apply(this, arguments);
+}
+function f() {
+    return _f.apply(this, arguments);
+}
+// @filename: b.ts
+function g() {
+}

tests/tsc-references/async/es5/asyncMultiFile_es5/input.ts/es2015.2.minified/output.js

@@ -0,0 +1,27 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg), value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _f() {
+    return (_f = (function(fn) {
+        return function() {
+            var self = this, args = arguments;
+            return new Promise(function(resolve, reject) {
+                var gen = fn.apply(self, args);
+                function _next(value) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+                }
+                function _throw(err) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+                }
+                _next(void 0);
+            });
+        };
+    })(function*() {
+    })).apply(this, arguments);
+}

tests/tsc-references/async/es5/asyncUseStrict_es5/input.ts/es2015.1.normal/output.js

@@ -0,0 +1,39 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _func() {
+    _func = _asyncToGenerator(function*() {
+        "use strict";
+        var b = (yield p) || a;
+    });
+    return _func.apply(this, arguments);
+}
+function func() {
+    return _func.apply(this, arguments);
+}