feat(core): Add support for modules in realms

This change makes realms other than the main one support modules by
having a module map associated to each realm, rather than one per
module. As part of this, it also:

- Adds an argument to `JsRuntime::create_realm` to set the realm's
  module loader. This allows different realms to have different module
  loading strategies (different import maps, for example).

- Moves all of the methods of `JsRuntime` related to module loading
  into `JsRealm`. To minimize changing unrelated code, the public and
  crate-private methods in `JsRuntime` are kept, with their
  implementation replaced by a call to the corresponding method of the
  main realm's `JsRealm`.

- Removes the `module_map` argument to the `EventLoopPendingState`
  constructor, instead accessing each realm's corresponding module map
  as part of the existing iteration.

- Changes the parts of `JsRuntime::poll_event_loop` that deal with
  module evaluation and detecting stalled top-level awaits to support
  multiple module maps and multiple top-level module evaluations at
  the same time.

- Moves `pending_mod_evaluate` and `pending_dyn_mod_evaluate` from
  `JsRuntimeState` to `ContextState`.

Towards #13239.

Author: andreubotella

core/bindings.rs

@@ -289,7 +289,7 @@ pub fn host_import_module_dynamically_callback<'s>(
     let resolver_handle = v8::Global::new(scope, resolver);
     {
       let state_rc = JsRuntime::state(scope);
-      let module_map_rc = JsRuntime::module_map(scope);
+      let module_map_rc = JsRealm::module_map_from_scope(scope);
 
       debug!(
         "dyn_import specifier {} referrer {} ",
@@ -336,7 +336,7 @@ pub extern "C" fn host_initialize_import_meta_object_callback(
 ) {
   // SAFETY: `CallbackScope` can be safely constructed from `Local<Context>`
   let scope = &mut unsafe { v8::CallbackScope::new(context) };
-  let module_map_rc = JsRuntime::module_map(scope);
+  let module_map_rc = JsRealm::module_map_from_scope(scope);
   let module_map = module_map_rc.borrow();
 
   let module_global = v8::Global::new(scope, module);
@@ -379,7 +379,7 @@ fn import_meta_resolve(
     let url_prop = args.data();
     url_prop.to_rust_string_lossy(scope)
   };
-  let module_map_rc = JsRuntime::module_map(scope);
+  let module_map_rc = JsRealm::module_map_from_scope(scope);
   let (loader, snapshot_loaded_and_not_snapshotting) = {
     let module_map = module_map_rc.borrow();
     (
@@ -510,7 +510,7 @@ pub extern "C" fn promise_reject_callback(message: v8::PromiseRejectMessage) {
       };
 
     if has_unhandled_rejection_handler {
-      let state_rc = JsRuntime::state(tc_scope);
+      let state_rc = JsRealm::state_from_scope(tc_scope);
       let mut state = state_rc.borrow_mut();
       if let Some(pending_mod_evaluate) = state.pending_mod_evaluate.as_mut() {
         if !pending_mod_evaluate.has_evaluated {
@@ -608,7 +608,7 @@ pub fn module_resolve_callback<'s>(
   // SAFETY: `CallbackScope` can be safely constructed from `Local<Context>`
   let scope = &mut unsafe { v8::CallbackScope::new(context) };
 
-  let module_map_rc = JsRuntime::module_map(scope);
+  let module_map_rc = JsRealm::module_map_from_scope(scope);
   let module_map = module_map_rc.borrow();
 
   let referrer_global = v8::Global::new(scope, referrer);

core/modules.rs

@@ -9,7 +9,7 @@ use crate::module_specifier::ModuleSpecifier;
 use crate::resolve_import;
 use crate::resolve_url;
 use crate::snapshot_util::SnapshottedData;
-use crate::JsRuntime;
+use crate::JsRealm;
 use crate::OpState;
 use anyhow::Error;
 use core::panic;
@@ -135,7 +135,7 @@ fn json_module_evaluation_steps<'a>(
   // SAFETY: `CallbackScope` can be safely constructed from `Local<Context>`
   let scope = &mut unsafe { v8::CallbackScope::new(context) };
   let tc_scope = &mut v8::TryCatch::new(scope);
-  let module_map = JsRuntime::module_map(tc_scope);
+  let module_map = JsRealm::module_map_from_scope(tc_scope);
 
   let handle = v8::Global::<v8::Module>::new(tc_scope, module);
   let value_handle = module_map