Fix for #4943 "Calling an async function with default parameter as function for arguments checking handled synchonous" (#5688)

* moved applying arguments inside new Promise handler block

* updated test fixture to reflect change

* corrected the apply to use correct scope and arguments

* added regression test for issue #4943, added async-to-generator/async-default-arguments test

* added regression test for issue #4943

* switched back to using arrow function, since now pointing to v7 release base branch

* simplified async-to-generator regression test for issue #4943, imrproved change to self/arguments refs by using arrow function on returned promise

* updated text fixtures

* removed es2015 preset usage from issue #4943 regression exec test

* added use strict to test fixture

* added use strict to test fixture

* added destructing transform to test options

* removed use strict from exec test

* added parameters & destructing transforms to test

packages/babel-core/test/fixtures/transformation/misc/regression-2892/expected.js

@@ -46,7 +46,7 @@ var foo = function () {
   };
 }();
 
-function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(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 _next(value) { step("next", value); } function _throw(err) { step("throw", err); } _next(); }); }; }
+function _asyncToGenerator(fn) { return function () { var _this = this, _arguments = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(_this, _arguments); function step(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 _next(value) { step("next", value); } function _throw(err) { step("throw", err); } _next(); }); }; }
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 

packages/babel-helpers/src/helpers.js

@@ -216,8 +216,8 @@ helpers.asyncGeneratorDelegate = template(`
 helpers.asyncToGenerator = template(`
   (function (fn) {
     return function () {
+      return new Promise((resolve, reject) => {
         var gen = fn.apply(this, arguments);
-      return new Promise(function (resolve, reject) {
         function step(key, arg) {
           try {
             var info = gen[key](arg);

packages/babel-plugin-transform-async-to-generator/test/fixtures/async-to-generator/async-default-arguments/actual.js

@@ -0,0 +1,7 @@
+function mandatory(paramName) {
+  throw new Error(`Missing parameter: ${paramName}`);
+}
+
+async function foo({ a, b = mandatory("b") }) {
+  return Promise.resolve(b);
+}

packages/babel-plugin-transform-async-to-generator/test/fixtures/async-to-generator/async-default-arguments/expected.js

@@ -0,0 +1,15 @@
+let foo = (() => {
+  var _ref2 = babelHelpers.asyncToGenerator(function* (_ref) {
+    let { a, b = mandatory("b") } = _ref;
+
+    return Promise.resolve(b);
+  });
+
+  return function foo(_x) {
+    return _ref2.apply(this, arguments);
+  };
+})();
+
+function mandatory(paramName) {
+  throw new Error(`Missing parameter: ${paramName}`);
+}

packages/babel-plugin-transform-async-to-generator/test/fixtures/async-to-generator/shadowed-promise-import/expected.js

@@ -8,6 +8,6 @@ let foo = (() => {
   };
 })();
 
-function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(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 _next(value) { step("next", value); } function _throw(err) { step("throw", err); } _next(); }); }; }
+function _asyncToGenerator(fn) { return function () { return new Promise((resolve, reject) => { var gen = fn.apply(this, arguments); function step(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 _next(value) { step("next", value); } function _throw(err) { step("throw", err); } _next(); }); }; }
 
 import _Promise from 'somewhere';

packages/babel-plugin-transform-async-to-generator/test/fixtures/async-to-generator/shadowed-promise-nested/expected.js

@@ -20,6 +20,6 @@ let foo = (() => {
   };
 })();
 
-function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(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 _next(value) { step("next", value); } function _throw(err) { step("throw", err); } _next(); }); }; }
+function _asyncToGenerator(fn) { return function () { return new Promise((resolve, reject) => { var gen = fn.apply(this, arguments); function step(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 _next(value) { step("next", value); } function _throw(err) { step("throw", err); } _next(); }); }; }
 
 let _Promise;

packages/babel-plugin-transform-async-to-generator/test/fixtures/async-to-generator/shadowed-promise/expected.js

@@ -10,6 +10,6 @@ let foo = (() => {
   };
 })();
 
-function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(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 _next(value) { step("next", value); } function _throw(err) { step("throw", err); } _next(); }); }; }
+function _asyncToGenerator(fn) { return function () { return new Promise((resolve, reject) => { var gen = fn.apply(this, arguments); function step(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 _next(value) { step("next", value); } function _throw(err) { step("throw", err); } _next(); }); }; }
 
 let _Promise;

packages/babel-plugin-transform-async-to-generator/test/fixtures/regression/4943/actual.js

@@ -0,0 +1,9 @@
+"use strict";
+
+function mandatory(paramName) {
+  throw new Error(`Missing parameter: ${paramName}`);
+}
+
+async function foo({ a, b = mandatory("b") }) {
+  return Promise.resolve(b);
+}

packages/babel-plugin-transform-async-to-generator/test/fixtures/regression/4943/exec.js

@@ -0,0 +1,19 @@
+"use strict";
+
+function mandatory(paramName) {
+  throw new Error(`Missing parameter: ${paramName}`);
+}
+
+async function foo({ a, b = mandatory("b") } = {}) {
+  return Promise.resolve(b);
+}
+
+return (async () => {
+  assert.doesNotThrow(() => {
+    foo()
+      .then(() => {
+        throw new Error('should not occcur');
+      })
+      .catch(() => true);
+  });
+})();

packages/babel-plugin-transform-async-to-generator/test/fixtures/regression/4943/expected.js

@@ -0,0 +1,21 @@
+"use strict";
+
+let foo = (() => {
+  var _ref = _asyncToGenerator(function* (_ref2) {
+    let a = _ref2.a;
+    var _ref2$b = _ref2.b;
+    let b = _ref2$b === undefined ? mandatory("b") : _ref2$b;
+
+    return Promise.resolve(b);
+  });
+
+  return function foo(_x) {
+    return _ref.apply(this, arguments);
+  };
+})();
+
+function _asyncToGenerator(fn) { return function () { return new Promise((resolve, reject) => { var gen = fn.apply(this, arguments); function step(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 _next(value) { step("next", value); } function _throw(err) { step("throw", err); } _next(); }); }; }
+
+function mandatory(paramName) {
+  throw new Error(`Missing parameter: ${paramName}`);
+}

packages/babel-plugin-transform-async-to-generator/test/fixtures/regression/4943/options.json

@@ -0,0 +1,10 @@
+{
+  "plugins": [
+    "transform-async-to-generator",
+    "transform-es2015-destructuring",
+    "transform-es2015-parameters"
+  ],
+  "parserOpts": {
+    "allowReturnOutsideFunction": true
+  }
+}

packages/babel-plugin-transform-react-constant-elements/test/fixtures/constant-elements/async-function/expected.js

@@ -1,4 +1,4 @@
-function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(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 _next(value) { step("next", value); } function _throw(err) { step("throw", err); } _next(); }); }; }
+function _asyncToGenerator(fn) { return function () { return new Promise((resolve, reject) => { var gen = fn.apply(this, arguments); function step(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 _next(value) { step("next", value); } function _throw(err) { step("throw", err); } _next(); }); }; }
 
 export default {
     function(name) {