summaryrefslogtreecommitdiffstats
path: root/js/src/shell/ShellModuleObjectWrapper.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'js/src/shell/ShellModuleObjectWrapper.cpp')
-rw-r--r--js/src/shell/ShellModuleObjectWrapper.cpp479
1 files changed, 479 insertions, 0 deletions
diff --git a/js/src/shell/ShellModuleObjectWrapper.cpp b/js/src/shell/ShellModuleObjectWrapper.cpp
new file mode 100644
index 0000000000..9f1b9fd59c
--- /dev/null
+++ b/js/src/shell/ShellModuleObjectWrapper.cpp
@@ -0,0 +1,479 @@
+/* -*- Mode: javascript; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4
+ * -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "shell/ShellModuleObjectWrapper.h"
+
+#include "mozilla/Maybe.h"
+#include "mozilla/Span.h"
+
+#include "jsapi.h" // JS_GetProperty, JS::Call, JS_NewPlainObject, JS_DefineProperty
+
+#include "builtin/ModuleObject.h" // js::ModuleObject
+#include "js/CallAndConstruct.h" // JS::Call
+#include "js/CallArgs.h" // JS::CallArgs
+#include "js/CallNonGenericMethod.h" // CallNonGenericMethod
+#include "js/Class.h" // JSClass, JSCLASS_*
+#include "js/ColumnNumber.h" // JS::ColumnNumberOneOrigin
+#include "js/ErrorReport.h" // JS_ReportErrorASCII
+#include "js/PropertyAndElement.h" // JS_GetProperty
+#include "js/PropertySpec.h" // JSPropertySpec, JS_PSG, JS_PS_END, JSFunctionSpec, JS_FN, JS_FN_END
+#include "js/RootingAPI.h" // JS::Rooted, JS::Handle, JS::MutableHandle
+#include "js/Value.h" // JS::Value
+#include "vm/ArrayObject.h" // ArrayObject, NewDenseFullyAllocatedArray
+#include "vm/GlobalObject.h" // DefinePropertiesAndFunctions
+#include "vm/JSFunction.h" // JSFunction
+#include "vm/JSObject.h" // JSObject
+#include "vm/List.h" // ListObject
+#include "vm/NativeObject.h" // NativeObject
+#include "vm/Stack.h" // FixedInvokeArgs
+
+#include "vm/NativeObject-inl.h" // NativeObject::ensureDenseInitializedLength
+
+using namespace js;
+using namespace js::shell;
+
+using mozilla::Span;
+
+#define DEFINE_CLASS_IMPL(CLASS) \
+ CLASS* Shell##CLASS##Wrapper::get() { \
+ return &getReservedSlot(TargetSlot).toObject().as<CLASS>(); \
+ } \
+ /* static */ const JSClass Shell##CLASS##Wrapper::class_ = { \
+ "Shell" #CLASS "Wrapper", \
+ JSCLASS_HAS_RESERVED_SLOTS(Shell##CLASS##Wrapper::SlotCount)}; \
+ MOZ_ALWAYS_INLINE bool IsShell##CLASS##Wrapper(JS::Handle<JS::Value> v) { \
+ return v.isObject() && v.toObject().is<Shell##CLASS##Wrapper>(); \
+ }
+
+#define DEFINE_CLASS(CLASS) \
+ class Shell##CLASS##Wrapper : public js::NativeObject { \
+ public: \
+ using Target = CLASS; \
+ enum ModuleSlot { TargetSlot = 0, SlotCount }; \
+ static const JSClass class_; \
+ static Shell##CLASS##Wrapper* create(JSContext* cx, \
+ JS::Handle<CLASS*> obj); \
+ CLASS* get(); \
+ }; \
+ DEFINE_CLASS_IMPL(CLASS)
+
+#define DEFINE_NATIVE_CLASS_IMPL(CLASS) \
+ CLASS* Shell##CLASS##Wrapper::get() { \
+ return static_cast<CLASS*>(getReservedSlot(TargetSlot).toPrivate()); \
+ } \
+ /* static */ const JSClass Shell##CLASS##Wrapper::class_ = { \
+ "Shell" #CLASS "Wrapper", \
+ JSCLASS_HAS_RESERVED_SLOTS(Shell##CLASS##Wrapper::SlotCount)}; \
+ MOZ_ALWAYS_INLINE bool IsShell##CLASS##Wrapper(JS::Handle<JS::Value> v) { \
+ return v.isObject() && v.toObject().is<Shell##CLASS##Wrapper>(); \
+ }
+
+#define DEFINE_NATIVE_CLASS(CLASS) \
+ class Shell##CLASS##Wrapper : public js::NativeObject { \
+ public: \
+ using Target = CLASS; \
+ enum ModuleSlot { OwnerSlot = 0, TargetSlot, SlotCount }; \
+ static const JSClass class_; \
+ static Shell##CLASS##Wrapper* create(JSContext* cx, \
+ JS::Handle<JSObject*> owner, \
+ CLASS* obj); \
+ CLASS* get(); \
+ }; \
+ DEFINE_NATIVE_CLASS_IMPL(CLASS)
+
+DEFINE_CLASS(ModuleRequestObject)
+DEFINE_NATIVE_CLASS(ImportEntry)
+DEFINE_NATIVE_CLASS(ExportEntry)
+DEFINE_NATIVE_CLASS(RequestedModule)
+// NOTE: We don't need wrapper for IndirectBindingMap and ModuleNamespaceObject
+DEFINE_CLASS_IMPL(ModuleObject)
+
+#undef DEFINE_CLASS
+#undef DEFINE_CLASS_IMPL
+#undef DEFINE_NATIVE_CLASS
+#undef DEFINE_NATIVE_CLASS_IMPL
+
+bool IdentFilter(JSContext* cx, JS::Handle<JS::Value> from,
+ JS::MutableHandle<JS::Value> to) {
+ to.set(from);
+ return true;
+}
+
+template <class T>
+bool SingleFilter(JSContext* cx, JS::Handle<JS::Value> from,
+ JS::MutableHandle<JS::Value> to) {
+ using TargetT = typename T::Target;
+
+ if (!from.isObject() || !from.toObject().is<TargetT>()) {
+ to.set(from);
+ return true;
+ }
+
+ JS::Rooted<TargetT*> obj(cx, &from.toObject().as<TargetT>());
+ JS::Rooted<T*> filtered(cx, T::create(cx, obj));
+ if (!filtered) {
+ return false;
+ }
+ to.setObject(*filtered);
+ return true;
+}
+
+template <class T>
+bool ArrayFilter(JSContext* cx, JS::Handle<JS::Value> from,
+ JS::MutableHandle<JS::Value> to) {
+ using TargetT = typename T::Target;
+
+ if (!from.isObject() || !from.toObject().is<ArrayObject>()) {
+ to.set(from);
+ return true;
+ }
+
+ JS::Rooted<ArrayObject*> fromArray(cx, &from.toObject().as<ArrayObject>());
+ uint32_t length = fromArray->length();
+ JS::Rooted<ArrayObject*> toArray(cx, NewDenseFullyAllocatedArray(cx, length));
+ if (!toArray) {
+ return false;
+ }
+
+ toArray->ensureDenseInitializedLength(0, length);
+
+ for (uint32_t i = 0; i < length; i++) {
+ JS::Rooted<JS::Value> item(cx, fromArray->getDenseElement(i));
+ JS::Rooted<TargetT*> req(cx, &item.toObject().as<TargetT>());
+ JS::Rooted<T*> filtered(cx, T::create(cx, req));
+ if (!filtered) {
+ return false;
+ }
+ toArray->initDenseElement(i, ObjectValue(*filtered));
+ }
+ to.setObject(*toArray);
+ return true;
+}
+
+template <class T>
+bool ListToArrayFilter(JSContext* cx, JS::Handle<JS::Value> from,
+ JS::MutableHandle<JS::Value> to) {
+ using TargetT = typename T::Target;
+
+ if (!from.isObject() || !from.toObject().is<ListObject>()) {
+ to.set(from);
+ return true;
+ }
+
+ JS::Rooted<ListObject*> fromList(cx, &from.toObject().as<ListObject>());
+ uint32_t length = fromList->length();
+ JS::Rooted<ArrayObject*> toArray(cx, NewDenseFullyAllocatedArray(cx, length));
+ if (!toArray) {
+ return false;
+ }
+
+ toArray->ensureDenseInitializedLength(0, length);
+
+ for (uint32_t i = 0; i < length; i++) {
+ JS::Rooted<JS::Value> item(cx, fromList->get(i));
+ JS::Rooted<TargetT*> req(cx, &item.toObject().as<TargetT>());
+ JS::Rooted<T*> filtered(cx, T::create(cx, req));
+ if (!filtered) {
+ return false;
+ }
+ toArray->initDenseElement(i, ObjectValue(*filtered));
+ }
+ to.setObject(*toArray);
+ return true;
+}
+
+static Value StringOrNullValue(JSString* maybeString) {
+ if (!maybeString) {
+ return NullValue();
+ }
+
+ return StringValue(maybeString);
+}
+
+static Value Uint32Value(uint32_t x) {
+ MOZ_ASSERT(x <= INT32_MAX);
+ return Int32Value(x);
+}
+
+static Value Uint32OrUndefinedValue(mozilla::Maybe<uint32_t> x) {
+ if (x.isNothing()) {
+ return UndefinedValue();
+ }
+
+ return Uint32Value(x.value());
+}
+
+static Value ColumnNumberOneOriginValue(JS::ColumnNumberOneOrigin x) {
+ uint32_t column = x.oneOriginValue();
+ MOZ_ASSERT(column <= INT32_MAX);
+ return Int32Value(column);
+}
+
+static Value StatusValue(ModuleStatus status) {
+ return Int32Value(int32_t(status));
+}
+
+static Value ObjectOrUndefinedValue(JSObject* object) {
+ if (!object) {
+ return UndefinedValue();
+ }
+
+ return ObjectValue(*object);
+}
+
+template <class T, typename RawGetterT, typename FilterT>
+bool ShellModuleWrapperGetter(JSContext* cx, const JS::CallArgs& args,
+ RawGetterT rawGetter, FilterT filter) {
+ JS::Rooted<T*> wrapper(cx, &args.thisv().toObject().as<T>());
+ JS::Rooted<JS::Value> raw(cx, rawGetter(wrapper->get()));
+
+ JS::Rooted<JS::Value> filtered(cx);
+ if (!filter(cx, raw, &filtered)) {
+ return false;
+ }
+
+ args.rval().set(filtered);
+ return true;
+}
+
+#define DEFINE_GETTER_FUNCTIONS(CLASS, PROP, TO_VALUE, FILTER) \
+ static Value Shell##CLASS##Wrapper_##PROP##Getter_raw(CLASS* obj) { \
+ return TO_VALUE(obj->PROP()); \
+ } \
+ static bool Shell##CLASS##Wrapper_##PROP##Getter_impl( \
+ JSContext* cx, const JS::CallArgs& args) { \
+ return ShellModuleWrapperGetter<Shell##CLASS##Wrapper>( \
+ cx, args, Shell##CLASS##Wrapper_##PROP##Getter_raw, FILTER); \
+ } \
+ static bool Shell##CLASS##Wrapper_##PROP##Getter(JSContext* cx, \
+ unsigned argc, Value* vp) { \
+ JS::CallArgs args = JS::CallArgsFromVp(argc, vp); \
+ return CallNonGenericMethod<IsShell##CLASS##Wrapper, \
+ Shell##CLASS##Wrapper_##PROP##Getter_impl>( \
+ cx, args); \
+ }
+
+template <class T>
+bool SpanToArrayFilter(JSContext* cx, JS::Handle<JSObject*> owner,
+ Span<const typename T::Target> from,
+ JS::MutableHandle<JS::Value> to) {
+ size_t length = from.Length();
+ JS::Rooted<ArrayObject*> toArray(cx, NewDenseFullyAllocatedArray(cx, length));
+ if (!toArray) {
+ return false;
+ }
+
+ toArray->ensureDenseInitializedLength(0, length);
+
+ for (uint32_t i = 0; i < length; i++) {
+ auto* element = const_cast<typename T::Target*>(&from[i]);
+ JS::Rooted<T*> filtered(cx, T::create(cx, owner, element));
+ if (!filtered) {
+ return false;
+ }
+ toArray->initDenseElement(i, ObjectValue(*filtered));
+ }
+
+ to.setObject(*toArray);
+ return true;
+}
+
+template <class T, typename RawGetterT, typename FilterT>
+bool ShellModuleNativeWrapperGetter(JSContext* cx, const JS::CallArgs& args,
+ RawGetterT rawGetter, FilterT filter) {
+ JS::Rooted<T*> wrapper(cx, &args.thisv().toObject().as<T>());
+ JS::Rooted<typename T::Target*> owner(cx, wrapper->get());
+
+ JS::Rooted<JS::Value> filtered(cx);
+ if (!filter(cx, owner, rawGetter(owner), &filtered)) {
+ return false;
+ }
+
+ args.rval().set(filtered);
+ return true;
+}
+
+#define DEFINE_NATIVE_GETTER_FUNCTIONS(CLASS, PROP, FILTER) \
+ static auto Shell##CLASS##Wrapper_##PROP##Getter_raw(CLASS* obj) { \
+ return obj->PROP(); \
+ } \
+ static bool Shell##CLASS##Wrapper_##PROP##Getter_impl( \
+ JSContext* cx, const JS::CallArgs& args) { \
+ return ShellModuleNativeWrapperGetter<Shell##CLASS##Wrapper>( \
+ cx, args, Shell##CLASS##Wrapper_##PROP##Getter_raw, FILTER); \
+ } \
+ static bool Shell##CLASS##Wrapper_##PROP##Getter(JSContext* cx, \
+ unsigned argc, Value* vp) { \
+ JS::CallArgs args = JS::CallArgsFromVp(argc, vp); \
+ return CallNonGenericMethod<IsShell##CLASS##Wrapper, \
+ Shell##CLASS##Wrapper_##PROP##Getter_impl>( \
+ cx, args); \
+ }
+
+DEFINE_GETTER_FUNCTIONS(ModuleRequestObject, specifier, StringOrNullValue,
+ IdentFilter)
+DEFINE_GETTER_FUNCTIONS(ModuleRequestObject, assertions, ObjectOrNullValue,
+ IdentFilter)
+
+static const JSPropertySpec ShellModuleRequestObjectWrapper_accessors[] = {
+ JS_PSG("specifier", ShellModuleRequestObjectWrapper_specifierGetter, 0),
+ JS_PSG("assertions", ShellModuleRequestObjectWrapper_assertionsGetter, 0),
+ JS_PS_END};
+
+DEFINE_GETTER_FUNCTIONS(ImportEntry, moduleRequest, ObjectOrNullValue,
+ SingleFilter<ShellModuleRequestObjectWrapper>)
+DEFINE_GETTER_FUNCTIONS(ImportEntry, importName, StringOrNullValue, IdentFilter)
+DEFINE_GETTER_FUNCTIONS(ImportEntry, localName, StringValue, IdentFilter)
+DEFINE_GETTER_FUNCTIONS(ImportEntry, lineNumber, Uint32Value, IdentFilter)
+DEFINE_GETTER_FUNCTIONS(ImportEntry, columnNumber, ColumnNumberOneOriginValue,
+ IdentFilter)
+
+static const JSPropertySpec ShellImportEntryWrapper_accessors[] = {
+ JS_PSG("moduleRequest", ShellImportEntryWrapper_moduleRequestGetter, 0),
+ JS_PSG("importName", ShellImportEntryWrapper_importNameGetter, 0),
+ JS_PSG("localName", ShellImportEntryWrapper_localNameGetter, 0),
+ JS_PSG("lineNumber", ShellImportEntryWrapper_lineNumberGetter, 0),
+ JS_PSG("columnNumber", ShellImportEntryWrapper_columnNumberGetter, 0),
+ JS_PS_END};
+
+DEFINE_GETTER_FUNCTIONS(ExportEntry, exportName, StringOrNullValue, IdentFilter)
+DEFINE_GETTER_FUNCTIONS(ExportEntry, moduleRequest, ObjectOrNullValue,
+ SingleFilter<ShellModuleRequestObjectWrapper>)
+DEFINE_GETTER_FUNCTIONS(ExportEntry, importName, StringOrNullValue, IdentFilter)
+DEFINE_GETTER_FUNCTIONS(ExportEntry, localName, StringOrNullValue, IdentFilter)
+DEFINE_GETTER_FUNCTIONS(ExportEntry, lineNumber, Uint32Value, IdentFilter)
+DEFINE_GETTER_FUNCTIONS(ExportEntry, columnNumber, ColumnNumberOneOriginValue,
+ IdentFilter)
+
+static const JSPropertySpec ShellExportEntryWrapper_accessors[] = {
+ JS_PSG("exportName", ShellExportEntryWrapper_exportNameGetter, 0),
+ JS_PSG("moduleRequest", ShellExportEntryWrapper_moduleRequestGetter, 0),
+ JS_PSG("importName", ShellExportEntryWrapper_importNameGetter, 0),
+ JS_PSG("localName", ShellExportEntryWrapper_localNameGetter, 0),
+ JS_PSG("lineNumber", ShellExportEntryWrapper_lineNumberGetter, 0),
+ JS_PSG("columnNumber", ShellExportEntryWrapper_columnNumberGetter, 0),
+ JS_PS_END};
+
+DEFINE_GETTER_FUNCTIONS(RequestedModule, moduleRequest, ObjectOrNullValue,
+ SingleFilter<ShellModuleRequestObjectWrapper>)
+DEFINE_GETTER_FUNCTIONS(RequestedModule, lineNumber, Uint32Value, IdentFilter)
+DEFINE_GETTER_FUNCTIONS(RequestedModule, columnNumber,
+ ColumnNumberOneOriginValue, IdentFilter)
+
+static const JSPropertySpec ShellRequestedModuleWrapper_accessors[] = {
+ JS_PSG("moduleRequest", ShellRequestedModuleWrapper_moduleRequestGetter, 0),
+ JS_PSG("lineNumber", ShellRequestedModuleWrapper_lineNumberGetter, 0),
+ JS_PSG("columnNumber", ShellRequestedModuleWrapper_columnNumberGetter, 0),
+ JS_PS_END};
+
+DEFINE_GETTER_FUNCTIONS(ModuleObject, namespace_, ObjectOrNullValue,
+ IdentFilter)
+DEFINE_GETTER_FUNCTIONS(ModuleObject, status, StatusValue, IdentFilter)
+DEFINE_GETTER_FUNCTIONS(ModuleObject, maybeEvaluationError, Value, IdentFilter)
+DEFINE_NATIVE_GETTER_FUNCTIONS(ModuleObject, requestedModules,
+ SpanToArrayFilter<ShellRequestedModuleWrapper>)
+DEFINE_NATIVE_GETTER_FUNCTIONS(ModuleObject, importEntries,
+ SpanToArrayFilter<ShellImportEntryWrapper>)
+DEFINE_NATIVE_GETTER_FUNCTIONS(ModuleObject, localExportEntries,
+ SpanToArrayFilter<ShellExportEntryWrapper>)
+DEFINE_NATIVE_GETTER_FUNCTIONS(ModuleObject, indirectExportEntries,
+ SpanToArrayFilter<ShellExportEntryWrapper>)
+DEFINE_NATIVE_GETTER_FUNCTIONS(ModuleObject, starExportEntries,
+ SpanToArrayFilter<ShellExportEntryWrapper>)
+DEFINE_GETTER_FUNCTIONS(ModuleObject, maybeDfsIndex, Uint32OrUndefinedValue,
+ IdentFilter)
+DEFINE_GETTER_FUNCTIONS(ModuleObject, maybeDfsAncestorIndex,
+ Uint32OrUndefinedValue, IdentFilter)
+DEFINE_GETTER_FUNCTIONS(ModuleObject, hasTopLevelAwait, BooleanValue,
+ IdentFilter)
+DEFINE_GETTER_FUNCTIONS(ModuleObject, maybeTopLevelCapability,
+ ObjectOrUndefinedValue, IdentFilter)
+DEFINE_GETTER_FUNCTIONS(ModuleObject, isAsyncEvaluating, BooleanValue,
+ IdentFilter)
+DEFINE_GETTER_FUNCTIONS(ModuleObject, maybeAsyncEvaluatingPostOrder,
+ Uint32OrUndefinedValue, IdentFilter)
+DEFINE_GETTER_FUNCTIONS(ModuleObject, asyncParentModules, ObjectOrNullValue,
+ ListToArrayFilter<ShellModuleObjectWrapper>)
+DEFINE_GETTER_FUNCTIONS(ModuleObject, maybePendingAsyncDependencies,
+ Uint32OrUndefinedValue, IdentFilter)
+
+static const JSPropertySpec ShellModuleObjectWrapper_accessors[] = {
+ JS_PSG("namespace", ShellModuleObjectWrapper_namespace_Getter, 0),
+ JS_PSG("status", ShellModuleObjectWrapper_statusGetter, 0),
+ JS_PSG("evaluationError",
+ ShellModuleObjectWrapper_maybeEvaluationErrorGetter, 0),
+ JS_PSG("requestedModules", ShellModuleObjectWrapper_requestedModulesGetter,
+ 0),
+ JS_PSG("importEntries", ShellModuleObjectWrapper_importEntriesGetter, 0),
+ JS_PSG("localExportEntries",
+ ShellModuleObjectWrapper_localExportEntriesGetter, 0),
+ JS_PSG("indirectExportEntries",
+ ShellModuleObjectWrapper_indirectExportEntriesGetter, 0),
+ JS_PSG("starExportEntries",
+ ShellModuleObjectWrapper_starExportEntriesGetter, 0),
+ JS_PSG("dfsIndex", ShellModuleObjectWrapper_maybeDfsIndexGetter, 0),
+ JS_PSG("dfsAncestorIndex",
+ ShellModuleObjectWrapper_maybeDfsAncestorIndexGetter, 0),
+ JS_PSG("hasTopLevelAwait", ShellModuleObjectWrapper_hasTopLevelAwaitGetter,
+ 0),
+ JS_PSG("topLevelCapability",
+ ShellModuleObjectWrapper_maybeTopLevelCapabilityGetter, 0),
+ JS_PSG("isAsyncEvaluating",
+ ShellModuleObjectWrapper_isAsyncEvaluatingGetter, 0),
+ JS_PSG("asyncEvaluatingPostOrder",
+ ShellModuleObjectWrapper_maybeAsyncEvaluatingPostOrderGetter, 0),
+ JS_PSG("asyncParentModules",
+ ShellModuleObjectWrapper_asyncParentModulesGetter, 0),
+ JS_PSG("pendingAsyncDependencies",
+ ShellModuleObjectWrapper_maybePendingAsyncDependenciesGetter, 0),
+ JS_PS_END};
+
+#undef DEFINE_GETTER_FUNCTIONS
+#undef DEFINE_NATIVE_GETTER_FUNCTIONS
+
+#define DEFINE_CREATE(CLASS, ACCESSORS, FUNCTIONS) \
+ /* static */ \
+ Shell##CLASS##Wrapper* Shell##CLASS##Wrapper::create( \
+ JSContext* cx, JS::Handle<CLASS*> target) { \
+ JS::Rooted<JSObject*> obj(cx, JS_NewObject(cx, &class_)); \
+ if (!obj) { \
+ return nullptr; \
+ } \
+ if (!DefinePropertiesAndFunctions(cx, obj, ACCESSORS, FUNCTIONS)) { \
+ return nullptr; \
+ } \
+ auto* wrapper = &obj->as<Shell##CLASS##Wrapper>(); \
+ wrapper->initReservedSlot(TargetSlot, ObjectValue(*target)); \
+ return wrapper; \
+ }
+
+#define DEFINE_NATIVE_CREATE(CLASS, ACCESSORS, FUNCTIONS) \
+ /* static */ \
+ Shell##CLASS##Wrapper* Shell##CLASS##Wrapper::create( \
+ JSContext* cx, JS::Handle<JSObject*> owner, CLASS* target) { \
+ JS::Rooted<JSObject*> obj(cx, JS_NewObject(cx, &class_)); \
+ if (!obj) { \
+ return nullptr; \
+ } \
+ if (!DefinePropertiesAndFunctions(cx, obj, ACCESSORS, FUNCTIONS)) { \
+ return nullptr; \
+ } \
+ auto* wrapper = &obj->as<Shell##CLASS##Wrapper>(); \
+ wrapper->initReservedSlot(OwnerSlot, ObjectValue(*owner)); \
+ wrapper->initReservedSlot(TargetSlot, PrivateValue(target)); \
+ return wrapper; \
+ }
+
+DEFINE_CREATE(ModuleRequestObject, ShellModuleRequestObjectWrapper_accessors,
+ nullptr)
+DEFINE_NATIVE_CREATE(ImportEntry, ShellImportEntryWrapper_accessors, nullptr)
+DEFINE_NATIVE_CREATE(ExportEntry, ShellExportEntryWrapper_accessors, nullptr)
+DEFINE_NATIVE_CREATE(RequestedModule, ShellRequestedModuleWrapper_accessors,
+ nullptr)
+DEFINE_CREATE(ModuleObject, ShellModuleObjectWrapper_accessors, nullptr)
+
+#undef DEFINE_CREATE
+#undef DEFINE_NATIVE_CREATE