src: port defineLazyProperties to native code

lib/internal/bootstrap/web/exposed-wildcard.js

@@ -12,12 +12,11 @@ const {
 
 const {
  exposeInterface,
- lazyDOMExceptionClass,
  exposeLazyInterfaces,
- exposeGetterAndSetter,
  exposeNamespace,
 } = require('internal/util');
 const config = internalBinding('config');
+const { exposeLazyDOMExceptionProperty } = internalBinding('messaging');
 
 // https://console.spec.whatwg.org/#console-namespace
 exposeNamespace(globalThis, 'console',
@@ -28,16 +27,7 @@ const { URL, URLSearchParams } = require('internal/url');
 exposeInterface(globalThis, 'URL', URL);
 // https://url.spec.whatwg.org/#urlsearchparams
 exposeInterface(globalThis, 'URLSearchParams', URLSearchParams);
-exposeGetterAndSetter(globalThis,
- 'DOMException',
- () => {
- const DOMException = lazyDOMExceptionClass();
- exposeInterface(globalThis, 'DOMException', DOMException);
- return DOMException;
- },
- (value) => {
- exposeInterface(globalThis, 'DOMException', value);
- });
+exposeLazyDOMExceptionProperty(globalThis);
 
 // https://dom.spec.whatwg.org/#interface-abortcontroller
 // Lazy ones.

lib/internal/util.js

@@ -55,6 +55,7 @@ const {
 const { signals } = internalBinding('constants').os;
 const {
  guessHandleType: _guessHandleType,
+ defineLazyProperties,
  privateSymbols: {
  arrow_message_private_symbol,
  decorated_private_symbol,
@@ -610,46 +611,6 @@ function exposeGetterAndSetter(target, name, getter, setter = undefined) {
  });
 }
 
-function defineLazyProperties(target, id, keys, enumerable = true) {
- const descriptors = { __proto__: null };
- let mod;
- for (let i = 0; i < keys.length; i++) {
- const key = keys[i];
- let lazyLoadedValue;
- function set(value) {
- ObjectDefineProperty(target, key, {
- __proto__: null,
- writable: true,
- value,
- });
- }
- ObjectDefineProperty(set, 'name', {
- __proto__: null,
- value: `set ${key}`,
- });
- function get() {
- mod ??= require(id);
- if (lazyLoadedValue === undefined) {
- lazyLoadedValue = mod[key];
- set(lazyLoadedValue);
- }
- return lazyLoadedValue;
- }
- ObjectDefineProperty(get, 'name', {
- __proto__: null,
- value: `get ${key}`,
- });
- descriptors[key] = {
- __proto__: null,
- configurable: true,
- enumerable,
- get,
- set,
- };
- }
- ObjectDefineProperties(target, descriptors);
-}
-
 function defineReplaceableLazyAttribute(target, id, keys, writable = true, check) {
  let mod;
  for (let i = 0; i < keys.length; i++) {

src/node_messaging.cc

@@ -1645,6 +1645,36 @@ static void BroadcastChannel(const FunctionCallbackInfo<Value>& args) {
  }
 }
 
+static void ExposeLazyDOMExceptionPropertyGetter(
+ Local<v8::Name> name, const v8::PropertyCallbackInfo<Value>& info) {
+ auto context = info.GetIsolate()->GetCurrentContext();
+ Local<Function> domexception;
+ if (!GetDOMException(context).ToLocal(&domexception)) {
+ // V8 will have scheduled an error to be thrown.
+ return;
+ }
+ info.GetReturnValue().Set(domexception);
+}
+static void ExposeLazyDOMExceptionProperty(
+ const FunctionCallbackInfo<Value>& args) {
+ CHECK_GE(args.Length(), 1);
+ CHECK(args[0]->IsObject());
+
+ Isolate* isolate = args.GetIsolate();
+ auto target = args[0].As<Object>();
+
+ if (target
+ ->SetLazyDataProperty(isolate->GetCurrentContext(),
+ FIXED_ONE_BYTE_STRING(isolate, "DOMException"),
+ ExposeLazyDOMExceptionPropertyGetter,
+ Local<Value>(),
+ v8::DontEnum)
+ .IsNothing()) {
+ // V8 will have scheduled an error to be thrown.
+ return;
+ }
+}
+
 static void CreatePerIsolateProperties(IsolateData* isolate_data,
  Local<ObjectTemplate> target) {
  Isolate* isolate = isolate_data->isolate();
@@ -1669,6 +1699,10 @@ static void CreatePerIsolateProperties(IsolateData* isolate_data,
  isolate_data->message_port_constructor_string(),
  GetMessagePortConstructorTemplate(isolate_data));
 
+ SetMethod(isolate,
+ target,
+ "exposeLazyDOMExceptionProperty",
+ ExposeLazyDOMExceptionProperty);
  // These are not methods on the MessagePort prototype, because
  // the browser equivalents do not provide them.
  SetMethod(isolate, target, "stopMessagePort", MessagePort::Stop);
@@ -1714,6 +1748,8 @@ static void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
  registry->Register(MessagePort::MoveToContext);
  registry->Register(SetDeserializerCreateObjectFunction);
  registry->Register(StructuredClone);
+ registry->Register(ExposeLazyDOMExceptionProperty);
+ registry->Register(ExposeLazyDOMExceptionPropertyGetter);
 }
 
 } // anonymous namespace

src/node_util.cc

@@ -348,6 +348,69 @@ static void IsInsideNodeModules(const FunctionCallbackInfo<Value>& args) {
  args.GetReturnValue().Set(result);
 }
 
+static void DefineLazyPropertiesGetter(
+ Local<v8::Name> name, const v8::PropertyCallbackInfo<Value>& info) {
+ Realm* realm = Realm::GetCurrent(info);
+ Isolate* isolate = realm->isolate();
+ auto context = isolate->GetCurrentContext();
+ Local<Value> arg = info.Data();
+ Local<Value> require_result;
+ if (!realm->builtin_module_require()
+ ->Call(context, Null(isolate), 1, &arg)
+ .ToLocal(&require_result)) {
+ // V8 will have scheduled an error to be thrown.
+ return;
+ }
+ Local<Value> ret;
+ if (!require_result.As<v8::Object>()->Get(context, name).ToLocal(&ret)) {
+ // V8 will have scheduled an error to be thrown.
+ return;
+ }
+ info.GetReturnValue().Set(ret);
+}
+static void DefineLazyProperties(const FunctionCallbackInfo<Value>& args) {
+ // target: object, id: string, keys: string[][, enumerable = true]
+ CHECK_GE(args.Length(), 3);
+ // target: Object where to define the lazy properties.
+ CHECK(args[0]->IsObject());
+ // id: Internal module to lazy-load where the API to expose are implemented.
+ CHECK(args[1]->IsString());
+ // keys: Keys to map from `require(id)` and `target`.
+ CHECK(args[2]->IsArray());
+ // enumerable: Whether the property should be enumerable.
+ CHECK(args.Length() == 3 || args[3]->IsBoolean());
+
+ Environment* env = Environment::GetCurrent(args);
+ Isolate* isolate = env->isolate();
+ auto context = isolate->GetCurrentContext();
+
+ auto target = args[0].As<Object>();
+ Local<Value> id = args[1];
+ v8::PropertyAttribute attribute =
+ args.Length() == 3 || args[3]->IsTrue() ? v8::None : v8::DontEnum;
+
+ const Local<Array> keys = args[2].As<Array>();
+ size_t length = keys->Length();
+ for (size_t i = 0; i < length; i++) {
+ Local<Value> key;
+ if (!keys->Get(context, i).ToLocal(&key)) {
+ // V8 will have scheduled an error to be thrown.
+ return;
+ }
+ CHECK(key->IsString());
+ if (target
+ ->SetLazyDataProperty(context,
+ key.As<String>(),
+ DefineLazyPropertiesGetter,
+ id,
+ attribute)
+ .IsNothing()) {
+ // V8 will have scheduled an error to be thrown.
+ return;
+ };
+ }
+}
+
 void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
  registry->Register(GetPromiseDetails);
  registry->Register(GetProxyDetails);
@@ -364,6 +427,8 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
  registry->Register(fast_guess_handle_type_.GetTypeInfo());
  registry->Register(ParseEnv);
  registry->Register(IsInsideNodeModules);
+ registry->Register(DefineLazyProperties);
+ registry->Register(DefineLazyPropertiesGetter);
 }
 
 void Initialize(Local<Object> target,
@@ -448,6 +513,7 @@ void Initialize(Local<Object> target,
  }
 
  SetMethod(context, target, "isInsideNodeModules", IsInsideNodeModules);
+ SetMethod(context, target, "defineLazyProperties", DefineLazyProperties);
  SetMethodNoSideEffect(
  context, target, "getPromiseDetails", GetPromiseDetails);
  SetMethodNoSideEffect(context, target, "getProxyDetails", GetProxyDetails);

test/common/wpt.js

@@ -595,7 +595,6 @@ class WPTRunner {
  switch (name) {
  case 'Window': {
  this.globalThisInitScripts.push('globalThis.Window = Object.getPrototypeOf(globalThis).constructor;');
- this.loadLazyGlobals();
  break;
  }
 
@@ -609,32 +608,6 @@ class WPTRunner {
  }
  }
 
- loadLazyGlobals() {
- const lazyProperties = [
- 'DOMException',
- 'Performance', 'PerformanceEntry', 'PerformanceMark', 'PerformanceMeasure',
- 'PerformanceObserver', 'PerformanceObserverEntryList', 'PerformanceResourceTiming',
- 'Blob', 'atob', 'btoa',
- 'MessageChannel', 'MessagePort', 'MessageEvent',
- 'EventTarget', 'Event',
- 'AbortController', 'AbortSignal',
- 'performance',
- 'TransformStream', 'TransformStreamDefaultController',
- 'WritableStream', 'WritableStreamDefaultController', 'WritableStreamDefaultWriter',
- 'ReadableStream', 'ReadableStreamDefaultReader',
- 'ReadableStreamBYOBReader', 'ReadableStreamBYOBRequest',
- 'ReadableByteStreamController', 'ReadableStreamDefaultController',
- 'ByteLengthQueuingStrategy', 'CountQueuingStrategy',
- 'TextEncoder', 'TextDecoder', 'TextEncoderStream', 'TextDecoderStream',
- 'CompressionStream', 'DecompressionStream',
- ];
- if (Boolean(process.versions.openssl) && !process.env.NODE_SKIP_CRYPTO) {
- lazyProperties.push('crypto', 'Crypto', 'CryptoKey', 'SubtleCrypto');
- }
- const script = lazyProperties.map((name) => `globalThis.${name};`).join('\n');
- this.globalThisInitScripts.push(script);
- }
-
  // TODO(joyeecheung): work with the upstream to port more tests in .html
  // to .js.
  async runJsTests() {

test/wpt/test-domexception.js

@@ -4,6 +4,4 @@ const { WPTRunner } = require('../common/wpt');
 
 const runner = new WPTRunner('webidl/ecmascript-binding/es-exceptions');
 
-runner.loadLazyGlobals();
-
 runner.runJsTests();