feat: include if synchronous load in ModuleLoader (#1219)

Part of the fix for denoland/deno#26136 --
this will allow us to tell we're doing a sync import and then to use a
different executor for deno_graph that doesn't spawn the future in the
tokio runtime.

Author: dsherret

core/examples/ts_module_loader.rs

@@ -14,14 +14,14 @@ use deno_ast::MediaType;
 use deno_ast::ParseParams;
 use deno_ast::SourceMapOption;
 use deno_core::JsRuntime;
+use deno_core::ModuleLoadOptions;
 use deno_core::ModuleLoadReferrer;
 use deno_core::ModuleLoadResponse;
 use deno_core::ModuleLoader;
 use deno_core::ModuleSource;
 use deno_core::ModuleSourceCode;
 use deno_core::ModuleSpecifier;
 use deno_core::ModuleType;
-use deno_core::RequestedModuleType;
 use deno_core::ResolutionKind;
 use deno_core::RuntimeOptions;
 use deno_core::error::ModuleLoaderError;
@@ -52,8 +52,7 @@ impl ModuleLoader for TypescriptModuleLoader {
     &self,
     module_specifier: &ModuleSpecifier,
     _maybe_referrer: Option<&ModuleLoadReferrer>,
-    _is_dyn_import: bool,
-    _requested_module_type: RequestedModuleType,
+    _options: ModuleLoadOptions,
   ) -> ModuleLoadResponse {
     let source_maps = self.source_maps.clone();
     fn load(

core/lib.rs

@@ -113,6 +113,7 @@ pub use crate::modules::FsModuleLoader;
 pub use crate::modules::ModuleCodeBytes;
 pub use crate::modules::ModuleCodeString;
 pub use crate::modules::ModuleId;
+pub use crate::modules::ModuleLoadOptions;
 pub use crate::modules::ModuleLoadReferrer;
 pub use crate::modules::ModuleLoadResponse;
 pub use crate::modules::ModuleLoader;

core/modules/loaders.rs

@@ -39,6 +39,13 @@ pub enum ModuleLoadResponse {
   Async(Pin<Box<ModuleSourceFuture>>),
 }
 
+pub struct ModuleLoadOptions {
+  pub is_dynamic_import: bool,
+  /// If this is a synchronous ES module load.
+  pub is_synchronous: bool,
+  pub requested_module_type: RequestedModuleType,
+}
+
 #[derive(Debug, Clone)]
 pub struct ModuleLoadReferrer {
   pub specifier: ModuleSpecifier,
@@ -83,8 +90,7 @@ pub trait ModuleLoader {
     &self,
     module_specifier: &ModuleSpecifier,
     maybe_referrer: Option<&ModuleLoadReferrer>,
-    is_dyn_import: bool,
-    requested_module_type: RequestedModuleType,
+    options: ModuleLoadOptions,
   ) -> ModuleLoadResponse;
 
   /// This hook can be used by implementors to do some preparation
@@ -99,8 +105,7 @@ pub trait ModuleLoader {
     &self,
     _module_specifier: &ModuleSpecifier,
     _maybe_referrer: Option<String>,
-    _is_dyn_import: bool,
-    _requested_module_type: RequestedModuleType,
+    _options: ModuleLoadOptions,
   ) -> Pin<Box<dyn Future<Output = Result<(), ModuleLoaderError>>>> {
     async { Ok(()) }.boxed_local()
   }
@@ -181,8 +186,7 @@ impl ModuleLoader for NoopModuleLoader {
     &self,
     _module_specifier: &ModuleSpecifier,
     _maybe_referrer: Option<&ModuleLoadReferrer>,
-    _is_dyn_import: bool,
-    _requested_module_type: RequestedModuleType,
+    _options: ModuleLoadOptions,
   ) -> ModuleLoadResponse {
     ModuleLoadResponse::Sync(Err(JsErrorBox::generic(
       "Module loading is not supported.",
@@ -280,8 +284,7 @@ impl ModuleLoader for ExtModuleLoader {
     &self,
     specifier: &ModuleSpecifier,
     _maybe_referrer: Option<&ModuleLoadReferrer>,
-    _is_dyn_import: bool,
-    _requested_module_type: RequestedModuleType,
+    _options: ModuleLoadOptions,
   ) -> ModuleLoadResponse {
     let mut sources = self.sources.borrow_mut();
     let source = match sources.remove(specifier.as_str()) {
@@ -310,8 +313,7 @@ impl ModuleLoader for ExtModuleLoader {
     &self,
     _specifier: &ModuleSpecifier,
     _maybe_referrer: Option<String>,
-    _is_dyn_import: bool,
-    _requested_module_type: RequestedModuleType,
+    _options: ModuleLoadOptions,
   ) -> Pin<Box<dyn Future<Output = Result<(), ModuleLoaderError>>>> {
     async { Ok(()) }.boxed_local()
   }
@@ -358,8 +360,7 @@ impl ModuleLoader for LazyEsmModuleLoader {
     &self,
     specifier: &ModuleSpecifier,
     _maybe_referrer: Option<&ModuleLoadReferrer>,
-    _is_dyn_import: bool,
-    _requested_module_type: RequestedModuleType,
+    _options: ModuleLoadOptions,
   ) -> ModuleLoadResponse {
     let mut sources = self.sources.borrow_mut();
     let source = match sources.remove(specifier.as_str()) {
@@ -383,8 +384,7 @@ impl ModuleLoader for LazyEsmModuleLoader {
     &self,
     _specifier: &ModuleSpecifier,
     _maybe_referrer: Option<String>,
-    _is_dyn_import: bool,
-    _requested_module_type: RequestedModuleType,
+    _options: ModuleLoadOptions,
   ) -> Pin<Box<dyn Future<Output = Result<(), ModuleLoaderError>>>> {
     async { Ok(()) }.boxed_local()
   }
@@ -421,8 +421,7 @@ impl ModuleLoader for FsModuleLoader {
     &self,
     module_specifier: &ModuleSpecifier,
     _maybe_referrer: Option<&ModuleLoadReferrer>,
-    _is_dynamic: bool,
-    requested_module_type: RequestedModuleType,
+    options: ModuleLoadOptions,
   ) -> ModuleLoadResponse {
     let module_specifier = module_specifier.clone();
     let fut = async move {
@@ -441,7 +440,7 @@ impl ModuleLoader for FsModuleLoader {
         } else if ext == "wasm" {
           ModuleType::Wasm
         } else {
-          match &requested_module_type {
+          match &options.requested_module_type {
             RequestedModuleType::Other(ty) => ModuleType::Other(ty.clone()),
             RequestedModuleType::Text => ModuleType::Text,
             RequestedModuleType::Bytes => ModuleType::Bytes,
@@ -455,7 +454,7 @@ impl ModuleLoader for FsModuleLoader {
       // If we loaded a JSON file, but the "requested_module_type" (that is computed from
       // import attributes) is not JSON we need to fail.
       if module_type == ModuleType::Json
-        && requested_module_type != RequestedModuleType::Json
+        && options.requested_module_type != RequestedModuleType::Json
       {
         return Err(JsErrorBox::generic("Attempted to load JSON module without specifying \"type\": \"json\" attribute in the import statement."));
       }
@@ -524,8 +523,7 @@ impl ModuleLoader for StaticModuleLoader {
     &self,
     module_specifier: &ModuleSpecifier,
     _maybe_referrer: Option<&ModuleLoadReferrer>,
-    _is_dyn_import: bool,
-    _requested_module_type: RequestedModuleType,
+    _options: ModuleLoadOptions,
   ) -> ModuleLoadResponse {
     let res = if let Some(code) = self.map.get(module_specifier) {
       Ok(ModuleSource::new(
@@ -593,16 +591,12 @@ impl<L: ModuleLoader> ModuleLoader for TestingModuleLoader<L> {
     &self,
     module_specifier: &ModuleSpecifier,
     maybe_referrer: Option<String>,
-    is_dyn_import: bool,
-    requested_module_type: RequestedModuleType,
+    options: ModuleLoadOptions,
   ) -> Pin<Box<dyn Future<Output = Result<(), ModuleLoaderError>>>> {
     self.prepare_count.set(self.prepare_count.get() + 1);
-    self.loader.prepare_load(
-      module_specifier,
-      maybe_referrer,
-      is_dyn_import,
-      requested_module_type,
-    )
+    self
+      .loader
+      .prepare_load(module_specifier, maybe_referrer, options)
   }
 
   fn finish_load(&self) {
@@ -614,17 +608,11 @@ impl<L: ModuleLoader> ModuleLoader for TestingModuleLoader<L> {
     &self,
     module_specifier: &ModuleSpecifier,
     maybe_referrer: Option<&ModuleLoadReferrer>,
-    is_dyn_import: bool,
-    requested_module_type: RequestedModuleType,
+    options: ModuleLoadOptions,
   ) -> ModuleLoadResponse {
     self.load_count.set(self.load_count.get() + 1);
     self.log.borrow_mut().push(module_specifier.clone());
-    self.loader.load(
-      module_specifier,
-      maybe_referrer,
-      is_dyn_import,
-      requested_module_type,
-    )
+    self.loader.load(module_specifier, maybe_referrer, options)
   }
 }
 

core/modules/map.rs

@@ -3,7 +3,9 @@
 use super::IntoModuleCodeString;
 use super::IntoModuleName;
 use super::ModuleConcreteError;
+use super::loaders::ModuleLoadOptions;
 use super::module_map_data::ModuleMapSnapshotData;
+use super::recursive_load::SideModuleKind;
 use crate::FastStaticString;
 use crate::JsRuntime;
 use crate::ModuleCodeBytes;
@@ -1064,9 +1066,13 @@ impl ModuleMap {
   pub(crate) async fn load_side(
     module_map_rc: Rc<ModuleMap>,
     specifier: impl AsRef<str>,
+    kind: SideModuleKind,
   ) -> Result<RecursiveModuleLoad, CoreError> {
-    let load =
-      RecursiveModuleLoad::side(specifier.as_ref(), module_map_rc.clone());
+    let load = RecursiveModuleLoad::side(
+      specifier.as_ref(),
+      module_map_rc.clone(),
+      kind,
+    );
     load.prepare().await?;
     Ok(load)
   }
@@ -2003,8 +2009,15 @@ impl ModuleMap {
 
     let specifier = ModuleSpecifier::parse(module_specifier)?;
 
-    let load_response =
-      loader.load(&specifier, None, false, RequestedModuleType::None);
+    let load_response = loader.load(
+      &specifier,
+      None,
+      ModuleLoadOptions {
+        is_dynamic_import: false,
+        is_synchronous: false,
+        requested_module_type: RequestedModuleType::None,
+      },
+    );
 
     let source = match load_response {
       ModuleLoadResponse::Sync(result) => result,

core/modules/mod.rs

@@ -26,6 +26,7 @@ pub use loaders::ExtCodeCache;
 pub(crate) use loaders::ExtModuleLoader;
 pub use loaders::FsModuleLoader;
 pub(crate) use loaders::LazyEsmModuleLoader;
+pub use loaders::ModuleLoadOptions;
 pub use loaders::ModuleLoadReferrer;
 pub use loaders::ModuleLoadResponse;
 pub use loaders::ModuleLoader;
@@ -36,6 +37,7 @@ pub(crate) use map::ModuleMap;
 pub(crate) use map::script_origin;
 pub(crate) use map::synthetic_module_evaluation_steps;
 pub(crate) use module_map_data::ModuleMapSnapshotData;
+pub(crate) use recursive_load::SideModuleKind;
 
 pub type ModuleId = usize;
 pub(crate) type ModuleLoadId = i32;