From 7bd8fd000f3f8e92ff632be2370a279ac2309250 Mon Sep 17 00:00:00 2001 From: Timothy Flynn Date: Mon, 9 Jan 2023 17:49:06 -0500 Subject: [PATCH] LibWeb: Generate dedicated methods to create Web constructors/prototypes Currently, for each exposed interface, we generate one massive function to create every Web constructor and prototype. In an effort to lazily create these instead, this first step is to extract the creation of each of these into its own method. First, this generates a forwarding header for all IDL types. This is to allow callers to remain unchanged without forcing them to include the (very heavy) generated IDL headers. This header is included by LibWeb's forwarding header. Next, this defines a base template method on Web::Bindings::Intrinsics to create a prototype/constructor pair. Specializations of this template are now generated in a new .cpp file, IntrinsicDefinitions.cpp. The base Intrinsics class is updated to use this new method, and will continue to cache the result. Last, some WebAssembly classes are updated to use this new mechanism. They were using some ad hoc cache keys that are now in line with the generated specializations. That one massive function is still used to invoke these specializations, so they are not lazy as of this commit. --- Meta/CMake/libweb_generators.cmake | 10 +- .../GenerateWindowOrWorkerInterfaces.cpp | 318 ++++++++++++++---- .../Libraries/LibWeb/Bindings/Intrinsics.h | 30 +- .../LibWeb/Fetch/HeadersIterator.cpp | 11 + Userland/Libraries/LibWeb/Forward.h | 2 + .../LibWeb/URL/URLSearchParamsIterator.cpp | 11 + .../WebAssemblyInstanceConstructor.cpp | 2 +- .../WebAssembly/WebAssemblyInstanceObject.cpp | 2 +- .../WebAssemblyMemoryConstructor.cpp | 2 +- .../WebAssemblyModuleConstructor.cpp | 2 +- .../WebAssembly/WebAssemblyModuleObject.cpp | 2 +- .../LibWeb/WebAssembly/WebAssemblyObject.cpp | 24 +- .../WebAssemblyTableConstructor.cpp | 2 +- .../WebAssembly/WebAssemblyTableObject.cpp | 2 +- 14 files changed, 313 insertions(+), 107 deletions(-) diff --git a/Meta/CMake/libweb_generators.cmake b/Meta/CMake/libweb_generators.cmake index 63ff5b2cc0..3b71144161 100644 --- a/Meta/CMake/libweb_generators.cmake +++ b/Meta/CMake/libweb_generators.cmake @@ -147,14 +147,18 @@ function (generate_js_bindings target) endfunction() function(generate_exposed_interface_files) - set(exposed_interface_sources DedicatedWorkerExposedInterfaces.cpp DedicatedWorkerExposedInterfaces.h - SharedWorkerExposedInterfaces.cpp SharedWorkerExposedInterfaces.h - WindowExposedInterfaces.cpp WindowExposedInterfaces.h) + set(exposed_interface_sources + Forward.h IntrinsicDefinitions.cpp + DedicatedWorkerExposedInterfaces.cpp DedicatedWorkerExposedInterfaces.h + SharedWorkerExposedInterfaces.cpp SharedWorkerExposedInterfaces.h + WindowExposedInterfaces.cpp WindowExposedInterfaces.h) list(TRANSFORM exposed_interface_sources PREPEND "Bindings/") add_custom_command( OUTPUT ${exposed_interface_sources} COMMAND "${CMAKE_COMMAND}" -E make_directory "tmp" COMMAND $ -o "${CMAKE_CURRENT_BINARY_DIR}/tmp" -b "${LIBWEB_INPUT_FOLDER}" ${LIBWEB_ALL_IDL_FILES} + COMMAND "${CMAKE_COMMAND}" -E copy_if_different tmp/Forward.h "Bindings/Forward.h" + COMMAND "${CMAKE_COMMAND}" -E copy_if_different tmp/IntrinsicDefinitions.cpp "Bindings/IntrinsicDefinitions.cpp" COMMAND "${CMAKE_COMMAND}" -E copy_if_different tmp/DedicatedWorkerExposedInterfaces.h "Bindings/DedicatedWorkerExposedInterfaces.h" COMMAND "${CMAKE_COMMAND}" -E copy_if_different tmp/DedicatedWorkerExposedInterfaces.cpp "Bindings/DedicatedWorkerExposedInterfaces.cpp" COMMAND "${CMAKE_COMMAND}" -E copy_if_different tmp/SharedWorkerExposedInterfaces.h "Bindings/SharedWorkerExposedInterfaces.h" diff --git a/Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateWindowOrWorkerInterfaces.cpp b/Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateWindowOrWorkerInterfaces.cpp index d32ce65d8e..6ecdec0e5f 100644 --- a/Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateWindowOrWorkerInterfaces.cpp +++ b/Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateWindowOrWorkerInterfaces.cpp @@ -14,9 +14,241 @@ #include #include -static ErrorOr add_to_interface_sets(IDL::Interface&, Vector& window_exposed, Vector& dedicated_worker_exposed, Vector& shared_worker_exposed); +static ErrorOr add_to_interface_sets(IDL::Interface&, Vector& intrinsics, Vector& window_exposed, Vector& dedicated_worker_exposed, Vector& shared_worker_exposed); static DeprecatedString s_error_string; +struct LegacyConstructor { + DeprecatedString name; + DeprecatedString constructor_class; +}; + +static void consume_whitespace(GenericLexer& lexer) +{ + bool consumed = true; + while (consumed) { + consumed = lexer.consume_while(is_ascii_space).length() > 0; + + if (lexer.consume_specific("//")) { + lexer.consume_until('\n'); + lexer.ignore(); + consumed = true; + } + } +} + +static Optional const& lookup_legacy_constructor(IDL::Interface& interface) +{ + static HashMap> s_legacy_constructors; + if (auto cache = s_legacy_constructors.get(interface.name); cache.has_value()) + return cache.value(); + + auto attribute = interface.extended_attributes.get("LegacyFactoryFunction"sv); + if (!attribute.has_value()) { + s_legacy_constructors.set(interface.name, {}); + return s_legacy_constructors.get(interface.name).value(); + } + + GenericLexer function_lexer(attribute.value()); + consume_whitespace(function_lexer); + + auto name = function_lexer.consume_until([](auto ch) { return is_ascii_space(ch) || ch == '('; }); + auto constructor_class = DeprecatedString::formatted("{}Constructor", name); + + s_legacy_constructors.set(interface.name, LegacyConstructor { name, move(constructor_class) }); + return s_legacy_constructors.get(interface.name).value(); +} + +static ErrorOr generate_forwarding_header(StringView output_path, Vector& exposed_interfaces) +{ + StringBuilder builder; + SourceGenerator generator(builder); + + generator.append(R"~~~( +#pragma once + +namespace Web::Bindings { +)~~~"); + + auto add_interface = [](SourceGenerator& gen, StringView prototype_class, StringView constructor_class, Optional const& legacy_constructor) { + gen.set("prototype_class", prototype_class); + gen.set("constructor_class", constructor_class); + + gen.append(R"~~~( +class @prototype_class@; +class @constructor_class@;)~~~"); + + if (legacy_constructor.has_value()) { + gen.set("legacy_constructor_class", legacy_constructor->constructor_class); + gen.append(R"~~~( +class @legacy_constructor_class@;)~~~"); + } + }; + + for (auto& interface : exposed_interfaces) { + auto gen = generator.fork(); + add_interface(gen, interface.prototype_class, interface.constructor_class, lookup_legacy_constructor(interface)); + } + + // FIXME: Special case window. We should convert Window and Location to use IDL. + { + auto gen = generator.fork(); + add_interface(gen, "WindowPrototype"sv, "WindowConstructor"sv, {}); + add_interface(gen, "LocationPrototype"sv, "LocationConstructor"sv, {}); + } + + // FIXME: Special case WebAssembly. We should convert WASM to use IDL. + { + auto gen = generator.fork(); + add_interface(gen, "WebAssemblyMemoryPrototype"sv, "WebAssemblyMemoryConstructor"sv, {}); + add_interface(gen, "WebAssemblyInstancePrototype"sv, "WebAssemblyInstanceConstructor"sv, {}); + add_interface(gen, "WebAssemblyModulePrototype"sv, "WebAssemblyModuleConstructor"sv, {}); + add_interface(gen, "WebAssemblyTablePrototype"sv, "WebAssemblyTableConstructor"sv, {}); + } + + generator.append(R"~~~( + +} +)~~~"); + + auto generated_forward_path = LexicalPath(output_path).append("Forward.h"sv).string(); + auto generated_forward_file = TRY(Core::Stream::File::open(generated_forward_path, Core::Stream::OpenMode::Write)); + TRY(generated_forward_file->write(generator.as_string_view().bytes())); + + return {}; +} + +static ErrorOr generate_intrinsic_definitions(StringView output_path, Vector& exposed_interfaces) +{ + StringBuilder builder; + SourceGenerator generator(builder); + + generator.append(R"~~~( +#include +#include +#include )~~~"); + + for (auto& interface : exposed_interfaces) { + auto gen = generator.fork(); + gen.set("prototype_class", interface.prototype_class); + gen.set("constructor_class", interface.constructor_class); + + gen.append(R"~~~( +#include +#include )~~~"); + + if (auto const& legacy_constructor = lookup_legacy_constructor(interface); legacy_constructor.has_value()) { + gen.set("legacy_constructor_class", legacy_constructor->constructor_class); + gen.append(R"~~~( +#include )~~~"); + } + } + + // FIXME: Special case window. We should convert Window and Location to use IDL. + generator.append(R"~~~( +#include +#include +#include +#include )~~~"); + + // FIXME: Special case WebAssembly. We should convert WASM to use IDL. + generator.append(R"~~~( +#include +#include +#include +#include +#include +#include +#include +#include )~~~"); + + generator.append(R"~~~( + +namespace Web::Bindings { +)~~~"); + + auto add_interface = [&](SourceGenerator& gen, StringView name, StringView prototype_class, StringView constructor_class, Optional const& legacy_constructor, bool attach_to_global) { + gen.set("interface_name", name); + gen.set("prototype_class", prototype_class); + gen.set("constructor_class", constructor_class); + + gen.append(R"~~~( +template<> +void Intrinsics::create_web_prototype_and_constructor<@prototype_class@>(JS::Realm& realm) +{ + auto& vm = realm.vm(); + + auto prototype = heap().allocate<@prototype_class@>(realm, realm); + m_prototypes.set("@interface_name@"sv, prototype); + + auto constructor = heap().allocate<@constructor_class@>(realm, realm); + m_constructors.set("@interface_name@"sv, constructor); +)~~~"); + + if (attach_to_global) { + gen.append(R"~~~( + auto& global = realm.global_object(); + global.define_direct_property("@interface_name@", constructor.ptr(), JS::Attribute::Writable | JS::Attribute::Configurable);)~~~"); + } + + gen.append(R"~~~( + 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, "@interface_name@"sv), JS::Attribute::Configurable); +)~~~"); + + if (legacy_constructor.has_value()) { + gen.set("legacy_interface_name", legacy_constructor->name); + gen.set("legacy_constructor_class", legacy_constructor->constructor_class); + gen.append(R"~~~( + auto legacy_constructor = heap().allocate<@legacy_constructor_class@>(realm, realm); + m_constructors.set("@legacy_interface_name@"sv, legacy_constructor); +)~~~"); + + if (attach_to_global) { + gen.append(R"~~~( + global.define_direct_property("@legacy_interface_name@", legacy_constructor.ptr(), JS::Attribute::Writable | JS::Attribute::Configurable);)~~~"); + } + + gen.append(R"~~~( + legacy_constructor->define_direct_property(vm.names.name, JS::PrimitiveString::create(vm, "@legacy_interface_name@"sv), JS::Attribute::Configurable);)~~~"); + } + + gen.append(R"~~~( +} +)~~~"); + }; + + for (auto& interface : exposed_interfaces) { + auto gen = generator.fork(); + add_interface(gen, interface.name, interface.prototype_class, interface.constructor_class, lookup_legacy_constructor(interface), true); + } + + // FIXME: Special case window. We should convert Window and Location to use IDL + { + auto gen = generator.fork(); + add_interface(gen, "Window"sv, "WindowPrototype"sv, "WindowConstructor"sv, {}, true); + add_interface(gen, "Location"sv, "LocationPrototype"sv, "LocationConstructor"sv, {}, true); + } + + // FIXME: Special case WebAssembly. We should convert WASM to use IDL. + { + auto gen = generator.fork(); + add_interface(gen, "WebAssembly.Memory"sv, "WebAssemblyMemoryPrototype"sv, "WebAssemblyMemoryConstructor"sv, {}, false); + add_interface(gen, "WebAssembly.Instance"sv, "WebAssemblyInstancePrototype"sv, "WebAssemblyInstanceConstructor"sv, {}, false); + add_interface(gen, "WebAssembly.Module"sv, "WebAssemblyModulePrototype"sv, "WebAssemblyModuleConstructor"sv, {}, false); + add_interface(gen, "WebAssembly.Table"sv, "WebAssemblyTablePrototype"sv, "WebAssemblyTableConstructor"sv, {}, false); + } + + generator.append(R"~~~( +} +)~~~"); + + auto generated_intrinsics_path = LexicalPath(output_path).append("IntrinsicDefinitions.cpp"sv).string(); + auto generated_intrinsics_file = TRY(Core::Stream::File::open(generated_intrinsics_path, Core::Stream::OpenMode::Write)); + TRY(generated_intrinsics_file->write(generator.as_string_view().bytes())); + + return {}; +} + static ErrorOr generate_exposed_interface_header(StringView class_name, StringView output_path) { StringBuilder builder; @@ -63,10 +295,14 @@ static ErrorOr generate_exposed_interface_implementation(StringView class_ gen.set("constructor_class", interface.constructor_class); gen.append(R"~~~(#include +#include )~~~"); - if (interface.parent_name != "[Synthetic Interface]"sv) - gen.append(R"~~~(#include + + if (auto const& legacy_constructor = lookup_legacy_constructor(interface); legacy_constructor.has_value()) { + gen.set("legacy_constructor_class", legacy_constructor->constructor_class); + gen.append(R"~~~(#include )~~~"); + } } // FIXME: Special case window. We should convert Window and Location to use IDL @@ -92,36 +328,31 @@ void add_@global_object_snake_name@_exposed_interfaces(JS::Object& global, JS::R JS::DeferGC defer_gc(vm.heap()); )~~~"); - auto add_interface = [](SourceGenerator& gen, StringView name, StringView prototype_class, StringView constructor_class) { + auto add_interface = [](SourceGenerator& gen, StringView name, StringView prototype_class) { gen.set("interface_name", name); gen.set("prototype_class", prototype_class); - gen.set("constructor_class", constructor_class); - gen.append(R"~~~( { - auto& prototype = Bindings::ensure_web_prototype(realm, "@interface_name@"); - auto& constructor = Bindings::ensure_web_constructor(realm, "@interface_name@"); - global.define_direct_property("@interface_name@", &constructor, JS::Attribute::Writable | JS::Attribute::Configurable); - prototype.define_direct_property(vm.names.constructor, &constructor, JS::Attribute::Writable | JS::Attribute::Configurable); - constructor.define_direct_property(vm.names.name, JS::PrimitiveString::create(vm, "@interface_name@"), JS::Attribute::Configurable); - } -)~~~"); }; + gen.append(R"~~~( + (void)ensure_web_prototype<@prototype_class@>(realm, "@interface_name@"sv);)~~~"); }; for (auto& interface : exposed_interfaces) { auto gen = generator.fork(); - add_interface(gen, interface.name, interface.prototype_class, interface.constructor_class); + add_interface(gen, interface.name, interface.prototype_class); } // FIXME: Special case window. We should convert Window and Location to use IDL if (class_name == "Window"sv) { auto gen = generator.fork(); - add_interface(gen, "Window"sv, "WindowPrototype"sv, "WindowConstructor"sv); - add_interface(gen, "Location"sv, "LocationPrototype"sv, "LocationConstructor"sv); + add_interface(gen, "Window"sv, "WindowPrototype"sv); + add_interface(gen, "Location"sv, "LocationPrototype"sv); } generator.append(R"~~~( } + } )~~~"); + auto generated_implementation_path = LexicalPath(output_path).append(DeprecatedString::formatted("{}ExposedInterfaces.cpp", class_name)).string(); auto generated_implementation_file = TRY(Core::Stream::File::open(generated_implementation_path, Core::Stream::OpenMode::Write)); TRY(generated_implementation_file->write(generator.as_string_view().bytes())); @@ -162,6 +393,7 @@ ErrorOr serenity_main(Main::Arguments arguments) VERIFY(paths.size() == file_contents.size()); Vector parsers; + Vector intrinsics; Vector window_exposed; Vector dedicated_worker_exposed; Vector shared_worker_exposed; @@ -169,10 +401,13 @@ ErrorOr serenity_main(Main::Arguments arguments) for (size_t i = 0; i < paths.size(); ++i) { IDL::Parser parser(paths[i], file_contents[i], lexical_base.string()); - TRY(add_to_interface_sets(parser.parse(), window_exposed, dedicated_worker_exposed, shared_worker_exposed)); + TRY(add_to_interface_sets(parser.parse(), intrinsics, window_exposed, dedicated_worker_exposed, shared_worker_exposed)); parsers.append(move(parser)); } + TRY(generate_forwarding_header(output_path, intrinsics)); + TRY(generate_intrinsic_definitions(output_path, intrinsics)); + TRY(generate_exposed_interface_header("Window"sv, output_path)); TRY(generate_exposed_interface_header("DedicatedWorker"sv, output_path)); TRY(generate_exposed_interface_header("SharedWorker"sv, output_path)); @@ -186,20 +421,6 @@ ErrorOr serenity_main(Main::Arguments arguments) return 0; } -static void consume_whitespace(GenericLexer& lexer) -{ - bool consumed = true; - while (consumed) { - consumed = lexer.consume_while(is_ascii_space).length() > 0; - - if (lexer.consume_specific("//")) { - lexer.consume_until('\n'); - lexer.ignore(); - consumed = true; - } - } -} - enum ExposedTo { Nobody = 0x0, DedicatedWorker = 0x1, @@ -264,30 +485,15 @@ static ErrorOr parse_exposure_set(IDL::Interface& interface) return Error::from_string_view(s_error_string); } -static IDL::Interface& add_synthetic_interface(IDL::Interface& reference_interface) -{ - static Vector> s_synthetic_interfaces; - - GenericLexer function_lexer(reference_interface.extended_attributes.get("LegacyFactoryFunction").value()); - consume_whitespace(function_lexer); - auto name = function_lexer.consume_until([](auto ch) { return is_ascii_space(ch) || ch == '('; }); - - auto new_interface = make(); - new_interface->name = name; - new_interface->constructor_class = DeprecatedString::formatted("{}Constructor", new_interface->name); - new_interface->prototype_class = reference_interface.prototype_class; - new_interface->parent_name = "[Synthetic Interface]"; - - s_synthetic_interfaces.append(move(new_interface)); - return *s_synthetic_interfaces.last(); -} - -ErrorOr add_to_interface_sets(IDL::Interface& interface, Vector& window_exposed, Vector& dedicated_worker_exposed, Vector& shared_worker_exposed) +ErrorOr add_to_interface_sets(IDL::Interface& interface, Vector& intrinsics, Vector& window_exposed, Vector& dedicated_worker_exposed, Vector& shared_worker_exposed) { // TODO: Add service worker exposed and audio worklet exposed auto whom = TRY(parse_exposure_set(interface)); VERIFY(whom != ExposedTo::Nobody); + if ((whom & ExposedTo::Window) || (whom & ExposedTo::DedicatedWorker) || (whom & ExposedTo::SharedWorker)) + intrinsics.append(interface); + if (whom & ExposedTo::Window) window_exposed.append(interface); @@ -297,17 +503,5 @@ ErrorOr add_to_interface_sets(IDL::Interface& interface, Vector + template JS::Object& ensure_web_prototype(DeprecatedString const& class_name) { - auto it = m_prototypes.find(class_name); - if (it != m_prototypes.end()) + if (auto it = m_prototypes.find(class_name); it != m_prototypes.end()) return *it->value; - auto& realm = *m_realm; - auto prototype = heap().allocate(realm, realm); - m_prototypes.set(class_name, prototype); - return prototype; + + create_web_prototype_and_constructor(*m_realm); + return *m_prototypes.find(class_name)->value; } - template + template JS::NativeFunction& ensure_web_constructor(DeprecatedString const& class_name) { - auto it = m_constructors.find(class_name); - if (it != m_constructors.end()) + if (auto it = m_constructors.find(class_name); it != m_constructors.end()) return *it->value; - auto& realm = *m_realm; - auto constructor = heap().allocate(realm, realm); - m_constructors.set(class_name, constructor); - return constructor; + + create_web_prototype_and_constructor(*m_realm); + return *m_constructors.find(class_name)->value; } private: virtual void visit_edges(JS::Cell::Visitor&) override; - HashMap m_prototypes; - HashMap m_constructors; + template + void create_web_prototype_and_constructor(JS::Realm& realm); + HashMap> m_prototypes; + HashMap> m_constructors; JS::NonnullGCPtr m_realm; }; diff --git a/Userland/Libraries/LibWeb/Fetch/HeadersIterator.cpp b/Userland/Libraries/LibWeb/Fetch/HeadersIterator.cpp index 9544118575..342f290c1e 100644 --- a/Userland/Libraries/LibWeb/Fetch/HeadersIterator.cpp +++ b/Userland/Libraries/LibWeb/Fetch/HeadersIterator.cpp @@ -10,6 +10,17 @@ #include #include +namespace Web::Bindings { + +template<> +void Intrinsics::create_web_prototype_and_constructor(JS::Realm& realm) +{ + auto prototype = heap().allocate(realm, realm); + m_prototypes.set("HeadersIterator"sv, prototype); +} + +} + namespace Web::Fetch { JS::NonnullGCPtr HeadersIterator::create(Headers const& headers, JS::Object::PropertyKind iteration_kind) diff --git a/Userland/Libraries/LibWeb/Forward.h b/Userland/Libraries/LibWeb/Forward.h index 0e69beb304..74f2c1fb5e 100644 --- a/Userland/Libraries/LibWeb/Forward.h +++ b/Userland/Libraries/LibWeb/Forward.h @@ -7,6 +7,8 @@ #pragma once +#include + namespace Web { class XMLDocumentBuilder; } diff --git a/Userland/Libraries/LibWeb/URL/URLSearchParamsIterator.cpp b/Userland/Libraries/LibWeb/URL/URLSearchParamsIterator.cpp index 902dd499b4..6b289fe2c1 100644 --- a/Userland/Libraries/LibWeb/URL/URLSearchParamsIterator.cpp +++ b/Userland/Libraries/LibWeb/URL/URLSearchParamsIterator.cpp @@ -10,6 +10,17 @@ #include #include +namespace Web::Bindings { + +template<> +void Intrinsics::create_web_prototype_and_constructor(JS::Realm& realm) +{ + auto prototype = heap().allocate(realm, realm); + m_prototypes.set("URLSearchParamsIterator"sv, prototype); +} + +} + namespace Web::URL { JS::NonnullGCPtr URLSearchParamsIterator::create(URLSearchParams const& url_search_params, JS::Object::PropertyKind iteration_kind) diff --git a/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyInstanceConstructor.cpp b/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyInstanceConstructor.cpp index a2d71570d6..d5ce97272e 100644 --- a/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyInstanceConstructor.cpp +++ b/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyInstanceConstructor.cpp @@ -44,7 +44,7 @@ void WebAssemblyInstanceConstructor::initialize(JS::Realm& realm) auto& vm = this->vm(); NativeFunction::initialize(realm); - define_direct_property(vm.names.prototype, &Bindings::ensure_web_prototype(realm, "WebAssemblyInstancePrototype"), 0); + define_direct_property(vm.names.prototype, &Bindings::ensure_web_prototype(realm, "WebAssembly.Instance"), 0); define_direct_property(vm.names.length, JS::Value(1), JS::Attribute::Configurable); } diff --git a/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyInstanceObject.cpp b/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyInstanceObject.cpp index bd616a0982..f32989e89d 100644 --- a/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyInstanceObject.cpp +++ b/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyInstanceObject.cpp @@ -19,7 +19,7 @@ namespace Web::Bindings { WebAssemblyInstanceObject::WebAssemblyInstanceObject(JS::Realm& realm, size_t index) - : Object(ConstructWithPrototypeTag::Tag, Bindings::ensure_web_prototype(realm, "WebAssemblyInstancePrototype")) + : Object(ConstructWithPrototypeTag::Tag, Bindings::ensure_web_prototype(realm, "WebAssembly.Instance")) , m_index(index) { } diff --git a/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyMemoryConstructor.cpp b/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyMemoryConstructor.cpp index bbb04cd1bf..30ebd209a5 100644 --- a/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyMemoryConstructor.cpp +++ b/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyMemoryConstructor.cpp @@ -54,7 +54,7 @@ void WebAssemblyMemoryConstructor::initialize(JS::Realm& realm) auto& vm = this->vm(); NativeFunction::initialize(realm); - define_direct_property(vm.names.prototype, &Bindings::ensure_web_prototype(realm, "WebAssemblyMemoryPrototype"), 0); + define_direct_property(vm.names.prototype, &Bindings::ensure_web_prototype(realm, "WebAssembly.Memory"), 0); define_direct_property(vm.names.length, JS::Value(1), JS::Attribute::Configurable); } diff --git a/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyModuleConstructor.cpp b/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyModuleConstructor.cpp index ab11610d3d..1a0ed6802d 100644 --- a/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyModuleConstructor.cpp +++ b/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyModuleConstructor.cpp @@ -41,7 +41,7 @@ void WebAssemblyModuleConstructor::initialize(JS::Realm& realm) auto& vm = this->vm(); NativeFunction::initialize(realm); - define_direct_property(vm.names.prototype, &Bindings::ensure_web_prototype(realm, "WebAssemblyModulePrototype"), 0); + define_direct_property(vm.names.prototype, &Bindings::ensure_web_prototype(realm, "WebAssembly.Module"), 0); define_direct_property(vm.names.length, JS::Value(1), JS::Attribute::Configurable); } diff --git a/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyModuleObject.cpp b/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyModuleObject.cpp index 70cd7c2d82..a73b50d5ee 100644 --- a/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyModuleObject.cpp +++ b/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyModuleObject.cpp @@ -11,7 +11,7 @@ namespace Web::Bindings { WebAssemblyModuleObject::WebAssemblyModuleObject(JS::Realm& realm, size_t index) - : Object(ConstructWithPrototypeTag::Tag, Bindings::ensure_web_prototype(realm, "WebAssemblyModulePrototype")) + : Object(ConstructWithPrototypeTag::Tag, Bindings::ensure_web_prototype(realm, "WebAssembly.Module")) , m_index(index) { } diff --git a/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyObject.cpp b/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyObject.cpp index ea4507cd0b..5d1592bce1 100644 --- a/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyObject.cpp +++ b/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyObject.cpp @@ -40,30 +40,16 @@ void WebAssemblyObject::initialize(JS::Realm& realm) define_native_function(realm, "compile", compile, 1, attr); define_native_function(realm, "instantiate", instantiate, 1, attr); - auto& vm = this->vm(); - - auto& memory_constructor = Bindings::ensure_web_constructor(realm, "WebAssembly.Memory"); - memory_constructor.define_direct_property(vm.names.name, JS::PrimitiveString::create(vm, "WebAssembly.Memory"), JS::Attribute::Configurable); - auto& memory_prototype = Bindings::ensure_web_prototype(realm, "WebAssemblyMemoryPrototype"); - memory_prototype.define_direct_property(vm.names.constructor, &memory_constructor, JS::Attribute::Writable | JS::Attribute::Configurable); + auto& memory_constructor = Bindings::ensure_web_constructor(realm, "WebAssembly.Memory"sv); define_direct_property("Memory", &memory_constructor, JS::Attribute::Writable | JS::Attribute::Configurable); - auto& instance_constructor = Bindings::ensure_web_constructor(realm, "WebAssembly.Instance"); - instance_constructor.define_direct_property(vm.names.name, JS::PrimitiveString::create(vm, "WebAssembly.Instance"), JS::Attribute::Configurable); - auto& instance_prototype = Bindings::ensure_web_prototype(realm, "WebAssemblyInstancePrototype"); - instance_prototype.define_direct_property(vm.names.constructor, &instance_constructor, JS::Attribute::Writable | JS::Attribute::Configurable); + auto& instance_constructor = Bindings::ensure_web_constructor(realm, "WebAssembly.Instance"sv); define_direct_property("Instance", &instance_constructor, JS::Attribute::Writable | JS::Attribute::Configurable); - auto& module_constructor = Bindings::ensure_web_constructor(realm, "WebAssembly.Module"); - module_constructor.define_direct_property(vm.names.name, JS::PrimitiveString::create(vm, "WebAssembly.Module"), JS::Attribute::Configurable); - auto& module_prototype = Bindings::ensure_web_prototype(realm, "WebAssemblyModulePrototype"); - module_prototype.define_direct_property(vm.names.constructor, &module_constructor, JS::Attribute::Writable | JS::Attribute::Configurable); + auto& module_constructor = Bindings::ensure_web_constructor(realm, "WebAssembly.Module"sv); define_direct_property("Module", &module_constructor, JS::Attribute::Writable | JS::Attribute::Configurable); - auto& table_constructor = Bindings::ensure_web_constructor(realm, "WebAssembly.Table"); - table_constructor.define_direct_property(vm.names.name, JS::PrimitiveString::create(vm, "WebAssembly.Table"), JS::Attribute::Configurable); - auto& table_prototype = Bindings::ensure_web_prototype(realm, "WebAssemblyTablePrototype"); - table_prototype.define_direct_property(vm.names.constructor, &table_constructor, JS::Attribute::Writable | JS::Attribute::Configurable); + auto& table_constructor = Bindings::ensure_web_constructor(realm, "WebAssembly.Table"sv); define_direct_property("Table", &table_constructor, JS::Attribute::Writable | JS::Attribute::Configurable); } @@ -483,7 +469,7 @@ JS::NativeFunction* create_native_function(JS::VM& vm, Wasm::FunctionAddress add } WebAssemblyMemoryObject::WebAssemblyMemoryObject(JS::Realm& realm, Wasm::MemoryAddress address) - : Object(ConstructWithPrototypeTag::Tag, Bindings::ensure_web_prototype(realm, "WebAssemblyMemoryPrototype")) + : Object(ConstructWithPrototypeTag::Tag, Bindings::ensure_web_prototype(realm, "WebAssembly.Memory")) , m_address(address) { } diff --git a/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyTableConstructor.cpp b/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyTableConstructor.cpp index 337d32b52e..23bc35df7b 100644 --- a/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyTableConstructor.cpp +++ b/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyTableConstructor.cpp @@ -85,7 +85,7 @@ void WebAssemblyTableConstructor::initialize(JS::Realm& realm) auto& vm = this->vm(); NativeFunction::initialize(realm); - define_direct_property(vm.names.prototype, &Bindings::ensure_web_prototype(realm, "WebAssemblyTablePrototype"), 0); + define_direct_property(vm.names.prototype, &Bindings::ensure_web_prototype(realm, "WebAssembly.Table"), 0); define_direct_property(vm.names.length, JS::Value(1), JS::Attribute::Configurable); } diff --git a/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyTableObject.cpp b/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyTableObject.cpp index d03c4461a0..7569e1f3c7 100644 --- a/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyTableObject.cpp +++ b/Userland/Libraries/LibWeb/WebAssembly/WebAssemblyTableObject.cpp @@ -11,7 +11,7 @@ namespace Web::Bindings { WebAssemblyTableObject::WebAssemblyTableObject(JS::Realm& realm, Wasm::TableAddress address) - : Object(ConstructWithPrototypeTag::Tag, Bindings::ensure_web_prototype(realm, "WebAssemblyTablePrototype")) + : Object(ConstructWithPrototypeTag::Tag, Bindings::ensure_web_prototype(realm, "WebAssembly.Table")) , m_address(address) { }