OLD | NEW |
---|---|
1 // Copyright 2016 the V8 project authors. All rights reserved. | 1 // Copyright 2016 the V8 project authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 (function(global, utils, extrasUtils) { | 5 (function(global, utils, extrasUtils) { |
6 | 6 |
7 "use strict"; | 7 "use strict"; |
8 | 8 |
9 %CheckIsBootstrapping(); | 9 %CheckIsBootstrapping(); |
10 | 10 |
11 // ------------------------------------------------------------------- | 11 // ------------------------------------------------------------------- |
12 // Imports | 12 // Imports |
13 | 13 |
14 var InternalArray = utils.InternalArray; | |
adamk
2016/09/08 18:58:36
Nit: alphabetize?
Dan Ehrenberg
2016/09/08 22:34:05
Deleted
| |
14 var AsyncFunctionNext; | 15 var AsyncFunctionNext; |
15 var AsyncFunctionThrow; | 16 var AsyncFunctionThrow; |
16 var GlobalPromise; | 17 var GlobalPromise; |
18 var IsPromise; | |
17 var NewPromiseCapability; | 19 var NewPromiseCapability; |
18 var PerformPromiseThen; | 20 var PerformPromiseThen; |
19 var PromiseCastResolved; | 21 var PromiseCreate; |
20 var RejectPromise; | 22 var RejectPromise; |
23 var ResolvePromise; | |
21 | 24 |
22 utils.Import(function(from) { | 25 utils.Import(function(from) { |
23 AsyncFunctionNext = from.AsyncFunctionNext; | 26 AsyncFunctionNext = from.AsyncFunctionNext; |
24 AsyncFunctionThrow = from.AsyncFunctionThrow; | 27 AsyncFunctionThrow = from.AsyncFunctionThrow; |
28 IsPromise = from.IsPromise; | |
25 GlobalPromise = from.GlobalPromise; | 29 GlobalPromise = from.GlobalPromise; |
26 NewPromiseCapability = from.NewPromiseCapability; | 30 NewPromiseCapability = from.NewPromiseCapability; |
27 PromiseCastResolved = from.PromiseCastResolved; | 31 PromiseCreate = from.PromiseCreate; |
28 PerformPromiseThen = from.PerformPromiseThen; | 32 PerformPromiseThen = from.PerformPromiseThen; |
29 RejectPromise = from.RejectPromise; | 33 RejectPromise = from.RejectPromise; |
34 ResolvePromise = from.ResolvePromise; | |
30 }); | 35 }); |
31 | 36 |
37 var promiseAwaitHandlerSymbol = utils.ImportNow("promise_await_handler_symbol"); | |
38 var promiseHandledHintSymbol = | |
39 utils.ImportNow("promise_handled_hint_symbol"); | |
40 | |
32 // ------------------------------------------------------------------- | 41 // ------------------------------------------------------------------- |
33 | 42 |
34 function AsyncFunctionAwait(generator, value) { | 43 function PromiseCastResolved(value) { |
35 // Promise.resolve(value).then( | 44 if (IsPromise(value)) { |
45 return value; | |
46 } else { | |
47 var promise = PromiseCreate(); | |
48 ResolvePromise(promise, value); | |
49 return promise; | |
50 } | |
51 } | |
52 | |
53 function AsyncFunctionAwait(generator, awaited, mark) { | |
54 // Promise.resolve(awaited).then( | |
36 // value => AsyncFunctionNext(value), | 55 // value => AsyncFunctionNext(value), |
37 // error => AsyncFunctionThrow(error) | 56 // error => AsyncFunctionThrow(error) |
38 // ); | 57 // ); |
39 var promise = PromiseCastResolved(value); | 58 var promise = PromiseCastResolved(awaited); |
40 | 59 |
41 var onFulfilled = | 60 var onFulfilled = |
42 (sentValue) => %_Call(AsyncFunctionNext, generator, sentValue); | 61 (sentValue) => %_Call(AsyncFunctionNext, generator, sentValue); |
43 var onRejected = | 62 var onRejected = |
44 (sentError) => %_Call(AsyncFunctionThrow, generator, sentError); | 63 (sentError) => %_Call(AsyncFunctionThrow, generator, sentError); |
45 | 64 |
46 // false debugEvent to avoid redundant ExceptionEvents | 65 if (mark && DEBUG_IS_ACTIVE && IsPromise(awaited)) { |
66 // Mark the reject handler callback such that it does not influence | |
67 // catch prediction. | |
68 SET_PRIVATE(onRejected, promiseAwaitHandlerSymbol, true); | |
69 } | |
70 | |
71 // Just forwarding the exception, so no debugEvent for throwawayCapability | |
47 var throwawayCapability = NewPromiseCapability(GlobalPromise, false); | 72 var throwawayCapability = NewPromiseCapability(GlobalPromise, false); |
48 return PerformPromiseThen(promise, onFulfilled, onRejected, | 73 return PerformPromiseThen(promise, onFulfilled, onRejected, |
49 throwawayCapability); | 74 throwawayCapability); |
50 } | 75 } |
51 | 76 |
77 function AsyncFunctionAwaitUncaught(generator, awaited) { | |
78 // TODO(littledan): Install a dependency edge from awaited to outerPromise | |
79 return AsyncFunctionAwait(generator, awaited, true); | |
80 } | |
81 | |
82 function AsyncFunctionAwaitCaught(generator, awaited) { | |
83 if (DEBUG_IS_ACTIVE && IsPromise(awaited)) { | |
84 SET_PRIVATE(awaited, promiseHandledHintSymbol, true); | |
85 } | |
86 return AsyncFunctionAwait(generator, awaited, false); | |
87 } | |
88 | |
52 // How the parser rejects promises from async/await desugaring | 89 // How the parser rejects promises from async/await desugaring |
53 function RejectPromiseNoDebugEvent(promise, reason) { | 90 function RejectPromiseNoDebugEvent(promise, reason) { |
54 return RejectPromise(promise, reason, false); | 91 return RejectPromise(promise, reason, false); |
55 } | 92 } |
56 | 93 |
57 %InstallToContext([ | 94 %InstallToContext([ |
58 "async_function_await", AsyncFunctionAwait, | 95 "async_function_await_caught", AsyncFunctionAwaitCaught, |
96 "async_function_await_uncaught", AsyncFunctionAwaitUncaught, | |
59 "reject_promise_no_debug_event", RejectPromiseNoDebugEvent, | 97 "reject_promise_no_debug_event", RejectPromiseNoDebugEvent, |
60 ]); | 98 ]); |
61 | 99 |
62 }) | 100 }) |
OLD | NEW |