src: move import.meta initializer to native land

When the source text module is compiled without custom callbacks,
instead of calling into JS land from the per-isolate import.meta
initializer and then back to C++ land to set up lazy data
properties, just do the initialization all in C++ land.
Only import.meta.resolve initialization will call back
into JS land to generate a closure that call the cascaded loader
for resolution.

In addition, simplify the loader structure by merging
allowImportMetaResolve into isForAsyncLoaderHookWorker - the two
are essentially equivalent, as import.meta.resolve is only
allowed in a non-loader-hook worker thread's loader.

PR-URL: #60603
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Geoffrey Booth <webadmin@geoffreybooth.com>

Author: joyeecheung

lib/internal/modules/esm/hooks.js

@@ -58,7 +58,6 @@ const {
 let debug = require('internal/util/debuglog').debuglog('async_loader_worker', (fn) => {
   debug = fn;
 });
-let importMetaInitializer;
 
 let importAssertionAlreadyWarned = false;
 
@@ -111,7 +110,6 @@ function defineImportAssertionAlias(context) {
  * Interface for classes that implement asynchronous loader hooks that can be attached to the ModuleLoader
  * via `ModuleLoader.#setAsyncLoaderHooks()`.
  * @typedef {object} AsyncLoaderHooks
- * @property {boolean} allowImportMetaResolve Whether to allow the use of `import.meta.resolve`.
  * @property {boolean} isForAsyncLoaderHookWorker Whether the instance is running on the loader hook worker thread.
  * @property {(url: string, context: object, defaultLoad: Function) => Promise<LoadResult>} load
  *   Calling the asynchronous `load` hook asynchronously.
@@ -163,8 +161,6 @@ class AsyncLoaderHooksOnLoaderHookWorker {
   // Cache URLs we've already validated to avoid repeated validation
   #validatedUrls = new SafeSet();
 
-  allowImportMetaResolve = false;
-
   isForAsyncLoaderHookWorker = true;
 
   /**
@@ -480,12 +476,6 @@ class AsyncLoaderHooksOnLoaderHookWorker {
   waitForLoaderHookInitialization() {
     // No-op
   }
-
-  importMetaInitialize(meta, context, loader) {
-    importMetaInitializer ??= require('internal/modules/esm/initialize_import_meta').initializeImportMeta;
-    meta = importMetaInitializer(meta, context, loader);
-    return meta;
-  }
 }
 ObjectSetPrototypeOf(AsyncLoaderHooksOnLoaderHookWorker.prototype, null);
 
@@ -674,12 +664,6 @@ class AsyncLoaderHookWorker {
       return body;
     }
   }
-
-  #importMetaInitializer = require('internal/modules/esm/initialize_import_meta').initializeImportMeta;
-
-  importMetaInitialize(meta, context, loader) {
-    this.#importMetaInitializer(meta, context, loader);
-  }
 }
 ObjectSetPrototypeOf(AsyncLoaderHookWorker.prototype, null);
 
@@ -817,8 +801,6 @@ function getAsyncLoaderHookWorker() {
  */
 class AsyncLoaderHooksProxiedToLoaderHookWorker {
 
-  allowImportMetaResolve = true;
-
   isForAsyncLoaderHookWorker = false;
 
   /**
@@ -876,10 +858,6 @@ class AsyncLoaderHooksProxiedToLoaderHookWorker {
     return asyncLoaderHookWorker.makeSyncRequest('load', undefined, url, context);
   }
 
-  importMetaInitialize(meta, context, loader) {
-    asyncLoaderHookWorker.importMetaInitialize(meta, context, loader);
-  }
-
   waitForLoaderHookInitialization() {
     asyncLoaderHookWorker.waitForWorker();
   }

lib/internal/modules/esm/initialize_import_meta.js

@@ -51,6 +51,7 @@ const {
   kErrored,
   kSourcePhase,
   throwIfPromiseRejected,
+  setImportMetaResolveInitializer,
 } = internalBinding('module_wrap');
 const {
   urlToFilename,
@@ -62,7 +63,8 @@ const {
   loadWithHooks: loadWithSyncHooks,
   validateLoadSloppy,
 } = require('internal/modules/customization_hooks');
-let defaultResolve, defaultLoadSync, importMetaInitializer;
+
+let defaultResolve, defaultLoadSync;
 
 const { tracingChannel } = require('diagnostics_channel');
 const onImport = tracingChannel('module.import');
@@ -183,13 +185,6 @@ class ModuleLoader {
    */
   translators = getTranslators();
 
-  /**
-   * Truthy to allow the use of `import.meta.resolve`. This is needed
-   * currently because the `Hooks` class does not have `resolveSync`
-   * implemented and `import.meta.resolve` requires it.
-   */
-  allowImportMetaResolve;
-
   /**
    * @see {AsyncLoaderHooks.isForAsyncLoaderHookWorker}
    * Shortcut to this.#asyncLoaderHooks.isForAsyncLoaderHookWorker.
@@ -200,9 +195,10 @@ class ModuleLoader {
    * Asynchronous loader hooks to pass requests to.
    *
    * Note that this value _MUST_ be set with `#setAsyncLoaderHooks`
-   * because it needs to copy `#asyncLoaderHooks.allowImportMetaResolve`
-   *  to this property and failure to do so will cause undefined
-   * behavior when invoking `import.meta.resolve`.
+   * because it needs to copy `#asyncLoaderHooks.isForAsyncLoaderHookWorker`
+   * to this property.
+   * TODO(joyeecheung): this was a legacy of the previous setup of import.meta.resolve
+   * configuration; put this information in the environment directly instead.
    *
    * When the ModuleLoader is created on a loader hook thread, this is
    * {@link AsyncLoaderHooksOnLoaderHookWorker}, and its methods directly call out
@@ -234,10 +230,8 @@ class ModuleLoader {
   #setAsyncLoaderHooks(asyncLoaderHooks) {
     this.#asyncLoaderHooks = asyncLoaderHooks;
     if (asyncLoaderHooks) {
-      this.allowImportMetaResolve = asyncLoaderHooks.allowImportMetaResolve;
       this.isForAsyncLoaderHookWorker = asyncLoaderHooks.isForAsyncLoaderHookWorker;
     } else {
-      this.allowImportMetaResolve = true;
       this.isForAsyncLoaderHookWorker = false;
     }
   }
@@ -821,15 +815,6 @@ class ModuleLoader {
     }
   }
 
-  importMetaInitialize(meta, context) {
-    if (this.#asyncLoaderHooks) {
-      return this.#asyncLoaderHooks.importMetaInitialize(meta, context, this);
-    }
-    importMetaInitializer ??= require('internal/modules/esm/initialize_import_meta').initializeImportMeta;
-    meta = importMetaInitializer(meta, context, this);
-    return meta;
-  }
-
   /**
    * Block until the async loader hooks have been initialized.
    *
@@ -883,8 +868,47 @@ function createModuleLoader(asyncLoaderHooks) {
   return new ModuleLoader(asyncLoaderHooks);
 }
 
-let cascadedLoader;
+let allowImportMetaResolveParentURL;
+/**
+ * This is only called from the native ImportMetaObjectInitialize function to set up import.meta.resolve
+ * when import.meta.resolve is accessed for the first time in a module.
+ * @param {ModuleLoader} loader The cascaded loader to use. Bound when this function gets passed to native land.
+ * @param {string} moduleURL URL of the module accessing import.meta
+ * @returns {function(string, URL['href']=): string} The import.meta.resolve function
+ */
+function createImportMetaResolve(loader, moduleURL) {
+  /**
+   * @param {string} specifier The module specifier to resolve.
+   * @param {URL['href']} [parentURL] Optional parent URL to resolve against. Ignored unless
+   *   `--experimental-import-meta-resolve` is enabled.
+   * @returns {string}
+   */
+  return function resolve(specifier, parentURL) {
+    // The second argument is ignored unless --experimental-import-meta-resolve is enabled.
+    // Even then, if it's not provided, parentURL defaults to the url of the module accessing
+    // import.meta.resolve.
+    allowImportMetaResolveParentURL ??= getOptionValue('--experimental-import-meta-resolve');
+    parentURL = allowImportMetaResolveParentURL ? (parentURL ?? moduleURL) : moduleURL;
+
+    let url;
+    try {
+      ({ url } = loader.resolveSync(parentURL, { specifier, __proto__: null }));
+      return url;
+    } catch (error) {
+      switch (error?.code) {
+        case 'ERR_UNSUPPORTED_DIR_IMPORT':
+        case 'ERR_MODULE_NOT_FOUND':
+          ({ url } = error);
+          if (url) {
+            return url;
+          }
+      }
+      throw error;
+    }
+  };
+}
 
+let cascadedLoader;
 /**
  * This is a singleton ESM loader that integrates the loader hooks, if any.
  * It it used by other internal built-ins when they need to load user-land ESM code
@@ -898,7 +922,16 @@ let cascadedLoader;
  * @returns {ModuleLoader}
  */
 function getOrInitializeCascadedLoader(asyncLoaderHooks) {
-  cascadedLoader ??= createModuleLoader(asyncLoaderHooks);
+  if (!cascadedLoader) {
+    cascadedLoader = createModuleLoader(asyncLoaderHooks);
+    // import.meta.resolve is not allowed in the async loader hook worker thread.
+    // So only set up the import.meta.resolve initializer when we are initializing
+    // the non-loader-hook-thread cascaded loader. When the native land doesn't see it,
+    // it knows the loader is running on the loader hook thread.
+    if (!(asyncLoaderHooks?.isForAsyncLoaderHookWorker)) {
+      setImportMetaResolveInitializer(createImportMetaResolve.bind(null, cascadedLoader));
+    }
+  }
   return cascadedLoader;
 }
 

lib/internal/modules/esm/loader.js

@@ -183,27 +183,14 @@ function registerModule(referrer, registry) {
 }
 
 /**
- * Proxy the import meta handling to the default loader for source text modules.
- * @param {Record<string, string | Function>} meta - The import.meta object to initialize.
- * @param {ModuleWrap} wrap - The ModuleWrap of the SourceTextModule where `import.meta` is referenced.
- * @returns {object}
- */
-function defaultInitializeImportMetaForModule(meta, wrap) {
-  const cascadedLoader = require('internal/modules/esm/loader').getOrInitializeCascadedLoader();
-  return cascadedLoader.importMetaInitialize(meta, { url: wrap.url, isMain: wrap.isMain });
-}
-
-/**
- * Defines the `import.meta` object for a given module.
+ * Initializes the `import.meta` object for a given module. This is only called when the module
+ * is compiled with custom callbacks. Ordinary user-land source text modules are
+ * initialized by the native DefaultImportMetaObjectInitializer directly.
  * @param {symbol} symbol - Reference to the module.
  * @param {Record<string, string | Function>} meta - The import.meta object to initialize.
  * @param {ModuleWrap} wrap - The ModuleWrap of the SourceTextModule where `import.meta` is referenced.
  */
 function initializeImportMetaObject(symbol, meta, wrap) {
-  if (symbol === source_text_module_default_hdo) {
-    defaultInitializeImportMetaForModule(meta, wrap);
-    return;
-  }
   const data = moduleRegistries.get(symbol);
   assert(data, `import.meta registry not found for ${wrap.url}`);
   const { initializeImportMeta, callbackReferrer } = data;

lib/internal/modules/esm/utils.js

@@ -350,7 +350,7 @@ function findPackageJSON(specifier, base = 'data:') {
 
   try {
     // TODO(@JakobJingleheimer): Detect whether findPackageJSON is being used within a loader
-    // (possibly piggyback on `allowImportMetaResolve`)
+    // (possibly piggyback on `isForAsyncLoaderHookWorker` from the loader?) and if so:
     // - When inside, use the default resolve
     //   - (I think it's impossible to use the chain because of re-entry & a deadlock from atomics).
     // - When outside, use cascadedLoader.resolveSync (not implemented yet, but the pieces exist).

lib/internal/modules/package_json_reader.js

@@ -470,6 +470,7 @@
   V(enhance_fatal_stack_before_inspector, v8::Function)                        \
   V(get_source_map_error_source, v8::Function)                                 \
   V(host_import_module_dynamically_callback, v8::Function)                     \
+  V(host_import_meta_resolve_initializer, v8::Function)                        \
   V(host_initialize_import_meta_object_callback, v8::Function)                 \
   V(http2session_on_altsvc_function, v8::Function)                             \
   V(http2session_on_error_function, v8::Function)                              \