Everywhere: Hoist the Libraries folder to the top-level

Author: https://github.com/trflynn89
Commit: 93712b24bf
Pull-request: https://github.com/LadybirdBrowser/ladybird/pull/2256
Reviewed-by: https://github.com/sideshowbarker

Libraries/LibJS/Runtime/GeneratorObject.cpp

@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) 2021, Ali Mohammad Pur <mpfard@serenityos.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <AK/TemporaryChange.h>
+#include <LibJS/Bytecode/Generator.h>
+#include <LibJS/Bytecode/Interpreter.h>
+#include <LibJS/Runtime/GeneratorObject.h>
+#include <LibJS/Runtime/GeneratorPrototype.h>
+#include <LibJS/Runtime/GlobalObject.h>
+#include <LibJS/Runtime/Iterator.h>
+
+namespace JS {
+
+JS_DEFINE_ALLOCATOR(GeneratorObject);
+
+ThrowCompletionOr<NonnullGCPtr<GeneratorObject>> GeneratorObject::create(Realm& realm, Value initial_value, ECMAScriptFunctionObject* generating_function, NonnullOwnPtr<ExecutionContext> execution_context)
+{
+    auto& vm = realm.vm();
+    // This is "g1.prototype" in figure-2 (https://tc39.es/ecma262/img/figure-2.png)
+    Value generating_function_prototype;
+    if (generating_function->kind() == FunctionKind::Async) {
+        // We implement async functions by transforming them to generator function in the bytecode
+        // interpreter. However an async function does not have a prototype and should not be
+        // changed thus we hardcode the prototype.
+        generating_function_prototype = realm.intrinsics().generator_prototype();
+    } else {
+        generating_function_prototype = TRY(generating_function->get(vm.names.prototype));
+    }
+    auto generating_function_prototype_object = TRY(generating_function_prototype.to_object(vm));
+    auto object = realm.heap().allocate<GeneratorObject>(realm, realm, generating_function_prototype_object, move(execution_context));
+    object->m_generating_function = generating_function;
+    object->m_previous_value = initial_value;
+    return object;
+}
+
+GeneratorObject::GeneratorObject(Realm&, Object& prototype, NonnullOwnPtr<ExecutionContext> context, Optional<StringView> generator_brand)
+    : Object(ConstructWithPrototypeTag::Tag, prototype)
+    , m_execution_context(move(context))
+    , m_generator_brand(move(generator_brand))
+{
+}
+
+void GeneratorObject::visit_edges(Cell::Visitor& visitor)
+{
+    Base::visit_edges(visitor);
+    visitor.visit(m_generating_function);
+    visitor.visit(m_previous_value);
+    m_execution_context->visit_edges(visitor);
+}
+
+// 27.5.3.2 GeneratorValidate ( generator, generatorBrand ), https://tc39.es/ecma262/#sec-generatorvalidate
+ThrowCompletionOr<GeneratorObject::GeneratorState> GeneratorObject::validate(VM& vm, Optional<StringView> const& generator_brand)
+{
+    // 1. Perform ? RequireInternalSlot(generator, [[GeneratorState]]).
+    // 2. Perform ? RequireInternalSlot(generator, [[GeneratorBrand]]).
+    // NOTE: Already done by the caller of resume or resume_abrupt, as they wouldn't have a GeneratorObject otherwise.
+
+    // 3. If generator.[[GeneratorBrand]] is not the same value as generatorBrand, throw a TypeError exception.
+    if (m_generator_brand != generator_brand)
+        return vm.throw_completion<TypeError>(ErrorType::GeneratorBrandMismatch, m_generator_brand.value_or("<empty>"sv), generator_brand.value_or("<empty>"sv));
+
+    // 4. Assert: generator also has a [[GeneratorContext]] internal slot.
+    // NOTE: Done by already being a GeneratorObject.
+
+    // 5. Let state be generator.[[GeneratorState]].
+    auto state = m_generator_state;
+
+    // 6. If state is executing, throw a TypeError exception.
+    if (state == GeneratorState::Executing)
+        return vm.throw_completion<TypeError>(ErrorType::GeneratorAlreadyExecuting);
+
+    // 7. Return state.
+    return state;
+}
+
+ThrowCompletionOr<Value> GeneratorObject::execute(VM& vm, Completion const& completion)
+{
+    // Loosely based on step 4 of https://tc39.es/ecma262/#sec-generatorstart mixed with https://tc39.es/ecma262/#sec-generatoryield at the end.
+
+    VERIFY(completion.value().has_value());
+
+    auto generated_value = [](Value value) -> Value {
+        if (value.is_object())
+            return value.as_object().get_without_side_effects("result");
+        return value.is_empty() ? js_undefined() : value;
+    };
+
+    auto generated_continuation = [&](Value value) -> Optional<size_t> {
+        if (value.is_object()) {
+            auto number_value = value.as_object().get_without_side_effects("continuation");
+            if (number_value.is_null())
+                return {};
+            return static_cast<u64>(number_value.as_double());
+        }
+        return {};
+    };
+
+    auto& realm = *vm.current_realm();
+    auto completion_object = Object::create(realm, nullptr);
+    completion_object->define_direct_property(vm.names.type, Value(to_underlying(completion.type())), default_attributes);
+    completion_object->define_direct_property(vm.names.value, completion.value().value(), default_attributes);
+
+    auto& bytecode_interpreter = vm.bytecode_interpreter();
+
+    auto const next_block = generated_continuation(m_previous_value);
+
+    // We should never enter `execute` again after the generator is complete.
+    VERIFY(next_block.has_value());
+
+    auto next_result = bytecode_interpreter.run_executable(*m_generating_function->bytecode_executable(), next_block, completion_object);
+
+    vm.pop_execution_context();
+
+    auto result_value = move(next_result.value);
+    if (result_value.is_throw_completion()) {
+        // Uncaught exceptions disable the generator.
+        m_generator_state = GeneratorState::Completed;
+        return result_value;
+    }
+    m_previous_value = result_value.release_value();
+    bool done = !generated_continuation(m_previous_value).has_value();
+
+    m_generator_state = done ? GeneratorState::Completed : GeneratorState::SuspendedYield;
+    return create_iterator_result_object(vm, generated_value(m_previous_value), done);
+}
+
+// 27.5.3.3 GeneratorResume ( generator, value, generatorBrand ), https://tc39.es/ecma262/#sec-generatorresume
+ThrowCompletionOr<Value> GeneratorObject::resume(VM& vm, Value value, Optional<StringView> const& generator_brand)
+{
+    // 1. Let state be ? GeneratorValidate(generator, generatorBrand).
+    auto state = TRY(validate(vm, generator_brand));
+
+    // 2. If state is completed, return CreateIterResultObject(undefined, true).
+    if (state == GeneratorState::Completed)
+        return create_iterator_result_object(vm, js_undefined(), true);
+
+    // 3. Assert: state is either suspendedStart or suspendedYield.
+    VERIFY(state == GeneratorState::SuspendedStart || state == GeneratorState::SuspendedYield);
+
+    // 4. Let genContext be generator.[[GeneratorContext]].
+    auto& generator_context = m_execution_context;
+
+    // 5. Let methodContext be the running execution context.
+    auto const& method_context = vm.running_execution_context();
+
+    // FIXME: 6. Suspend methodContext.
+
+    // 8. Push genContext onto the execution context stack; genContext is now the running execution context.
+    // NOTE: This is done out of order as to not permanently disable the generator if push_execution_context throws,
+    //       as `resume` will immediately throw when [[GeneratorState]] is "executing", never allowing the state to change.
+    TRY(vm.push_execution_context(*generator_context, {}));
+
+    // 7. Set generator.[[GeneratorState]] to executing.
+    m_generator_state = GeneratorState::Executing;
+
+    // 9. Resume the suspended evaluation of genContext using NormalCompletion(value) as the result of the operation that suspended it. Let result be the value returned by the resumed computation.
+    auto result = execute(vm, normal_completion(value));
+
+    // 10. Assert: When we return here, genContext has already been removed from the execution context stack and methodContext is the currently running execution context.
+    VERIFY(&vm.running_execution_context() == &method_context);
+
+    // 11. Return ? result.
+    return result;
+}
+
+// 27.5.3.4 GeneratorResumeAbrupt ( generator, abruptCompletion, generatorBrand ), https://tc39.es/ecma262/#sec-generatorresumeabrupt
+ThrowCompletionOr<Value> GeneratorObject::resume_abrupt(JS::VM& vm, JS::Completion abrupt_completion, Optional<StringView> const& generator_brand)
+{
+    // Not part of the spec, but the spec assumes abruptCompletion.[[Value]] is not empty.
+    VERIFY(abrupt_completion.value().has_value());
+
+    // 1. Let state be ? GeneratorValidate(generator, generatorBrand).
+    auto state = TRY(validate(vm, generator_brand));
+
+    // 2. If state is suspendedStart, then
+    if (state == GeneratorState::SuspendedStart) {
+        // a. Set generator.[[GeneratorState]] to completed.
+        m_generator_state = GeneratorState::Completed;
+
+        // b. Once a generator enters the completed state it never leaves it and its associated execution context is never resumed. Any execution state associated with generator can be discarded at this point.
+        // We don't currently discard anything.
+
+        // c. Set state to completed.
+        state = GeneratorState::Completed;
+    }
+
+    // 3. If state is completed, then
+    if (state == GeneratorState::Completed) {
+        // a. If abruptCompletion.[[Type]] is return, then
+        if (abrupt_completion.type() == Completion::Type::Return) {
+            // i. Return CreateIterResultObject(abruptCompletion.[[Value]], true).
+            return create_iterator_result_object(vm, abrupt_completion.value().value(), true);
+        }
+
+        // b. Return ? abruptCompletion.
+        return abrupt_completion;
+    }
+
+    // 4. Assert: state is suspendedYield.
+    VERIFY(state == GeneratorState::SuspendedYield);
+
+    // 5. Let genContext be generator.[[GeneratorContext]].
+    auto& generator_context = m_execution_context;
+
+    // 6. Let methodContext be the running execution context.
+    auto const& method_context = vm.running_execution_context();
+
+    // FIXME: 7. Suspend methodContext.
+
+    // 9. Push genContext onto the execution context stack; genContext is now the running execution context.
+    // NOTE: This is done out of order as to not permanently disable the generator if push_execution_context throws,
+    //       as `resume_abrupt` will immediately throw when [[GeneratorState]] is "executing", never allowing the state to change.
+    TRY(vm.push_execution_context(*generator_context, {}));
+
+    // 8. Set generator.[[GeneratorState]] to executing.
+    m_generator_state = GeneratorState::Executing;
+
+    // 10. Resume the suspended evaluation of genContext using abruptCompletion as the result of the operation that suspended it. Let result be the Completion Record returned by the resumed computation.
+    auto result = execute(vm, abrupt_completion);
+
+    // 11. Assert: When we return here, genContext has already been removed from the execution context stack and methodContext is the currently running execution context.
+    VERIFY(&vm.running_execution_context() == &method_context);
+
+    // 12. Return ? result.
+    return result;
+}
+
+}