Fix async/await memory leak

src/js/harmony-async-await.js

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 (function(global, utils, extrasUtils) {
 
 "use strict";
 
 %CheckIsBootstrapping();
 
@@ skipping 49 matching lines @@
 // The 'awaited' parameter is the value; the generator stands in
 // for the asyncContext, and .promise is the larger promise under
 // construction by the enclosing async function.
 function AsyncFunctionAwait(generator, awaited, outerPromise) {
   // Promise.resolve(awaited).then(
   //     value => AsyncFunctionNext(value),
   //     error => AsyncFunctionThrow(error)
   // );
   var promise = PromiseCastResolved(awaited);
 
-  var onFulfilled =
-      (sentValue) => %_Call(AsyncFunctionNext, generator, sentValue);
+  var onFulfilled = (sentValue) => {
+    %_Call(AsyncFunctionNext, generator, sentValue);
+    // The resulting Promise is a throwaway, so it doesn't matter what it

[caitp, 2016/09/15 20:18:40]

don't we have this same problem in the rejection case?

[Dan Ehrenberg, 2016/09/15 20:24:21]

I don't think so; we don't have the whole chaining thing going on in the
rejection case.

[caitp, 2016/09/15 20:32:23]

Either way, I think it would still be good to add a similar test for

```
async function longLoop2() {
   for (let i = 0; i < 100000; i++) {
     try {
       await thrower();
     } catch (e) {
     }
   }
   out = 1;
}
```

although it might take too long.

[Dan Ehrenberg, 2016/09/15 20:37:58]

Oh, you're actually right. It'd similarly take keeping the whole chain alive to
figure out the rejection that things should resolve to. I reproduced this in a
test, and made a fix in the code, explaining in a comment.

+    // resolves to. What is important is that we don't end up keeping the
+    // whole chain of intermediate Promises alive by returning the value
+    // of AsyncFunctionNext, as that would create a memory leak.
+    return UNDEFINED;
+  };
   var onRejected =
       (sentError) => %_Call(AsyncFunctionThrow, generator, sentError);
 
   // Just forwarding the exception, so no debugEvent for throwawayCapability
   var throwawayCapability = NewPromiseCapability(GlobalPromise, false);
   // The Promise will be thrown away and not handled, but it shouldn't trigger
   // unhandled reject events as its work is done
   SET_PRIVATE(throwawayCapability.promise, promiseHasHandlerSymbol, true);
   PerformPromiseThen(promise, onFulfilled, onRejected, throwawayCapability);
 
@@ skipping 33 matching lines @@
   return RejectPromise(promise, reason, false);
 }
 
 %InstallToContext([
   "async_function_await_caught", AsyncFunctionAwaitCaught,
   "async_function_await_uncaught", AsyncFunctionAwaitUncaught,
   "reject_promise_no_debug_event", RejectPromiseNoDebugEvent,
 ]);
 
 })