RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-05-31 12:28:12 +00:00
Code Issues Activity Actions

LibJS: Overhaul AsyncFunctionDriverWrapper to make it actually work

Browse source 
This object is responsible for handling async functions in bytecode,
and this commit fully rewrites it, now it does:
* creates and keeps alive a top level promise, which callers can attach
  their `then` clauses
* creates and clear a handle to itself, to assure that it does not get
  garbage collected
* properly handles all possible ways a async function could halt and
  when possible continues the execution immediately
This commit is contained in:
Hendiadyoin1 2022-12-25 17:16:02 +01:00 • committed by Linus Groh
parent de514f29ad
commit 4c2b4c1a27
2 changed files with 106 additions and 37 deletions
Download patch file Download diff file Expand all files Collapse all files

129
Userland/Libraries/LibJS/Runtime/AsyncFunctionDriverWrapper.cpp
View file

@ -15,53 +15,115 @@ namespace JS {
ThrowCompletionOr<Value> AsyncFunctionDriverWrapper::create(Realm& realm, GeneratorObject* generator_object)
{
auto wrapper = MUST_OR_THROW_OOM(realm.heap().allocate<AsyncFunctionDriverWrapper>(realm, realm, generator_object));
return wrapper->react_to_async_task_completion(realm.vm(), js_undefined(), true);
auto top_level_promise = Promise::create(realm);
// Note: This generates a handle to itself, which it clears upon completing its execution
// The top_level_promise is also kept alive by this Wrapper
auto wrapper = MUST_OR_THROW_OOM(realm.heap().allocate<AsyncFunctionDriverWrapper>(realm, realm, *generator_object, *top_level_promise));
// Prime the generator:
// This runs until the first `await value;`
wrapper->continue_async_execution(realm.vm(), js_undefined(), true);
return top_level_promise;
}
AsyncFunctionDriverWrapper::AsyncFunctionDriverWrapper(Realm& realm, GeneratorObject* generator_object)
AsyncFunctionDriverWrapper::AsyncFunctionDriverWrapper(Realm& realm, NonnullGCPtr<GeneratorObject> generator_object, NonnullGCPtr<Promise> top_level_promise)
: Promise(*realm.intrinsics().promise_prototype())
, m_generator_object(generator_object)
, m_on_fulfillment(NativeFunction::create(realm, "async.on_fulfillment"sv, [this](VM& vm) {
return react_to_async_task_completion(vm, vm.argument(0), true);
, m_on_fulfillment(*NativeFunction::create(realm, "async.on_fulfillment"sv, [this](VM& vm) -> ThrowCompletionOr<Value> {
auto arg = vm.argument(0);
if (m_expect_promise) {
continue_async_execution(vm, arg, true);
m_expect_promise = false;
return js_undefined();
}
return arg;
}))
, m_on_rejection(NativeFunction::create(realm, "async.on_rejection"sv, [this](VM& vm) {
return react_to_async_task_completion(vm, vm.argument(0), false);
, m_on_rejection(*NativeFunction::create(realm, "async.on_rejection"sv, [this](VM& vm) -> ThrowCompletionOr<Value> {
auto arg = vm.argument(0);
if (m_expect_promise) {
continue_async_execution(vm, arg, false);
m_expect_promise = false;
return js_undefined();
}
return throw_completion(arg);
}))
, m_top_level_promise(top_level_promise)
, m_self_handle(make_handle(*this))
{
}
ThrowCompletionOr<Value> AsyncFunctionDriverWrapper::react_to_async_task_completion(VM& vm, Value value, bool is_successful)
void AsyncFunctionDriverWrapper::continue_async_execution(VM& vm, Value value, bool is_successful)
{
auto& realm = *vm.current_realm();
auto generator_result = is_successful
? m_generator_object->resume(vm, value, {})
: m_generator_object->resume_abrupt(vm, throw_completion(value), {});
if (generator_result.is_throw_completion()) {
VERIFY(generator_result.throw_completion().type() == Completion::Type::Throw);
auto promise = Promise::create(realm);
promise->reject(*generator_result.throw_completion().value());
return promise;
auto result = [&, this]() -> ThrowCompletionOr<void> {
// This loop is for the trivial case of awaiting a non-Promise value,
// and pseudo promises, that are actually resolved in a synchronous manner
// It's either this, a goto, or a needles indirection
while (true) {
if (generator_result.is_throw_completion())
return generator_result.throw_completion();
auto result = generator_result.release_value();
VERIFY(result.is_object());
auto promise_value = TRY(result.get(vm, vm.names.value));
if (TRY(result.get(vm, vm.names.done)).to_boolean()) {
// We hit a `return value;`
m_top_level_promise->fulfill(promise_value);
// We should not execute anymore, so we are safe to allow our selfs to be GC'd
m_self_handle = {};
return {};
}
if (!promise_value.is_object() || !is<Promise>(promise_value.as_object())) {
// We hit the trivial case of `await value`, where value is not a
// Promise, so we can just continue the execution
generator_result = m_generator_object->resume(vm, promise_value, {});
continue;
}
// We hit `await Promise`
m_current_promise = static_cast<Promise*>(&promise_value.as_object());
// FIXME: We need to be a bit explicit here,
// because for non async promises we arrive late to register us as handlers,
// so we need to just pretend we are early and do the main logic ourselves,
// Boon: This allows us to short-circuit to immediately continuing the execution
// FIXME: This then causes a warning to be printed to the console, that we supposedly did not handle the promise
if (m_current_promise->state() == Promise::State::Fulfilled) {
generator_result = m_generator_object->resume(vm, m_current_promise->result(), {});
continue;
}
if (m_current_promise->state() == Promise::State::Rejected) {
generator_result = m_generator_object->resume_abrupt(vm, m_current_promise->result(), {});
continue;
}
// Due to the nature of promise capabilities we might get called on either one path,
// so we use a flag to make sure only accept one call
// FIXME: There might be a cleaner way to accomplish this
m_expect_promise = true;
auto promise_capability = PromiseCapability::create(vm, *m_current_promise,
m_on_fulfillment,
m_on_rejection);
m_current_promise->perform_then(
m_on_fulfillment,
m_on_rejection,
promise_capability);
return {};
}
}();
if (result.is_throw_completion()) {
m_top_level_promise->reject(result.throw_completion().value().value_or(js_undefined()));
// We should not execute anymore, so we are safe to allow our selfs to be GC'd
m_self_handle = {};
}
auto result = generator_result.release_value();
VERIFY(result.is_object());
auto promise_value = TRY(result.get(vm, vm.names.value));
if (!promise_value.is_object() || !is<Promise>(promise_value.as_object())) {
auto promise = Promise::create(realm);
promise->fulfill(promise_value);
return promise;
}
auto promise = static_cast<Promise*>(&promise_value.as_object());
if (TRY(result.get(vm, vm.names.done)).to_boolean())
return promise;
auto promise_capability = PromiseCapability::create(vm, promise, m_on_fulfillment, m_on_rejection);
return promise->perform_then(m_on_fulfillment, m_on_rejection, promise_capability);
}
void AsyncFunctionDriverWrapper::visit_edges(Cell::Visitor& visitor)
@ -70,6 +132,9 @@ void AsyncFunctionDriverWrapper::visit_edges(Cell::Visitor& visitor)
visitor.visit(m_generator_object);
visitor.visit(m_on_fulfillment);
visitor.visit(m_on_rejection);
visitor.visit(m_top_level_promise);
if (m_current_promise)
visitor.visit(m_current_promise);
}
}