Add basic support for await with the pipeline operator

packages/babel-helper-remap-async-to-generator/src/index.js

@@ -13,6 +13,7 @@ const awaitVisitor = {
 
   AwaitExpression(path, { wrapAwait }) {
     const argument = path.get("argument");
+    argument.node.__wasAwait = true;
 
     if (path.parentPath.isYieldExpression()) {
       path.replaceWith(argument.node);

packages/babel-plugin-proposal-pipeline-operator/src/index.js

@@ -15,6 +15,11 @@ export default function() {
 
         let optimizeArrow =
           t.isArrowFunctionExpression(right) && t.isExpression(right.body);
+        const wasAwait =
+          t.isYieldExpression(right) &&
+          right.argument &&
+          right.argument.__wasAwait;
+        const isAwait = t.isAwaitExpression(right) || wasAwait;
         let param;
 
         if (optimizeArrow) {
@@ -24,6 +29,11 @@ export default function() {
           } else if (params.length > 0) {
             optimizeArrow = false;
           }
+        } else if (isAwait) {
+          right.argument = t.sequenceExpression([
+            t.numericLiteral(0),
+            right.argument,
+          ]);
         } else if (t.isIdentifier(right, { name: "eval" })) {
           right = t.sequenceExpression([t.numericLiteral(0), right]);
         }
@@ -44,7 +54,11 @@ export default function() {
 
         const call = optimizeArrow
           ? right.body
-          : t.callExpression(right, [placeholder]);
+          : isAwait
+            ? t[wasAwait ? "yieldExpression" : "awaitExpression"](
+                t.callExpression(right.argument, [placeholder]),
+              )
+            : t.callExpression(right, [placeholder]);
         path.replaceWith(
           t.sequenceExpression([
             t.assignmentExpression("=", placeholder, left),

packages/babel-plugin-proposal-pipeline-operator/test/fixtures/pipeline-operator/async-with-transform-async/actual.js

@@ -0,0 +1,9 @@
+var incPromise = (x) => Promise.resolve(x + 1);
+var double = (x) => x * 2;
+
+var result = async () => 10 |> await incPromise;
+var result2 = async () => 10 |> await incPromise |> double;
+
+function* foo() {
+  return 42 |> (yield 10);
+}

packages/babel-plugin-proposal-pipeline-operator/test/fixtures/pipeline-operator/async-with-transform-async/exec.js

@@ -0,0 +1,20 @@
+var incPromise = (x) => Promise.resolve(x + 1);
+var double = (x) => x * 2;
+
+var result = async () => 10 |> await incPromise;
+var result2 = async () => 10 |> await incPromise |> double;
+
+function* foo() {
+  return 42 |> (yield 10);
+}
+
+return Promise.all([result(), result2()]).then((results) => {
+  var r = results[0];
+  var r2 = results[1];
+  assert.equal(r, 11);
+  assert.equal(r2, 22);
+
+  var fooGen = foo();
+  var amount = fooGen.next().value;
+  assert.equal(fooGen.next(x => x + amount).value, 52);
+});

packages/babel-plugin-proposal-pipeline-operator/test/fixtures/pipeline-operator/async-with-transform-async/expected.js

@@ -0,0 +1,37 @@
+var incPromise = x => Promise.resolve(x + 1);
+
+var double = x => x * 2;
+
+var result =
+/*#__PURE__*/
+function () {
+  var _ref = babelHelpers.asyncToGenerator(function* () {
+    var _;
+
+    return _ = 10, yield (0, incPromise)(_);
+  });
+
+  return function result() {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+var result2 =
+/*#__PURE__*/
+function () {
+  var _ref2 = babelHelpers.asyncToGenerator(function* () {
+    var _ref3, _2;
+
+    return _ref3 = (_2 = 10, yield (0, incPromise)(_2)), double(_ref3);
+  });
+
+  return function result2() {
+    return _ref2.apply(this, arguments);
+  };
+}();
+
+function* foo() {
+  var _3;
+
+  return _3 = 42, (yield 10)(_3);
+}

packages/babel-plugin-proposal-pipeline-operator/test/fixtures/pipeline-operator/async-with-transform-async/options.json

@@ -0,0 +1,6 @@
+{
+  "plugins": ["proposal-pipeline-operator", "external-helpers", "transform-async-to-generator"],
+  "parserOpts": {
+    "allowReturnOutsideFunction": true
+  }
+}

packages/babel-plugin-proposal-pipeline-operator/test/fixtures/pipeline-operator/async/actual.js

@@ -0,0 +1,5 @@
+var incPromise = (x) => Promise.resolve(x + 1);
+var double = (x) => x * 2;
+
+var result = async () => 10 |> await incPromise;
+var result2 = async () => 10 |> await incPromise |> double;

packages/babel-plugin-proposal-pipeline-operator/test/fixtures/pipeline-operator/async/exec.js

@@ -0,0 +1,10 @@
+var incPromise = x => Promise.resolve(x + 1);
+var double = x => x * 2;
+
+var result = async () => 10 |> await incPromise;
+var result2 = async () => 10 |> await incPromise |> double;
+
+return Promise.all([result(), result2()]).then(([r, r2]) => {
+  assert.equal(r, 11);
+  assert.equal(r2, 22);
+});

packages/babel-plugin-proposal-pipeline-operator/test/fixtures/pipeline-operator/async/expected.js

@@ -0,0 +1,15 @@
+var incPromise = x => Promise.resolve(x + 1);
+
+var double = x => x * 2;
+
+var result = async () => {
+  var _;
+
+  return _ = 10, await (0, incPromise)(_);
+};
+
+var result2 = async () => {
+  var _ref, _2;
+
+  return _ref = (_2 = 10, await (0, incPromise)(_2)), double(_ref);
+};

packages/babel-plugin-proposal-pipeline-operator/test/fixtures/pipeline-operator/async/options.json

@@ -0,0 +1,6 @@
+{
+  "minNodeVersion": "7.6.0",
+  "parserOpts": {
+    "allowReturnOutsideFunction": true
+  }
+}