feat: diff context module sync mode (#6354)

Author: ahabhgk

Cargo.lock

@@ -17,7 +17,7 @@ use rspack_identifier::{Identifiable, Identifier};
 use rspack_macros::impl_source_map_config;
 use rspack_regex::RspackRegex;
 use rspack_sources::{BoxSource, ConcatSource, RawSource, SourceExt};
-use rspack_util::{json_stringify, source_map::SourceMapKind};
+use rspack_util::{fx_hash::FxIndexMap, json_stringify, source_map::SourceMapKind};
 use rustc_hash::FxHashMap as HashMap;
 use rustc_hash::FxHashSet as HashSet;
 
@@ -146,6 +146,7 @@ pub struct ContextOptions {
   pub context: String,
   pub namespace_object: ContextNameSpaceObject,
   pub group_options: Option<GroupOptions>,
+  pub replaces: Vec<(String, u32, u32)>,
   pub start: u32,
   pub end: u32,
 }
@@ -273,6 +274,13 @@ impl ContextModule {
     }
   }
 
+  fn get_fake_map_init_statement(&self, fake_map: &FakeMapValue) -> String {
+    match fake_map {
+      FakeMapValue::Bit(_) => "".to_string(),
+      FakeMapValue::Map(map) => json_stringify(map),
+    }
+  }
+
   fn get_return_module_object_source(
     &self,
     fake_map: &FakeMapValue,
@@ -306,36 +314,26 @@ impl ContextModule {
     &self,
     dependencies: impl IntoIterator<Item = &DependencyId>,
     compilation: &Compilation,
-  ) -> HashMap<String, String> {
+  ) -> FxIndexMap<String, Option<String>> {
+    let module_graph = compilation.get_module_graph();
     let dependencies = dependencies.into_iter();
-    let mut map = HashMap::default();
-    for dependency in dependencies {
-      if let Some(module_identifier) = compilation
-        .get_module_graph()
-        .module_identifier_by_dependency_id(dependency)
-      {
-        if let Some(dependency) = compilation.get_module_graph().dependency_by_id(dependency) {
-          let request = if let Some(d) = dependency.as_module_dependency() {
+    dependencies
+      .filter_map(|dep_id| {
+        let dep = module_graph.dependency_by_id(dep_id).and_then(|dep| {
+          if let Some(d) = dep.as_module_dependency() {
             Some(d.user_request().to_string())
           } else {
-            dependency
-              .as_context_dependency()
-              .map(|d| d.request().to_string())
-          };
-          if let Some(request) = request {
-            map.insert(
-              request,
-              if let Some(module_id) = compilation.chunk_graph.get_module_id(*module_identifier) {
-                format!("\"{module_id}\"")
-              } else {
-                "null".to_string()
-              },
-            );
+            dep.as_context_dependency().map(|d| d.request().to_string())
           }
-        }
-      }
-    }
-    map
+        });
+        let module_id = module_graph
+          .module_identifier_by_dependency_id(dep_id)
+          .and_then(|module| compilation.chunk_graph.get_module_id(*module).clone());
+        // module_id could be None in weak mode
+        dep.map(|dep| (dep, module_id))
+      })
+      .sorted_by(|(a, _), (b, _)| a.cmp(b))
+      .collect()
   }
 
   fn get_source_for_empty_async_context(&self, compilation: &Compilation) -> BoxSource {
@@ -360,6 +358,24 @@ impl ContextModule {
     .boxed()
   }
 
+  fn get_source_for_empty_context(&self, compilation: &Compilation) -> BoxSource {
+    RawSource::from(formatdoc! {r#"
+      function webpackEmptyContext(req) {{
+        var e = new Error("Cannot find module '" + req + "'");
+        e.code = 'MODULE_NOT_FOUND';
+        throw e;
+      }}
+      webpackEmptyContext.keys = {keys};
+      webpackEmptyContext.resolve = webpackEmptyContext;
+      webpackEmptyContext.id = {id};
+      module.exports = webpackEmptyContext;
+      "#,
+      keys = returning_function("[]", ""),
+      id = json_stringify(self.id(&compilation.chunk_graph))
+    })
+    .boxed()
+  }
+
   #[inline]
   fn get_source_string(&self, compilation: &Compilation) -> BoxSource {
     match self.options.context_options.mode {
@@ -379,6 +395,13 @@ impl ContextModule {
         let block = module_graph.block_by_id(block).expect("should have block");
         self.generate_source(block.get_dependencies(), compilation)
       }
+      ContextMode::Sync => {
+        if !self.get_dependencies().is_empty() {
+          self.get_sync_source(compilation)
+        } else {
+          self.get_source_for_empty_context(compilation)
+        }
+      }
       _ => self.generate_source(self.get_dependencies(), compilation),
     }
   }
@@ -530,13 +553,50 @@ impl ContextModule {
       webpackAsyncContext.id = {id};
       module.exports = webpackAsyncContext;
       "#,
-      map = stringify_map(&map),
+      map = json_stringify(&map),
       keys = returning_function("Object.keys(map)", ""),
       id = json_stringify(self.id(&compilation.chunk_graph))
     }));
     source.boxed()
   }
 
+  fn get_sync_source(&self, compilation: &Compilation) -> BoxSource {
+    let dependencies = self.get_dependencies();
+    let map = self.get_user_request_map(dependencies, compilation);
+    let fake_map = self.get_fake_map(dependencies, compilation);
+    let return_module_object =
+      self.get_return_module_object_source(&fake_map, false, "fakeMap[id]");
+    let source = formatdoc! {r#"
+      var map = {map};
+      {fake_map_init_statement}
+
+      function webpackContext(req) {{
+        var id = webpackContextResolve(req);
+        {return_module_object}
+      }}
+      function webpackContextResolve(req) {{
+        if(!{has_own_property}(map, req)) {{
+          var e = new Error("Cannot find module '" + req + "'");
+          e.code = 'MODULE_NOT_FOUND';
+          throw e;
+        }}
+        return map[req];
+      }}
+      webpackContext.keys = function webpackContextKeys() {{
+        return Object.keys(map);
+      }};
+      webpackContext.resolve = webpackContextResolve;
+      module.exports = webpackContext;
+      webpackContext.id = {id};
+      "#,
+      map = json_stringify(&map),
+      fake_map_init_statement = self.get_fake_map_init_statement(&fake_map),
+      has_own_property = RuntimeGlobals::HAS_OWN_PROPERTY,
+      id = json_stringify(self.id(&compilation.chunk_graph))
+    };
+    RawSource::from(source).boxed()
+  }
+
   fn generate_source(&self, dependencies: &[DependencyId], compilation: &Compilation) -> BoxSource {
     let map = self.get_user_request_map(dependencies, compilation);
     let fake_map = self.get_fake_map(dependencies, compilation);
@@ -561,7 +621,7 @@ impl ContextModule {
     let mut source = ConcatSource::default();
     source.add(RawSource::from(format!(
       "var map = {};\n",
-      stringify_map(&map)
+      json_stringify(&map)
     )));
     if let FakeMapValue::Map(map) = &fake_map {
       source.add(RawSource::from(format!(
@@ -623,7 +683,7 @@ impl ContextModule {
     source.add(RawSource::from("\n}\n"));
 
     source.add(RawSource::from(format!(
-      "webpackContext.id = '{}';\n",
+      "webpackContext.id = {};\n",
       serde_json::to_string(self.id(&compilation.chunk_graph))
         .unwrap_or_else(|e| panic!("{}", e.to_string()))
     )));

crates/rspack_core/src/context_module.rs

@@ -0,0 +1,49 @@
+use crate::{
+  AsDependency, DependencyTemplate, InitFragmentExt, InitFragmentKey, InitFragmentStage,
+  NormalInitFragment, TemplateContext, TemplateReplaceSource,
+};
+
+#[derive(Debug, Clone)]
+pub struct CachedConstDependency {
+  pub start: u32,
+  pub end: u32,
+  pub identifier: Box<str>,
+  pub content: Box<str>,
+}
+
+impl CachedConstDependency {
+  pub fn new(start: u32, end: u32, identifier: Box<str>, content: Box<str>) -> Self {
+    Self {
+      start,
+      end,
+      identifier,
+      content,
+    }
+  }
+}
+
+impl DependencyTemplate for CachedConstDependency {
+  fn apply(
+    &self,
+    source: &mut TemplateReplaceSource,
+    code_generatable_context: &mut TemplateContext,
+  ) {
+    code_generatable_context.init_fragments.push(
+      NormalInitFragment::new(
+        format!("var {} = {};\n", self.identifier, self.content),
+        InitFragmentStage::StageConstants,
+        0,
+        InitFragmentKey::Const(self.identifier.to_string()),
+        None,
+      )
+      .boxed(),
+    );
+    source.replace(self.start, self.end, &self.identifier, None);
+  }
+
+  fn dependency_id(&self) -> Option<crate::DependencyId> {
+    None
+  }
+}
+
+impl AsDependency for CachedConstDependency {}

crates/rspack_core/src/dependency/cached_const_dependency.rs

@@ -1,3 +1,4 @@
+mod cached_const_dependency;
 mod const_dependency;
 mod context_dependency;
 mod context_element_dependency;
@@ -17,6 +18,7 @@ mod static_exports_dependency;
 
 use std::sync::Arc;
 
+pub use cached_const_dependency::CachedConstDependency;
 pub use const_dependency::ConstDependency;
 pub use context_dependency::{AsContextDependency, ContextDependency};
 pub use context_element_dependency::ContextElementDependency;

crates/rspack_core/src/dependency/mod.rs

@@ -1,6 +1,7 @@
 use std::fmt;
 
 use bitflags::bitflags;
+use serde::Serialize;
 
 bitflags! {
   #[derive(Debug, Clone, Copy, Eq, PartialEq)]
@@ -21,3 +22,12 @@ impl fmt::Display for FakeNamespaceObjectMode {
     f.write_fmt(format_args!("{}", self.bits()))
   }
 }
+
+impl Serialize for FakeNamespaceObjectMode {
+  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+  where
+    S: serde::Serializer,
+  {
+    serializer.serialize_u8(self.bits())
+  }
+}

crates/rspack_core/src/fake_namespace_object.rs

@@ -27,6 +27,7 @@ pub type InitFragmentKeyUKey = rspack_database::Ukey<InitFragmentKeyUnique>;
 
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub enum InitFragmentKey {
+  Unique(InitFragmentKeyUKey),
   HarmonyImport(String),
   HarmonyExportStar(String), // TODO: align with webpack and remove this
   HarmonyExports,
@@ -35,8 +36,8 @@ pub enum InitFragmentKey {
   AwaitDependencies,
   HarmonyCompatibility,
   ModuleDecorator(String /* module_id */),
-  Unique(InitFragmentKeyUKey),
   HarmonyFakeNamespaceObjectFragment(String),
+  Const(String),
 }
 
 impl InitFragmentKey {
@@ -113,7 +114,8 @@ impl InitFragmentKey {
       | InitFragmentKey::HarmonyExportStar(_)
       | InitFragmentKey::ExternalModule(_)
       | InitFragmentKey::ModuleDecorator(_)
-      | InitFragmentKey::CommonJsExports(_) => first(fragments),
+      | InitFragmentKey::CommonJsExports(_)
+      | InitFragmentKey::Const(_) => first(fragments),
       InitFragmentKey::HarmonyCompatibility | InitFragmentKey::Unique(_) => {
         debug_assert!(fragments.len() == 1, "fragment = {:?}", self);
         first(fragments)

crates/rspack_core/src/init_fragment.rs

@@ -1,9 +1,11 @@
-use rspack_core::{module_raw, parse_resource, AsModuleDependency, ContextDependency};
-use rspack_core::{normalize_context, DependencyCategory, DependencyId, DependencyTemplate};
+use rspack_core::{AsModuleDependency, ContextDependency};
 use rspack_core::{ContextOptions, Dependency, TemplateReplaceSource};
+use rspack_core::{DependencyCategory, DependencyId, DependencyTemplate};
 use rspack_core::{DependencyType, ErrorSpan, TemplateContext};
 
-use super::create_resource_identifier_for_context_dependency;
+use super::{
+  context_dependency_template_as_require_call, create_resource_identifier_for_context_dependency,
+};
 
 #[derive(Debug, Clone)]
 pub struct CommonJsRequireContextDependency {
@@ -87,49 +89,14 @@ impl DependencyTemplate for CommonJsRequireContextDependency {
     source: &mut TemplateReplaceSource,
     code_generatable_context: &mut TemplateContext,
   ) {
-    let TemplateContext {
-      compilation,
-      runtime_requirements,
-      ..
-    } = code_generatable_context;
-
-    let expr = module_raw(
-      compilation,
-      runtime_requirements,
-      &self.id,
-      self.request(),
-      false,
+    context_dependency_template_as_require_call(
+      self,
+      source,
+      code_generatable_context,
+      self.callee_start,
+      self.callee_end,
+      self.args_end,
     );
-
-    if compilation
-      .get_module_graph()
-      .module_graph_module_by_dependency_id(&self.id)
-      .is_none()
-    {
-      source.replace(self.callee_start, self.args_end, &expr, None);
-      return;
-    }
-
-    source.replace(self.callee_start, self.callee_end, &expr, None);
-
-    let context = normalize_context(&self.options.request);
-    let query = parse_resource(&self.options.request).and_then(|data| data.query);
-    if !context.is_empty() {
-      source.insert(self.callee_end, "(", None);
-      source.insert(
-        self.args_end,
-        format!(".replace('{context}', './')").as_str(),
-        None,
-      );
-      if let Some(query) = query {
-        source.insert(
-          self.args_end,
-          format!(".replace('{query}', '')").as_str(),
-          None,
-        );
-      }
-      source.insert(self.args_end, ")", None);
-    }
   }
 
   fn dependency_id(&self) -> Option<DependencyId> {