ladybird/Libraries/LibWeb/WebAssembly/WebAssembly.cpp

/*
 * Copyright (c) 2021, Ali Mohammad Pur <mpfard@serenityos.org>
 * Copyright (c) 2023, Tim Flynn <trflynn89@serenityos.org>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#include <AK/ByteBuffer.h>
#include <AK/MemoryStream.h>
#include <AK/ScopeGuard.h>
#include <AK/StringBuilder.h>
#include <LibJS/Runtime/Array.h>
#include <LibJS/Runtime/ArrayBuffer.h>
#include <LibJS/Runtime/BigInt.h>
#include <LibJS/Runtime/ErrorConstructor.h>
#include <LibJS/Runtime/Intrinsics.h>
#include <LibJS/Runtime/Iterator.h>
#include <LibJS/Runtime/NativeFunction.h>
#include <LibJS/Runtime/Object.h>
#include <LibJS/Runtime/VM.h>
#include <LibJS/Runtime/ValueInlines.h>
#include <LibWasm/AbstractMachine/Validator.h>
#include <LibWeb/Bindings/Intrinsics.h>
#include <LibWeb/Bindings/ResponsePrototype.h>
#include <LibWeb/Fetch/Response.h>
#include <LibWeb/HTML/Scripting/TemporaryExecutionContext.h>
#include <LibWeb/Platform/EventLoopPlugin.h>
#include <LibWeb/WebAssembly/Global.h>
#include <LibWeb/WebAssembly/Instance.h>
#include <LibWeb/WebAssembly/Memory.h>
#include <LibWeb/WebAssembly/Module.h>
#include <LibWeb/WebAssembly/Table.h>
#include <LibWeb/WebAssembly/WebAssembly.h>
#include <LibWeb/WebIDL/AbstractOperations.h>
#include <LibWeb/WebIDL/Buffers.h>
#include <LibWeb/WebIDL/Promise.h>

namespace Web::WebAssembly {

static GC::Ref<WebIDL::Promise> asynchronously_compile_webassembly_module(JS::VM&, ByteBuffer, HTML::Task::Source = HTML::Task::Source::Unspecified);
static GC::Ref<WebIDL::Promise> instantiate_promise_of_module(JS::VM&, GC::Ref<WebIDL::Promise>, GC::Ptr<JS::Object> import_object);
static GC::Ref<WebIDL::Promise> asynchronously_instantiate_webassembly_module(JS::VM&, GC::Ref<Module>, GC::Ptr<JS::Object> import_object);
static GC::Ref<WebIDL::Promise> compile_potential_webassembly_response(JS::VM&, GC::Ref<WebIDL::Promise>);

namespace Detail {

HashMap<GC::Ptr<JS::Object>, WebAssemblyCache> s_caches;

WebAssemblyCache& get_cache(JS::Realm& realm)
{
    return s_caches.ensure(realm.global_object());
}

}

void visit_edges(JS::Object& object, JS::Cell::Visitor& visitor)
{
    auto& global_object = HTML::relevant_global_object(object);
    if (auto maybe_cache = Detail::s_caches.get(global_object); maybe_cache.has_value()) {
        auto& cache = maybe_cache.release_value();
        visitor.visit(cache.function_instances());
        visitor.visit(cache.imported_objects());
        visitor.visit(cache.extern_values());
        visitor.visit(cache.global_instances());
        cache.abstract_machine().visit_external_resources({ .visit_trap = [&visitor](Wasm::ExternallyManagedTrap const& trap) {
            auto& completion = trap.unsafe_external_object_as<JS::Completion>();
            visitor.visit(completion.value());
        } });
    }
}

void finalize(JS::Object& object)
{
    auto& global_object = HTML::relevant_global_object(object);
    Detail::s_caches.remove(global_object);
}

// https://webassembly.github.io/spec/js-api/#error-objects
void initialize(JS::Object& self, JS::Realm& realm)
{
    // 1. Let namespaceObject be the namespace object.
    auto& namespace_object = self;

    // 2. For each error of « "CompileError", "LinkError", "RuntimeError" »,
    // 2.1. Let constructor be a new object, implementing the NativeError Object Structure, with NativeError set to error.
    // 2.2. ! DefineMethodProperty(namespaceObject, error, constructor, false).

    // 2..2.2 for error=CompileError:
    auto descriptor = JS::PropertyDescriptor {
        .writable = true,
        .enumerable = false,
        .configurable = true,
    };

    descriptor.value = &Bindings::ensure_web_constructor<CompileErrorPrototype>(realm, "CompileError"_fly_string);
    MUST(namespace_object.define_property_or_throw("CompileError"_string, descriptor));

    // 2..2.2 for error=LinkError:
    descriptor.value = &Bindings::ensure_web_constructor<LinkErrorPrototype>(realm, "LinkError"_fly_string);
    MUST(namespace_object.define_property_or_throw("LinkError"_string, descriptor));

    // 2..2.2 for error=RuntimeError:
    descriptor.value = &Bindings::ensure_web_constructor<RuntimeErrorPrototype>(realm, "RuntimeError"_fly_string);
    MUST(namespace_object.define_property_or_throw("RuntimeError"_string, descriptor));
}

// https://webassembly.github.io/spec/js-api/#dom-webassembly-validate
bool validate(JS::VM& vm, GC::Root<WebIDL::BufferSource>& bytes)
{
    // 1. Let stableBytes be a copy of the bytes held by the buffer bytes.
    auto stable_bytes = WebIDL::get_buffer_source_copy(*bytes->raw_object());
    if (stable_bytes.is_error()) {
        VERIFY(stable_bytes.error().code() == ENOMEM);
        return false;
    }

    // 2. Compile stableBytes as a WebAssembly module and store the results as module.
    auto module_or_error = Detail::compile_a_webassembly_module(vm, stable_bytes.release_value());

    // 3. If module is error, return false.
    if (module_or_error.is_error())
        return false;

    // 4. Return true.
    return true;
}

// https://webassembly.github.io/spec/js-api/#dom-webassembly-compile
WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> compile(JS::VM& vm, GC::Root<WebIDL::BufferSource>& bytes)
{
    auto& realm = *vm.current_realm();

    // 1. Let stableBytes be a copy of the bytes held by the buffer bytes.
    auto stable_bytes = WebIDL::get_buffer_source_copy(*bytes->raw_object());
    if (stable_bytes.is_error()) {
        VERIFY(stable_bytes.error().code() == ENOMEM);
        return WebIDL::create_rejected_promise_from_exception(realm, vm.throw_completion<JS::InternalError>(vm.error_message(JS::VM::ErrorMessage::OutOfMemory)));
    }

    // 2. Asynchronously compile a WebAssembly module from stableBytes and return the result.
    return asynchronously_compile_webassembly_module(vm, stable_bytes.release_value());
}

// https://webassembly.github.io/spec/web-api/index.html#dom-webassembly-compilestreaming
WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> compile_streaming(JS::VM& vm, GC::Root<WebIDL::Promise> source)
{
    //  The compileStreaming(source) method, when invoked, returns the result of compiling a potential WebAssembly response with source.
    return compile_potential_webassembly_response(vm, *source);
}

// https://webassembly.github.io/spec/js-api/#dom-webassembly-instantiate
WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> instantiate(JS::VM& vm, GC::Root<WebIDL::BufferSource>& bytes, Optional<GC::Root<JS::Object>>& import_object_handle)
{
    auto& realm = *vm.current_realm();

    // 1. Let stableBytes be a copy of the bytes held by the buffer bytes.
    auto stable_bytes = WebIDL::get_buffer_source_copy(*bytes->raw_object());
    if (stable_bytes.is_error()) {
        VERIFY(stable_bytes.error().code() == ENOMEM);
        return WebIDL::create_rejected_promise_from_exception(realm, vm.throw_completion<JS::InternalError>(vm.error_message(JS::VM::ErrorMessage::OutOfMemory)));
    }

    // 2. Asynchronously compile a WebAssembly module from stableBytes and let promiseOfModule be the result.
    auto promise_of_module = asynchronously_compile_webassembly_module(vm, stable_bytes.release_value());

    // 3. Instantiate promiseOfModule with imports importObject and return the result.
    GC::Ptr<JS::Object> const import_object = import_object_handle.has_value() ? import_object_handle.value().ptr() : nullptr;
    return instantiate_promise_of_module(vm, promise_of_module, import_object);
}

// https://webassembly.github.io/spec/js-api/#dom-webassembly-instantiate-moduleobject-importobject
WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> instantiate(JS::VM& vm, Module const& module_object, Optional<GC::Root<JS::Object>>& import_object)
{
    // 1. Asynchronously instantiate the WebAssembly module moduleObject importing importObject, and return the result.
    GC::Ref<Module> module { const_cast<Module&>(module_object) };
    GC::Ptr<JS::Object> const imports = import_object.has_value() ? import_object.value().ptr() : nullptr;
    return asynchronously_instantiate_webassembly_module(vm, module, imports);
}

// https://webassembly.github.io/spec/web-api/index.html#dom-webassembly-instantiatestreaming
WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> instantiate_streaming(JS::VM& vm, GC::Root<WebIDL::Promise> source, Optional<GC::Root<JS::Object>>& import_object)
{
    // The instantiateStreaming(source, importObject) method, when invoked, performs the following steps:

    // 1. Let promiseOfModule be the result of compiling a potential WebAssembly response with source.
    auto promise_of_module = compile_potential_webassembly_response(vm, *source);

    // 2. Return the result of instantiating the promise of a module promiseOfModule with imports importObject.
    auto imports = GC::Ptr { import_object.has_value() ? import_object.value().ptr() : nullptr };
    return instantiate_promise_of_module(vm, promise_of_module, imports);
}

namespace Detail {

#define TRY_OR_RETURN_TRAP(...)                                                                      \
    ({                                                                                               \
        /* Ignore -Wshadow to allow nesting the macro. */                                            \
        AK_IGNORE_DIAGNOSTIC("-Wshadow",                                                             \
            auto&& _temporary_result = (__VA_ARGS__));                                               \
        static_assert(!::AK::Detail::IsLvalueReference<decltype(_temporary_result.release_value())>, \
            "Do not return a reference from a fallible expression");                                 \
        if (_temporary_result.is_error()) [[unlikely]]                                               \
            return Wasm::Trap::from_external_object(_temporary_result.release_error());              \
        _temporary_result.release_value();                                                           \
    })

#define TRY_OR_RETURN_OOM_TRAP(vm, ...)                                                                                                                 \
    ({                                                                                                                                                  \
        /* Ignore -Wshadow to allow nesting the macro. */                                                                                               \
        AK_IGNORE_DIAGNOSTIC("-Wshadow",                                                                                                                \
            auto&& _temporary_result = (__VA_ARGS__));                                                                                                  \
        if (_temporary_result.is_error()) {                                                                                                             \
            VERIFY(_temporary_result.error().code() == ENOMEM);                                                                                         \
            return Wasm::Trap::from_external_object((vm).throw_completion<JS::InternalError>((vm).error_message(::JS::VM::ErrorMessage::OutOfMemory))); \
        }                                                                                                                                               \
        static_assert(!::AK::Detail::IsLvalueReference<decltype(_temporary_result.release_value())>,                                                    \
            "Do not return a reference from a fallible expression");                                                                                    \
        _temporary_result.release_value();                                                                                                              \
    })

JS::ThrowCompletionOr<NonnullOwnPtr<Wasm::ModuleInstance>> instantiate_module(JS::VM& vm, Wasm::Module const& module, GC::Ptr<JS::Object> import_object)
{
    Wasm::Linker linker { module };
    auto& cache = get_cache(*vm.current_realm());
    // https://webassembly.github.io/spec/js-api/index.html#read-the-imports
    // 1. If module.imports is not empty, and importObject is undefined, throw a TypeError exception.
    if (!module.import_section().imports().is_empty() && !import_object) {
        return vm.throw_completion<JS::TypeError>("ImportObject must be provided when module has imports"sv);
    }
    // 2. Let imports be « ».
    HashMap<Wasm::Linker::Name, Wasm::ExternValue> resolved_imports;
    if (import_object) {
        dbgln_if(LIBWEB_WASM_DEBUG, "Trying to resolve stuff because import object was specified");
        // 3. For each (moduleName, componentName, externtype) of module_imports(module),
        for (Wasm::Linker::Name const& import_name : linker.unresolved_imports()) {
            dbgln_if(LIBWEB_WASM_DEBUG, "Trying to resolve {}::{}", import_name.module, import_name.name);
            // 3.1. Let o be ? Get(importObject, moduleName).
            auto value_or_error = import_object->get(MUST(String::from_byte_string(import_name.module)));
            if (value_or_error.is_error())
                break;
            auto value = value_or_error.release_value();
            // 3.2. If o is not an Object, throw a TypeError exception.
            auto object_or_error = value.to_object(vm);
            if (object_or_error.is_error())
                break;
            auto object = object_or_error.release_value();
            // 3.3. Let v be ? Get(o, componentName).
            auto import_or_error = object->get(MUST(String::from_byte_string(import_name.name)));
            if (import_or_error.is_error())
                break;
            auto import_ = import_or_error.release_value();
            TRY(import_name.type.visit(
                // 3.4. If externtype is of the form func functype,
                [&](Wasm::TypeIndex index) -> JS::ThrowCompletionOr<void> {
                    dbgln_if(LIBWEB_WASM_DEBUG, "Trying to resolve a function {}::{}, type index {}", import_name.module, import_name.name, index.value());
                    auto& type = module.type_section().types()[index.value()];
                    // FIXME: 3.4.1. If IsCallable(v) is false, throw a LinkError exception.
                    if (!import_.is_function())
                        return {};
                    auto& function = import_.as_function();
                    // 3.4.2. If v has a [[FunctionAddress]] internal slot, and therefore is an Exported Function,
                    Optional<Wasm::FunctionAddress> address;
                    if (is<ExportedWasmFunction>(function)) {
                        // 3.4.2.1. Let funcaddr be the value of v’s [[FunctionAddress]] internal slot.
                        auto& exported_function = static_cast<ExportedWasmFunction&>(function);
                        address = exported_function.exported_address();
                    }
                    // 3.4.3. Otherwise,
                    else {
                        // 3.4.3.1. Create a host function from v and functype, and let funcaddr be the result.
                        cache.add_imported_object(function);
                        Wasm::HostFunction host_function {
                            [&](auto&, auto& arguments) -> Wasm::Result {
                                GC::RootVector<JS::Value> argument_values { vm.heap() };
                                size_t index = 0;
                                for (auto& entry : arguments) {
                                    argument_values.append(to_js_value(vm, entry, type.parameters()[index]));
                                    ++index;
                                }

                                auto result = TRY_OR_RETURN_TRAP(JS::call(vm, function, JS::js_undefined(), argument_values.span()));
                                if (type.results().is_empty())
                                    return Wasm::Result { Vector<Wasm::Value> {} };

                                if (type.results().size() == 1)
                                    return Wasm::Result { Vector<Wasm::Value> { TRY_OR_RETURN_TRAP(to_webassembly_value(vm, result, type.results().first())) } };

                                auto method = TRY_OR_RETURN_TRAP(result.get_method(vm, vm.names.iterator));
                                if (method == JS::js_undefined())
                                    return Wasm::Trap::from_external_object(vm.throw_completion<JS::TypeError>(JS::ErrorType::NotIterable, result.to_string_without_side_effects()));

                                auto values = TRY_OR_RETURN_TRAP(JS::iterator_to_list(vm, TRY_OR_RETURN_TRAP(JS::get_iterator_from_method(vm, result, *method))));

                                if (values.size() != type.results().size())
                                    return Wasm::Trap::from_external_object(vm.throw_completion<JS::TypeError>(ByteString::formatted("Invalid number of return values for multi-value wasm return of {} objects", type.results().size())));

                                Vector<Wasm::Value> wasm_values;
                                TRY_OR_RETURN_OOM_TRAP(vm, wasm_values.try_ensure_capacity(values.size()));

                                size_t i = 0;
                                for (auto& value : values)
                                    wasm_values.append(TRY_OR_RETURN_TRAP(to_webassembly_value(vm, value, type.results()[i++])));

                                return Wasm::Result { move(wasm_values) };
                            },
                            type,
                            ByteString::formatted("func{}", resolved_imports.size()),
                        };
                        address = cache.abstract_machine().store().allocate(move(host_function));
                        // FIXME: 3.4.3.2. Let index be the number of external functions in imports. This value index is known as the index of the host function funcaddr.
                        //        'index' doesn't seem to be used anywhere?
                    }
                    dbgln_if(LIBWEB_WASM_DEBUG, "Resolved to {}", address->value());
                    // FIXME: LinkError instead.
                    VERIFY(address.has_value());

                    // 3.4.4. Let externfunc be the external value func funcaddr.
                    // 3.4.5. Append externfunc to imports.
                    resolved_imports.set(import_name, Wasm::ExternValue { Wasm::FunctionAddress { *address } });
                    return {};
                },
                // 3.5. If externtype is of the form global mut valtype,
                [&](Wasm::GlobalType const& type) -> JS::ThrowCompletionOr<void> {
                    Optional<Wasm::GlobalAddress> address;
                    // 3.5.1. If v is a Number or v is a BigInt,
                    if (import_.is_number() || import_.is_bigint()) {
                        // 3.5.1.1. If valtype is i64 and v is a Number,
                        if (import_.is_number() && type.type().kind() == Wasm::ValueType::I64) {
                            // 3.5.1.1.1. Throw a LinkError exception.
                            return vm.throw_completion<LinkError>("Import resolution attempted to cast a Number to a BigInteger"sv);
                        }
                        // 3.5.1.2. If valtype is not i64 and v is a BigInt,
                        if (import_.is_bigint() && type.type().kind() != Wasm::ValueType::I64) {
                            // 3.5.1.2.1. Throw a LinkError exception.
                            return vm.throw_completion<LinkError>("Import resolution attempted to cast a BigInteger to a Number"sv);
                        }
                        // 3.5.1.3. If valtype is v128,
                        if (type.type().kind() == Wasm::ValueType::V128) {
                            // 3.5.1.3.1. Throw a LinkError exception.
                            return vm.throw_completion<LinkError>("Import resolution attempted to cast a Number or BigInt to a V128"sv);
                        }
                        // 3.5.1.4. Let value be ToWebAssemblyValue(v, valtype).
                        auto cast_value = TRY(to_webassembly_value(vm, import_, type.type()));
                        // 3.5.1.5. Let store be the surrounding agent's associated store.
                        // 3.5.1.6. Let (store, globaladdr) be global_alloc(store, const valtype, value).
                        // 3.5.1.7. Set the surrounding agent's associated store to store.
                        address = cache.abstract_machine().store().allocate({ type.type(), false }, cast_value);
                    }
                    // FIXME: 3.5.2. Otherwise, if v implements Global,
                    // FIXME: 3.5.2.1. Let globaladdr be v.[[Global]].
                    // 3.5.3. Otherwise,
                    else {
                        // 3.5.3.1. Throw a LinkError exception.
                        return vm.throw_completion<LinkError>("Invalid value for global type"sv);
                    }

                    // 3.5.4. Let externglobal be global globaladdr.
                    // 3.5.5. Append externglobal to imports.
                    resolved_imports.set(import_name, Wasm::ExternValue { *address });
                    return {};
                },
                // 3.6. If externtype is of the form mem memtype,
                [&](Wasm::MemoryType const&) -> JS::ThrowCompletionOr<void> {
                    // 3.6.1. If v does not implement Memory, throw a LinkError exception.
                    if (!import_.is_object() || !is<WebAssembly::Memory>(import_.as_object())) {
                        return vm.throw_completion<LinkError>("Expected an instance of WebAssembly.Memory for a memory import"sv);
                    }
                    // 3.6.2. Let externmem be the external value mem v.[[Memory]].
                    auto address = static_cast<WebAssembly::Memory const&>(import_.as_object()).address();
                    // 3.6.3. Append externmem to imports.
                    resolved_imports.set(import_name, Wasm::ExternValue { address });
                    return {};
                },
                // 3.7. If externtype is of the form table tabletype,
                [&](Wasm::TableType const&) -> JS::ThrowCompletionOr<void> {
                    // 3.7.1. If v does not implement Table, throw a LinkError exception.
                    if (!import_.is_object() || !is<WebAssembly::Table>(import_.as_object())) {
                        return vm.throw_completion<LinkError>("Expected an instance of WebAssembly.Table for a table import"sv);
                    }
                    // 3.7.2. Let tableaddr be v.[[Table]].
                    // 3.7.3. Let externtable be the external value table tableaddr.
                    auto address = static_cast<WebAssembly::Table const&>(import_.as_object()).address();
                    // 3.7.4. Append externtable to imports.
                    resolved_imports.set(import_name, Wasm::ExternValue { address });
                    return {};
                },
                [&](auto const&) -> JS::ThrowCompletionOr<void> {
                    // (noop)
                    return {};
                }));
        }
    }

    // (inlined) 4. Return imports.
    linker.link(resolved_imports);
    auto link_result = linker.finish();
    if (link_result.is_error()) {
        StringBuilder builder;
        builder.append("Missing "sv);
        builder.join(' ', link_result.error().missing_imports);
        return vm.throw_completion<LinkError>(MUST(builder.to_string()));
    }

    auto instance_result = cache.abstract_machine().instantiate(module, link_result.release_value());
    if (instance_result.is_error()) {
        return vm.throw_completion<LinkError>(instance_result.error().error);
    }

    return instance_result.release_value();
}

// // https://webassembly.github.io/spec/js-api/#compile-a-webassembly-module
JS::ThrowCompletionOr<NonnullRefPtr<CompiledWebAssemblyModule>> compile_a_webassembly_module(JS::VM& vm, ByteBuffer data)
{
    FixedMemoryStream stream { data.bytes() };
    auto module_result = Wasm::Module::parse(stream);
    if (module_result.is_error()) {
        return vm.throw_completion<CompileError>(Wasm::parse_error_to_byte_string(module_result.error()));
    }

    auto& cache = get_cache(*vm.current_realm());
    if (auto validation_result = cache.abstract_machine().validate(module_result.value()); validation_result.is_error()) {
        return vm.throw_completion<CompileError>(validation_result.error().error_string);
    }
    auto compiled_module = make_ref_counted<CompiledWebAssemblyModule>(module_result.release_value());
    cache.add_compiled_module(compiled_module);
    return compiled_module;
}

GC_DEFINE_ALLOCATOR(ExportedWasmFunction);

GC::Ref<ExportedWasmFunction> ExportedWasmFunction::create(JS::Realm& realm, FlyString const& name, Function<JS::ThrowCompletionOr<JS::Value>(JS::VM&)> behavior, Wasm::FunctionAddress exported_address)
{
    auto prototype = realm.intrinsics().function_prototype();
    return realm.create<ExportedWasmFunction>(
        name,
        move(behavior),
        exported_address,
        prototype);
}

ExportedWasmFunction::ExportedWasmFunction(FlyString name, AK::Function<JS::ThrowCompletionOr<JS::Value>(JS::VM&)> behavior, Wasm::FunctionAddress exported_address, JS::Object& prototype)
    : NativeFunction(move(name), move(behavior), prototype)
    , m_exported_address(exported_address)
{
}

JS::NativeFunction* create_native_function(JS::VM& vm, Wasm::FunctionAddress address, String const& name, Instance* instance)
{
    auto& realm = *vm.current_realm();
    Optional<Wasm::FunctionType> type;
    auto& cache = get_cache(realm);
    cache.abstract_machine().store().get(address)->visit([&](auto const& value) { type = value.type(); });
    if (auto entry = cache.get_function_instance(address); entry.has_value())
        return *entry;

    auto function = ExportedWasmFunction::create(
        realm,
        name,
        [address, type = type.release_value(), instance](JS::VM& vm) -> JS::ThrowCompletionOr<JS::Value> {
            (void)instance;
            auto& realm = *vm.current_realm();
            Vector<Wasm::Value> values;
            values.ensure_capacity(type.parameters().size());

            // Grab as many values as needed and convert them.
            size_t index = 0;
            for (auto& type : type.parameters())
                values.append(TRY(to_webassembly_value(vm, vm.argument(index++), type)));

            auto& cache = get_cache(realm);
            auto result = cache.abstract_machine().invoke(address, move(values));
            // FIXME: Use the convoluted mapping of errors defined in the spec.
            if (result.is_trap()) {
                if (auto ptr = result.trap().data.get_pointer<Wasm::ExternallyManagedTrap>())
                    return ptr->unsafe_external_object_as<JS::Completion>();
                return vm.throw_completion<RuntimeError>(TRY_OR_THROW_OOM(vm, String::formatted("Wasm execution trapped (WIP): {}", result.trap().format())));
            }

            if (result.values().is_empty())
                return JS::js_undefined();

            if (result.values().size() == 1)
                return to_js_value(vm, result.values().first(), type.results().first());

            // Put result values into a JS::Array in reverse order.
            auto js_result_values = GC::RootVector<JS::Value> { realm.heap() };
            js_result_values.ensure_capacity(result.values().size());

            for (size_t i = result.values().size(); i > 0; i--) {
                // Safety: ensure_capacity is called just before this.
                js_result_values.unchecked_append(to_js_value(vm, result.values().at(i - 1), type.results().at(i - 1)));
            }

            return JS::Value(JS::Array::create_from(realm, js_result_values));
        },
        address);

    cache.add_function_instance(address, function);
    return function;
}

JS::ThrowCompletionOr<Wasm::Value> to_webassembly_value(JS::VM& vm, JS::Value value, Wasm::ValueType const& type)
{
    static ::Crypto::SignedBigInteger two_64 = "1"_sbigint.shift_left(64);

    switch (type.kind()) {
    case Wasm::ValueType::I64: {
        auto bigint = TRY(value.to_bigint(vm));
        auto value = bigint->big_integer().divided_by(two_64).remainder;
        VERIFY(value.unsigned_value().trimmed_length() <= 2);
        i64 integer = static_cast<i64>(value.unsigned_value().to_u64());
        if (value.is_negative())
            integer = -integer;
        return Wasm::Value { integer };
    }
    case Wasm::ValueType::I32: {
        auto _i32 = TRY(value.to_i32(vm));
        return Wasm::Value { static_cast<i32>(_i32) };
    }
    case Wasm::ValueType::F64: {
        auto number = TRY(value.to_double(vm));
        return Wasm::Value { static_cast<double>(number) };
    }
    case Wasm::ValueType::F32: {
        auto number = TRY(value.to_double(vm));
        return Wasm::Value { static_cast<float>(number) };
    }
    case Wasm::ValueType::FunctionReference: {
        if (value.is_null())
            return Wasm::Value(Wasm::ValueType { Wasm::ValueType::Kind::FunctionReference });

        if (value.is_function()) {
            auto& function = value.as_function();
            auto& cache = get_cache(*vm.current_realm());
            for (auto& entry : cache.function_instances()) {
                if (entry.value == &function)
                    return Wasm::Value { Wasm::Reference { Wasm::Reference::Func { entry.key, cache.abstract_machine().store().get_module_for(entry.key) } } };
            }
        }

        return vm.throw_completion<JS::TypeError>(JS::ErrorType::NotAnObjectOfType, "Exported function");
    }
    case Wasm::ValueType::ExternReference: {
        if (value.is_null())
            return Wasm::Value(Wasm::ValueType { Wasm::ValueType::Kind::ExternReference });
        auto& cache = get_cache(*vm.current_realm());
        for (auto& entry : cache.extern_values()) {
            if (entry.value == value)
                return Wasm::Value { Wasm::Reference { Wasm::Reference::Extern { entry.key } } };
        }
        Wasm::ExternAddress extern_addr = cache.extern_values().size();
        cache.add_extern_value(extern_addr, value);
        return Wasm::Value { Wasm::Reference { Wasm::Reference::Extern { extern_addr } } };
    }
    case Wasm::ValueType::V128:
        return vm.throw_completion<JS::TypeError>("Cannot convert a vector value to a javascript value"sv);
    }

    VERIFY_NOT_REACHED();
}

Wasm::Value default_webassembly_value(JS::VM& vm, Wasm::ValueType type)
{
    switch (type.kind()) {
    case Wasm::ValueType::I32:
    case Wasm::ValueType::I64:
    case Wasm::ValueType::F32:
    case Wasm::ValueType::F64:
    case Wasm::ValueType::V128:
    case Wasm::ValueType::FunctionReference:
        return Wasm::Value(type);
    case Wasm::ValueType::ExternReference:
        return MUST(to_webassembly_value(vm, JS::js_undefined(), type));
    }
    VERIFY_NOT_REACHED();
}

// https://webassembly.github.io/spec/js-api/#tojsvalue
JS::Value to_js_value(JS::VM& vm, Wasm::Value& wasm_value, Wasm::ValueType type)
{
    auto& realm = *vm.current_realm();
    switch (type.kind()) {
    case Wasm::ValueType::I64:
        return realm.create<JS::BigInt>(::Crypto::SignedBigInteger { wasm_value.to<i64>() });
    case Wasm::ValueType::I32:
        return JS::Value(wasm_value.to<i32>());
    case Wasm::ValueType::F64:
        return JS::Value(wasm_value.to<double>());
    case Wasm::ValueType::F32:
        return JS::Value(static_cast<double>(wasm_value.to<float>()));
    case Wasm::ValueType::FunctionReference: {
        auto ref_ = wasm_value.to<Wasm::Reference>();
        if (ref_.ref().has<Wasm::Reference::Null>())
            return JS::js_null();
        auto address = ref_.ref().get<Wasm::Reference::Func>().address;
        auto& cache = get_cache(realm);
        auto* function = cache.abstract_machine().store().get(address);
        auto name = function->visit(
            [&](Wasm::WasmFunction& wasm_function) {
                auto index = *wasm_function.module().functions().find_first_index(address);
                return ByteString::formatted("func{}", index);
            },
            [](Wasm::HostFunction& host_function) {
                return host_function.name();
            });
        return create_native_function(vm, address, MUST(String::from_byte_string(name)));
    }
    case Wasm::ValueType::ExternReference: {
        auto ref_ = wasm_value.to<Wasm::Reference>();
        if (ref_.ref().has<Wasm::Reference::Null>())
            return JS::js_null();
        auto address = ref_.ref().get<Wasm::Reference::Extern>().address;
        auto& cache = get_cache(realm);
        auto value = cache.get_extern_value(address);
        return value.release_value();
    }
    case Wasm::ValueType::V128:
        VERIFY_NOT_REACHED();
    }
    VERIFY_NOT_REACHED();
}

}

// https://webassembly.github.io/spec/js-api/#asynchronously-compile-a-webassembly-module
GC::Ref<WebIDL::Promise> asynchronously_compile_webassembly_module(JS::VM& vm, ByteBuffer bytes, HTML::Task::Source task_source)
{
    auto& realm = *vm.current_realm();

    // 1. Let promise be a new Promise.
    auto promise = WebIDL::create_promise(realm);

    // 2. Run the following steps in parallel:
    Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(vm.heap(), [&vm, &realm, bytes = move(bytes), promise, task_source]() mutable {
        HTML::TemporaryExecutionContext context(realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
        // 1. Compile the WebAssembly module bytes and store the result as module.
        auto module_or_error = Detail::compile_a_webassembly_module(vm, move(bytes));

        // 2. Queue a task to perform the following steps. If taskSource was provided, queue the task on that task source.
        HTML::queue_a_task(task_source, nullptr, nullptr, GC::create_function(vm.heap(), [&realm, promise, module_or_error = move(module_or_error)]() mutable {
            HTML::TemporaryExecutionContext context(realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
            auto& realm = HTML::relevant_realm(*promise->promise());

            // 1. If module is error, reject promise with a CompileError exception.
            if (module_or_error.is_error()) {
                WebIDL::reject_promise(realm, promise, module_or_error.error_value());
            }

            // 2. Otherwise,
            else {
                // 1. Construct a WebAssembly module object from module and bytes, and let moduleObject be the result.
                // FIXME: Save bytes to the Module instance instead of moving into compile_a_webassembly_module
                auto module_object = realm.create<Module>(realm, module_or_error.release_value());

                // 2. Resolve promise with moduleObject.
                WebIDL::resolve_promise(realm, promise, module_object);
            }
        }));
    }));

    // 3. Return promise.
    return promise;
}

// https://webassembly.github.io/spec/js-api/#asynchronously-instantiate-a-webassembly-module
GC::Ref<WebIDL::Promise> asynchronously_instantiate_webassembly_module(JS::VM& vm, GC::Ref<Module> module_object, GC::Ptr<JS::Object> import_object)
{
    auto& realm = *vm.current_realm();

    // 1. Let promise be a new promise.
    auto promise = WebIDL::create_promise(realm);

    // 2. Let module be moduleObject.[[Module]].
    auto module = module_object->compiled_module();

    // 3. Read the imports of module with imports importObject, and let imports be the result.
    //    If this operation throws an exception, catch it, reject promise with the exception, and return promise.
    // Note: We do this at the same time as instantiation in instantiate_module.

    // 4. Run the following steps in parallel:
    //   1. Queue a task to perform the following steps: Note: Implementation-specific work may be performed here.
    HTML::queue_a_task(HTML::Task::Source::Unspecified, nullptr, nullptr, GC::create_function(vm.heap(), [&vm, &realm, promise, module, import_object]() {
        HTML::TemporaryExecutionContext context(realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
        auto& realm = HTML::relevant_realm(*promise->promise());

        // 1. Instantiate the core of a WebAssembly module module with imports, and let instance be the result.
        //    If this throws an exception, catch it, reject promise with the exception, and terminate these substeps.
        auto result = Detail::instantiate_module(vm, module->module, import_object);
        if (result.is_error()) {
            WebIDL::reject_promise(realm, promise, result.error_value());
            return;
        }
        auto instance = result.release_value();

        // 2. Let instanceObject be a new Instance.
        // 3. Initialize instanceObject from module and instance. If this throws an exception, catch it, reject promise with the exception, and terminate these substeps.
        // FIXME: Investigate whether we are doing all the proper steps for "initialize an instance object"
        auto instance_object = realm.create<Instance>(realm, move(instance));

        // 4. Resolve promise with instanceObject.
        WebIDL::resolve_promise(realm, promise, instance_object);
    }));

    // 5. Return promise.
    return promise;
}

// https://webassembly.github.io/spec/js-api/#instantiate-a-promise-of-a-module
GC::Ref<WebIDL::Promise> instantiate_promise_of_module(JS::VM& vm, GC::Ref<WebIDL::Promise> promise_of_module, GC::Ptr<JS::Object> import_object)
{
    auto& realm = *vm.current_realm();

    // 1. Let promise be a new Promise.
    auto promise = WebIDL::create_promise(realm);

    // FIXME: Spec should use react to promise here instead of separate upon fulfillment and upon rejection steps

    // 2. Upon fulfillment of promiseOfModule with value module:
    auto fulfillment_steps = GC::create_function(vm.heap(), [&vm, promise, import_object](JS::Value module_value) -> WebIDL::ExceptionOr<JS::Value> {
        VERIFY(module_value.is_object() && is<Module>(module_value.as_object()));
        auto module = GC::Ref { static_cast<Module&>(module_value.as_object()) };

        // 1. Instantiate the WebAssembly module module importing importObject, and let innerPromise be the result.
        auto inner_promise = asynchronously_instantiate_webassembly_module(vm, module, import_object);

        // 2. Upon fulfillment of innerPromise with value instance.
        auto instantiate_fulfillment_steps = GC::create_function(vm.heap(), [promise, module](JS::Value instance_value) -> WebIDL::ExceptionOr<JS::Value> {
            auto& realm = HTML::relevant_realm(*promise->promise());

            VERIFY(instance_value.is_object() && is<Instance>(instance_value.as_object()));
            auto instance = GC::Ref { static_cast<Instance&>(instance_value.as_object()) };

            // 1. Let result be the WebAssemblyInstantiatedSource value «[ "module" → module, "instance" → instance ]».
            auto result = JS::Object::create(realm, nullptr);
            result->define_direct_property("module"_fly_string, module, JS::default_attributes);
            result->define_direct_property("instance"_fly_string, instance, JS::default_attributes);

            // 2. Resolve promise with result.
            WebIDL::resolve_promise(realm, promise, result);

            return JS::js_undefined();
        });

        // 3. Upon rejection of innerPromise with reason reason.
        auto instantiate_rejection_steps = GC::create_function(vm.heap(), [promise](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
            auto& realm = HTML::relevant_realm(*promise->promise());

            // 1. Reject promise with reason.
            WebIDL::reject_promise(realm, promise, reason);

            return JS::js_undefined();
        });

        WebIDL::react_to_promise(inner_promise, instantiate_fulfillment_steps, instantiate_rejection_steps);

        return JS::js_undefined();
    });

    // 3. Upon rejection of promiseOfModule with reason reason:
    auto rejection_steps = GC::create_function(vm.heap(), [promise](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
        auto& realm = HTML::relevant_realm(*promise->promise());

        // 1. Reject promise with reason.
        WebIDL::reject_promise(realm, promise, reason);

        return JS::js_undefined();
    });

    WebIDL::react_to_promise(promise_of_module, fulfillment_steps, rejection_steps);

    // 4. Return promise.
    return promise;
}

// https://webassembly.github.io/spec/web-api/index.html#compile-a-potential-webassembly-response
GC::Ref<WebIDL::Promise> compile_potential_webassembly_response(JS::VM& vm, GC::Ref<WebIDL::Promise> source)
{
    auto& realm = *vm.current_realm();

    // Note: This algorithm accepts a Response object, or a promise for one, and compiles and instantiates the resulting bytes of the response.
    //       This compilation can be performed in the background and in a streaming manner.
    //       If the Response is not CORS-same-origin, does not represent an ok status, or does not match the `application/wasm` MIME type,
    //       the returned promise will be rejected with a TypeError; if compilation or instantiation fails,
    //       the returned promise will be rejected with a CompileError or other relevant error type, depending on the cause of failure.

    // 1. Let returnValue be a new promise
    auto return_value = WebIDL::create_promise(realm);

    // 2. Upon fulfillment of source with value unwrappedSource:
    auto fulfillment_steps = GC::create_function(vm.heap(), [&vm, return_value](JS::Value unwrapped_source) -> WebIDL::ExceptionOr<JS::Value> {
        auto& realm = HTML::relevant_realm(*return_value->promise());

        // 1. Let response be unwrappedSource’s response.
        if (!unwrapped_source.is_object() || !is<Fetch::Response>(unwrapped_source.as_object())) {
            WebIDL::reject_promise(realm, return_value, vm.throw_completion<JS::TypeError>(JS::ErrorType::NotAnObjectOfType, "Response").value());
            return JS::js_undefined();
        }
        auto& response_object = static_cast<Fetch::Response&>(unwrapped_source.as_object());
        auto response = response_object.response();

        // 2. Let mimeType be the result of getting `Content-Type` from response’s header list.
        // 3. If mimeType is null, reject returnValue with a TypeError and abort these substeps.
        // 4. Remove all HTTP tab or space byte from the start and end of mimeType.
        // 5. If mimeType is not a byte-case-insensitive match for `application/wasm`, reject returnValue with a TypeError and abort these substeps.
        // Note: extra parameters are not allowed, including the empty `application/wasm;`.
        // FIXME: Validate these extra constraints that are not checked by extract_mime_type()
        if (auto mime = response->header_list()->extract_mime_type(); !mime.has_value() || mime.value().essence() != "application/wasm"sv) {
            WebIDL::reject_promise(realm, return_value, vm.throw_completion<JS::TypeError>("Response does not match the application/wasm MIME type"sv).value());
            return JS::js_undefined();
        }

        // 6. If response is not CORS-same-origin, reject returnValue with a TypeError and abort these substeps.
        if (!response->is_cors_same_origin()) {
            WebIDL::reject_promise(realm, return_value, vm.throw_completion<JS::TypeError>("Response is not CORS-same-origin"sv).value());
            return JS::js_undefined();
        }

        // 7. If response’s status is not an ok status, reject returnValue with a TypeError and abort these substeps.
        if (!response_object.ok()) {
            WebIDL::reject_promise(realm, return_value, vm.throw_completion<JS::TypeError>("Response does not represent an ok status"sv).value());
            return JS::js_undefined();
        }

        // 8. Consume response’s body as an ArrayBuffer, and let bodyPromise be the result.
        auto body_promise_or_error = response_object.array_buffer();
        if (body_promise_or_error.is_error()) {
            auto throw_completion = Bindings::exception_to_throw_completion(realm.vm(), body_promise_or_error.release_error());
            WebIDL::reject_promise(realm, return_value, throw_completion.value());
            return JS::js_undefined();
        }
        auto body_promise = body_promise_or_error.release_value();

        // 9. Upon fulfillment of bodyPromise with value bodyArrayBuffer:
        auto body_fulfillment_steps = GC::create_function(vm.heap(), [&vm, return_value](JS::Value body_array_buffer) -> WebIDL::ExceptionOr<JS::Value> {
            // 1. Let stableBytes be a copy of the bytes held by the buffer bodyArrayBuffer.
            VERIFY(body_array_buffer.is_object());
            auto stable_bytes = WebIDL::get_buffer_source_copy(body_array_buffer.as_object());
            if (stable_bytes.is_error()) {
                VERIFY(stable_bytes.error().code() == ENOMEM);
                WebIDL::reject_promise(HTML::relevant_realm(*return_value->promise()), return_value, vm.throw_completion<JS::InternalError>(vm.error_message(JS::VM::ErrorMessage::OutOfMemory)).value());
                return JS::js_undefined();
            }

            // 2. Asynchronously compile the WebAssembly module stableBytes using the networking task source and resolve returnValue with the result.
            auto result = asynchronously_compile_webassembly_module(vm, stable_bytes.release_value(), HTML::Task::Source::Networking);

            // Need to manually convert WebIDL promise to an ECMAScript value here to resolve
            WebIDL::resolve_promise(HTML::relevant_realm(*return_value->promise()), return_value, result->promise());

            return JS::js_undefined();
        });

        // 10. Upon rejection of bodyPromise with reason reason:
        auto body_rejection_steps = GC::create_function(vm.heap(), [return_value](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
            // 1. Reject returnValue with reason.
            WebIDL::reject_promise(HTML::relevant_realm(*return_value->promise()), return_value, reason);
            return JS::js_undefined();
        });

        WebIDL::react_to_promise(body_promise, body_fulfillment_steps, body_rejection_steps);

        return JS::js_undefined();
    });

    // 3. Upon rejection of source with reason reason:
    auto rejection_steps = GC::create_function(vm.heap(), [return_value](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
        // 1. Reject returnValue with reason.
        WebIDL::reject_promise(HTML::relevant_realm(*return_value->promise()), return_value, reason);

        return JS::js_undefined();
    });

    WebIDL::react_to_promise(source, fulfillment_steps, rejection_steps);

    // 4. Return returnValue.
    return return_value;
}

#define DEFINE_WASM_NATIVE_ERROR(ClassName, snake_name, PrototypeName, ConstructorName)                                \
    GC_DEFINE_ALLOCATOR(ClassName);                                                                                    \
    GC::Ref<ClassName> ClassName::create(JS::Realm& realm)                                                             \
    {                                                                                                                  \
        return realm.create<ClassName>(Bindings::ensure_web_prototype<PrototypeName>(realm, #ClassName##_fly_string)); \
    }                                                                                                                  \
                                                                                                                       \
    GC::Ref<ClassName> ClassName::create(JS::Realm& realm, String message)                                             \
    {                                                                                                                  \
        auto& vm = realm.vm();                                                                                         \
        auto error = ClassName::create(realm);                                                                         \
        u8 const attr = JS::Attribute::Writable | JS::Attribute::Configurable;                                         \
        error->define_direct_property(vm.names.message, JS::PrimitiveString::create(vm, move(message)), attr);         \
        return error;                                                                                                  \
    }                                                                                                                  \
                                                                                                                       \
    GC::Ref<ClassName> ClassName::create(JS::Realm& realm, StringView message)                                         \
    {                                                                                                                  \
        return create(realm, MUST(String::from_utf8(message)));                                                        \
    }                                                                                                                  \
                                                                                                                       \
    ClassName::ClassName(JS::Object& prototype)                                                                        \
        : Error(prototype)                                                                                             \
    {                                                                                                                  \
    }

DEFINE_WASM_NATIVE_ERROR(CompileError, compile_error, CompileErrorPrototype, CompileErrorConstructor)
DEFINE_WASM_NATIVE_ERROR(LinkError, link_error, LinkErrorPrototype, LinkErrorConstructor)
DEFINE_WASM_NATIVE_ERROR(RuntimeError, runtime_error, RuntimeErrorPrototype, RuntimeErrorConstructor)

#undef DEFINE_WASM_NATIVE_ERROR

#define DEFINE_WASM_NATIVE_ERROR_CONSTRUCTOR(ClassName, snake_name, PrototypeName, ConstructorName)                                    \
    GC_DEFINE_ALLOCATOR(ConstructorName);                                                                                              \
    ConstructorName::ConstructorName(JS::Realm& realm)                                                                                 \
        : NativeFunction(#ClassName##_string, *realm.intrinsics().error_constructor())                                                 \
    {                                                                                                                                  \
    }                                                                                                                                  \
                                                                                                                                       \
    void ConstructorName::initialize(JS::Realm& realm)                                                                                 \
    {                                                                                                                                  \
        auto& vm = this->vm();                                                                                                         \
        Base::initialize(realm);                                                                                                       \
                                                                                                                                       \
        /* 20.5.6.2.1 NativeError.prototype, https://tc39.es/ecma262/#sec-nativeerror.prototype */                                     \
        define_direct_property(vm.names.prototype, &Bindings::ensure_web_prototype<PrototypeName>(realm, #ClassName##_fly_string), 0); \
                                                                                                                                       \
        define_direct_property(vm.names.length, JS::Value(1), JS::Attribute::Configurable);                                            \
    }                                                                                                                                  \
                                                                                                                                       \
    ConstructorName::~ConstructorName() = default;                                                                                     \
                                                                                                                                       \
    /* 20.5.6.1.1 NativeError ( message [ , options ] ), https://tc39.es/ecma262/#sec-nativeerror */                                   \
    JS::ThrowCompletionOr<JS::Value> ConstructorName::call()                                                                           \
    {                                                                                                                                  \
        /* 1. If NewTarget is undefined, let newTarget be the active function object; else let newTarget be NewTarget. */              \
        return TRY(construct(*this));                                                                                                  \
    }                                                                                                                                  \
                                                                                                                                       \
    /* 20.5.6.1.1 NativeError ( message [ , options ] ), https://tc39.es/ecma262/#sec-nativeerror */                                   \
    JS::ThrowCompletionOr<GC::Ref<JS::Object>> ConstructorName::construct(JS::FunctionObject& new_target)                              \
    {                                                                                                                                  \
        auto& vm = this->vm();                                                                                                         \
                                                                                                                                       \
        auto message = vm.argument(0);                                                                                                 \
        auto options = vm.argument(1);                                                                                                 \
                                                                                                                                       \
        /* 2. Let O be ? OrdinaryCreateFromConstructor(newTarget, "%NativeError.prototype%", « [[ErrorData]] »). */                    \
        auto error = TRY(ordinary_create_from_constructor<ClassName>(vm, new_target, &JS::Intrinsics::error_prototype));               \
                                                                                                                                       \
        /* 3. If message is not undefined, then */                                                                                     \
        if (!message.is_undefined()) {                                                                                                 \
            /* a. Let msg be ? ToString(message). */                                                                                   \
            auto msg = TRY(message.to_string(vm));                                                                                     \
                                                                                                                                       \
            /* b. Perform CreateNonEnumerableDataPropertyOrThrow(O, "message", msg). */                                                \
            error->create_non_enumerable_data_property_or_throw(vm.names.message, JS::PrimitiveString::create(vm, move(msg)));         \
        }                                                                                                                              \
                                                                                                                                       \
        /* 4. Perform ? InstallErrorCause(O, options). */                                                                              \
        TRY(error->install_error_cause(options));                                                                                      \
                                                                                                                                       \
        /* 5. Return O. */                                                                                                             \
        return error;                                                                                                                  \
    }

DEFINE_WASM_NATIVE_ERROR_CONSTRUCTOR(CompileError, compile_error, CompileErrorPrototype, CompileErrorConstructor)
DEFINE_WASM_NATIVE_ERROR_CONSTRUCTOR(LinkError, link_error, LinkErrorPrototype, LinkErrorConstructor)
DEFINE_WASM_NATIVE_ERROR_CONSTRUCTOR(RuntimeError, runtime_error, RuntimeErrorPrototype, RuntimeErrorConstructor)

#undef DEFINE_WASM_NATIVE_ERROR_CONSTRUCTOR

#define DEFINE_WASM_NATIVE_ERROR_PROTOTYPE(ClassName, snake_name, PrototypeName, ConstructorName)          \
    GC_DEFINE_ALLOCATOR(PrototypeName);                                                                    \
                                                                                                           \
    PrototypeName::PrototypeName(JS::Realm& realm)                                                         \
        : PrototypeObject(realm.intrinsics().error_prototype())                                            \
    {                                                                                                      \
    }                                                                                                      \
                                                                                                           \
    void PrototypeName::initialize(JS::Realm& realm)                                                       \
    {                                                                                                      \
        auto& vm = this->vm();                                                                             \
        Base::initialize(realm);                                                                           \
        u8 const attr = JS::Attribute::Writable | JS::Attribute::Configurable;                             \
        define_direct_property(vm.names.name, JS::PrimitiveString::create(vm, #ClassName##_string), attr); \
        define_direct_property(vm.names.message, JS::PrimitiveString::create(vm, String {}), attr);        \
    }

DEFINE_WASM_NATIVE_ERROR_PROTOTYPE(CompileError, compile_error, CompileErrorPrototype, CompileErrorConstructor)
DEFINE_WASM_NATIVE_ERROR_PROTOTYPE(LinkError, link_error, LinkErrorPrototype, LinkErrorConstructor)
DEFINE_WASM_NATIVE_ERROR_PROTOTYPE(RuntimeError, runtime_error, RuntimeErrorPrototype, RuntimeErrorConstructor)

#undef DEFINE_WASM_NATIVE_ERROR_PROTOTYPE

}

#define DEFINE_WASM_ERROR_PROTOTYPE_AND_CONSTRUCTOR_WEB_INTRINSIC(ClassName, snake_name, PrototypeName, ConstructorName)                       \
    template<>                                                                                                                                 \
    void Intrinsics::create_web_prototype_and_constructor<WebAssembly::PrototypeName>(JS::Realm & realm)                                       \
    {                                                                                                                                          \
        auto& vm = realm.vm();                                                                                                                 \
        auto prototype = heap().allocate<WebAssembly::PrototypeName>(realm);                                                                   \
        m_prototypes.set(#ClassName##_string, prototype);                                                                                      \
                                                                                                                                               \
        auto constructor = heap().allocate<WebAssembly::ConstructorName>(realm);                                                               \
        m_constructors.set(#ClassName##_string, constructor);                                                                                  \
                                                                                                                                               \
        prototype->define_direct_property(vm.names.constructor, constructor.ptr(), JS::Attribute::Writable | JS::Attribute::Configurable);     \
        constructor->define_direct_property(vm.names.name, JS::PrimitiveString::create(vm, #ClassName##_string), JS::Attribute::Configurable); \
    }

namespace Web::Bindings {
DEFINE_WASM_ERROR_PROTOTYPE_AND_CONSTRUCTOR_WEB_INTRINSIC(CompileError, compile_error, CompileErrorPrototype, CompileErrorConstructor)
DEFINE_WASM_ERROR_PROTOTYPE_AND_CONSTRUCTOR_WEB_INTRINSIC(LinkError, link_error, LinkErrorPrototype, LinkErrorConstructor)
DEFINE_WASM_ERROR_PROTOTYPE_AND_CONSTRUCTOR_WEB_INTRINSIC(RuntimeError, runtime_error, RuntimeErrorPrototype, RuntimeErrorConstructor)
}

#undef DEFINE_WASM_ERROR_PROTOTYPE_AND_CONSTRUCTOR_WEB_INTRINSIC