Await promises from sync iterators with for-await

packages/babel-helpers/src/helpers.ts

@@ -16,18 +16,60 @@ const helper = (minVersion: string) => (tpl: TemplateStringsArray) => ({
   ast: () => template.program.ast(tpl),
 });
 
-helpers.asyncIterator = helper("7.0.0-beta.0")`
+helpers.asyncIterator = helper("7.15.9")`
   export default function _asyncIterator(iterable) {
     var method;
     if (typeof Symbol !== "undefined") {
       if (Symbol.asyncIterator) method = iterable[Symbol.asyncIterator];
-      if (method == null && Symbol.iterator) method = iterable[Symbol.iterator];
+      if (method == null && Symbol.iterator) {
+        method = iterable[Symbol.iterator];
+        if (method != null) return new AsyncFromSyncIterator(method.call(iterable));
+      }
     }
     if (method == null) method = iterable["@@asyncIterator"];
-    if (method == null) method = iterable["@@iterator"]
+    if (method == null) {
+      method = iterable["@@iterator"];
+      if (method != null) return new AsyncFromSyncIterator(method.call(iterable));
+    }
     if (method == null) throw new TypeError("Object is not async iterable");
     return method.call(iterable);
   }
+
+  function AsyncFromSyncIterator(s) {
+    AsyncFromSyncIterator = function (s) {
+      this.s = s;
+      this.n = s.next;
+    };
+    AsyncFromSyncIterator.prototype = {
+      /* SyncIterator */ s: null,
+      /* SyncIterator.[[Next]] */ n: null,
+      next: function () {
+        return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
+      },
+      return: function (value) {
+        var ret = this.s.return;
+        if (ret === undefined) return Promise.resolve({ value: value, done: true });
+        return AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments));
+      },
+      throw: function (value) {
+        var thr = this.s.return;
+        if (thr === undefined) return Promise.reject(value);
+        return AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments));
+      },
+    };
+
+    function AsyncFromSyncIteratorContinuation(r) {
+      // This step is _before_ calling AsyncFromSyncIteratorContinuation in the spec.
+      if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object."));
+
+      var done = r.done;
+      return Promise.resolve(r.value).then(function (value) {
+        return { value: value, done: done };
+      });
+    }
+
+    return new AsyncFromSyncIterator(s);
+  }
 `;
 
 helpers.AwaitValue = helper("7.0.0-beta.0")`

packages/babel-plugin-proposal-async-generator-functions/test/fixtures/for-await/create-async-from-sync-iterator/exec.js

@@ -0,0 +1,12 @@
+async function* fn() {
+  for await (const result of [Promise.resolve("ok")]) {
+    return { result };
+  }
+}
+
+return fn().next().then(result => {
+  expect(result).toEqual({
+    done: true,
+    value: { result: "ok" }
+  });
+});

packages/babel-plugin-proposal-async-generator-functions/test/fixtures/for-await/create-async-from-sync-iterator/input.js

@@ -0,0 +1,5 @@
+async function* fn() {
+  for await (const result of [Promise.resolve("ok")]) {
+    return { result };
+  }
+}

packages/babel-plugin-proposal-async-generator-functions/test/fixtures/for-await/create-async-from-sync-iterator/options.json

@@ -0,0 +1,6 @@
+{
+  "plugins": ["proposal-async-generator-functions"],
+  "parserOpts": {
+    "allowReturnOutsideFunction": true
+  }
+}

packages/babel-plugin-proposal-async-generator-functions/test/fixtures/for-await/create-async-from-sync-iterator/output.js

@@ -0,0 +1,35 @@
+function fn() {
+  return _fn.apply(this, arguments);
+}
+
+function _fn() {
+  _fn = babelHelpers.wrapAsyncGenerator(function* () {
+    var _iteratorAbruptCompletion = false;
+    var _didIteratorError = false;
+
+    var _iteratorError;
+
+    try {
+      for (var _iterator = babelHelpers.asyncIterator([Promise.resolve("ok")]), _step; _iteratorAbruptCompletion = !(_step = yield babelHelpers.awaitAsyncGenerator(_iterator.next())).done; _iteratorAbruptCompletion = false) {
+        const result = _step.value;
+        return {
+          result
+        };
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (_iteratorAbruptCompletion && _iterator.return != null) {
+          yield babelHelpers.awaitAsyncGenerator(_iterator.return());
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+  });
+  return _fn.apply(this, arguments);
+}

packages/babel-plugin-proposal-async-generator-functions/test/fixtures/yield-star/create-async-from-sync-iterator/exec.js

@@ -0,0 +1,7 @@
+async function* fn() {
+  yield* [Promise.resolve("ok")] // CreateAsyncFromSyncIterator
+}
+
+return fn().next().then(result => {
+  expect(result).toEqual({ value: "ok", done: false });
+});

packages/babel-plugin-proposal-async-generator-functions/test/fixtures/yield-star/create-async-from-sync-iterator/input.js

@@ -0,0 +1,3 @@
+async function* fn() {
+  yield* [Promise.resolve("ok")] // CreateAsyncFromSyncIterator
+}

packages/babel-plugin-proposal-async-generator-functions/test/fixtures/yield-star/create-async-from-sync-iterator/options.json

@@ -0,0 +1,6 @@
+{
+  "plugins": ["proposal-async-generator-functions"],
+  "parserOpts": {
+    "allowReturnOutsideFunction": true
+  }
+}

packages/babel-plugin-proposal-async-generator-functions/test/fixtures/yield-star/create-async-from-sync-iterator/output.js

@@ -0,0 +1,10 @@
+function fn() {
+  return _fn.apply(this, arguments);
+}
+
+function _fn() {
+  _fn = babelHelpers.wrapAsyncGenerator(function* () {
+    yield* babelHelpers.asyncGeneratorDelegate(babelHelpers.asyncIterator([Promise.resolve("ok")]), babelHelpers.awaitAsyncGenerator); // CreateAsyncFromSyncIterator
+  });
+  return _fn.apply(this, arguments);
+}