fix: unstable render dependency template (#11473)

Author: LingyuCoder

crates/rspack_core/src/artifacts/module_graph_cache_artifact.rs

@@ -194,7 +194,7 @@ pub(super) mod concatenated_module_entries {
   use super::*;
   use crate::ModuleIdentifier;
 
-  pub type ConcatenatedModuleEntriesCacheKey = (ModuleIdentifier, String);
+  pub type ConcatenatedModuleEntriesCacheKey = (ModuleIdentifier, Option<RuntimeKey>);
 
   #[derive(Debug, Default)]
   pub struct ConcatenatedModuleEntriesCache {

crates/rspack_core/src/compiler/compilation.rs

@@ -46,8 +46,8 @@ use crate::{
   EntryOptions, EntryRuntime, Entrypoint, Filename, ImportVarMap, Logger, MemoryGCStorage,
   ModuleFactory, ModuleGraph, ModuleGraphCacheArtifact, ModuleGraphPartial, ModuleIdentifier,
   ModuleIdsArtifact, ModuleStaticCacheArtifact, PathData, ResolverFactory, RuntimeGlobals,
-  RuntimeMode, RuntimeModule, RuntimeSpecMap, RuntimeTemplate, SharedPluginDriver,
-  SideEffectsOptimizeArtifact, SourceType, Stats, ValueCacheVersions,
+  RuntimeKeyMap, RuntimeMode, RuntimeModule, RuntimeSpec, RuntimeSpecMap, RuntimeTemplate,
+  SharedPluginDriver, SideEffectsOptimizeArtifact, SourceType, Stats, ValueCacheVersions,
   build_chunk_graph::{build_chunk_graph, build_chunk_graph_new},
   compilation::make::{
     ExecuteModuleId, MakeArtifact, ModuleExecutor, UpdateParam, finish_make, make,
@@ -280,7 +280,7 @@ pub struct Compilation {
 
   pub value_cache_versions: ValueCacheVersions,
 
-  import_var_map: IdentifierDashMap<ImportVarMap>,
+  import_var_map: IdentifierDashMap<RuntimeKeyMap<ImportVarMap>>,
 
   // TODO move to MakeArtifact
   pub module_executor: Option<ModuleExecutor>,
@@ -588,7 +588,7 @@ impl Compilation {
   }
 
   // TODO move out from compilation
-  pub fn get_import_var(&self, dep_id: &DependencyId) -> String {
+  pub fn get_import_var(&self, dep_id: &DependencyId, runtime: Option<&RuntimeSpec>) -> String {
     let module_graph = self.get_module_graph();
     let parent_module_id = module_graph
       .get_parent_module(dep_id)
@@ -601,7 +601,10 @@ impl Compilation {
       .and_then(|dep| dep.as_module_dependency())
       .expect("should be module dependency");
     let user_request = to_identifier(module_dep.user_request());
-    let mut import_var_map_of_module = self.import_var_map.entry(*parent_module_id).or_default();
+    let mut runtime_map = self.import_var_map.entry(*parent_module_id).or_default();
+    let import_var_map_of_module = runtime_map
+      .entry(runtime.map(get_runtime_key).unwrap_or_default())
+      .or_default();
     let len = import_var_map_of_module.len();
 
     match import_var_map_of_module.entry(module_id) {
@@ -1782,7 +1785,7 @@ impl Compilation {
             }
 
             for runtime_key in runtime_map.map.keys() {
-              if !module_runtime_keys.contains(&runtime_key.as_str()) {
+              if !module_runtime_keys.contains(runtime_key) {
                 modules.insert(*mi);
                 break;
               }

crates/rspack_core/src/concatenated_module.rs

@@ -1735,51 +1735,42 @@ impl ConcatenatedModule {
     mg: &ModuleGraph,
     mg_cache: &ModuleGraphCacheArtifact,
   ) -> Vec<ConcatenationEntry> {
-    mg_cache.cached_concatenated_module_entries(
-      (
-        self.id,
-        runtime
-          .map(|r| get_runtime_key(r).to_string())
-          .unwrap_or_default(),
-      ),
-      || {
-        let root_module = self.root_module_ctxt.id;
-        let module_set: IdentifierIndexSet = self.modules.iter().map(|item| item.id).collect();
-
-        let mut list = vec![];
-        let mut exists_entries = IdentifierMap::default();
-        exists_entries.insert(root_module, RuntimeCondition::Boolean(true));
-
-        let imports_map = module_set
-          .par_iter()
-          .map(|module| {
-            let imports =
-              self.get_concatenated_imports(module, &root_module, runtime, mg, mg_cache);
-            (*module, imports)
-          })
-          .collect::<IdentifierMap<_>>();
+    mg_cache.cached_concatenated_module_entries((self.id, runtime.map(get_runtime_key)), || {
+      let root_module = self.root_module_ctxt.id;
+      let module_set: IdentifierIndexSet = self.modules.iter().map(|item| item.id).collect();
+
+      let mut list = vec![];
+      let mut exists_entries = IdentifierMap::default();
+      exists_entries.insert(root_module, RuntimeCondition::Boolean(true));
+
+      let imports_map = module_set
+        .par_iter()
+        .map(|module| {
+          let imports = self.get_concatenated_imports(module, &root_module, runtime, mg, mg_cache);
+          (*module, imports)
+        })
+        .collect::<IdentifierMap<_>>();
 
-        let imports = imports_map.get(&root_module).expect("should have imports");
-        for i in imports {
-          self.enter_module(
-            &module_set,
-            runtime,
-            mg,
-            &i.connection,
-            i.runtime_condition.clone(),
-            &mut exists_entries,
-            &mut list,
-            &imports_map,
-          );
-        }
-        list.push(ConcatenationEntry::Concatenated(
-          ConcatenationEntryConcatenated {
-            module: root_module,
-          },
-        ));
-        list
-      },
-    )
+      let imports = imports_map.get(&root_module).expect("should have imports");
+      for i in imports {
+        self.enter_module(
+          &module_set,
+          runtime,
+          mg,
+          &i.connection,
+          i.runtime_condition.clone(),
+          &mut exists_entries,
+          &mut list,
+          &imports_map,
+        );
+      }
+      list.push(ConcatenationEntry::Concatenated(
+        ConcatenationEntryConcatenated {
+          module: root_module,
+        },
+      ));
+      list
+    })
   }
 
   #[allow(clippy::too_many_arguments)]

crates/rspack_core/src/dependency/runtime_template.rs

@@ -378,6 +378,7 @@ pub fn module_id(
 
 pub fn import_statement(
   module: &dyn Module,
+  runtime: Option<&RuntimeSpec>,
   compilation: &Compilation,
   runtime_requirements: &mut RuntimeGlobals,
   id: &DependencyId,
@@ -396,7 +397,7 @@ pub fn import_statement(
 
   runtime_requirements.insert(RuntimeGlobals::REQUIRE);
 
-  let import_var = compilation.get_import_var(id);
+  let import_var = compilation.get_import_var(id, runtime);
 
   let opt_declaration = if update { "" } else { "var " };
 

crates/rspack_core/src/runtime.rs

@@ -4,16 +4,17 @@ use rspack_cacheable::{
   cacheable,
   with::{AsRefStr, AsVec},
 };
-use rustc_hash::FxHashMap as HashMap;
+use ustr::{Ustr, UstrMap, UstrSet};
 
 use crate::{EntryOptions, EntryRuntime};
 
 #[cacheable]
 #[derive(Debug, Default, Clone)]
 pub struct RuntimeSpec {
   #[cacheable(with=AsVec<AsRefStr>)]
-  inner: ustr::UstrSet,
-  key: String,
+  inner: UstrSet,
+  #[cacheable(with=AsRefStr)]
+  key: Ustr,
 }
 
 impl std::fmt::Display for RuntimeSpec {
@@ -45,39 +46,39 @@ impl std::cmp::PartialEq for RuntimeSpec {
 impl std::cmp::Eq for RuntimeSpec {}
 
 impl Deref for RuntimeSpec {
-  type Target = ustr::UstrSet;
+  type Target = UstrSet;
 
   fn deref(&self) -> &Self::Target {
     &self.inner
   }
 }
 
-impl From<ustr::UstrSet> for RuntimeSpec {
-  fn from(value: ustr::UstrSet) -> Self {
+impl From<UstrSet> for RuntimeSpec {
+  fn from(value: UstrSet) -> Self {
     Self::new(value)
   }
 }
 
-impl FromIterator<ustr::Ustr> for RuntimeSpec {
-  fn from_iter<T: IntoIterator<Item = ustr::Ustr>>(iter: T) -> Self {
-    Self::new(ustr::UstrSet::from_iter(iter))
+impl FromIterator<Ustr> for RuntimeSpec {
+  fn from_iter<T: IntoIterator<Item = Ustr>>(iter: T) -> Self {
+    Self::new(UstrSet::from_iter(iter))
   }
 }
 
 impl IntoIterator for RuntimeSpec {
-  type Item = ustr::Ustr;
-  type IntoIter = <ustr::UstrSet as IntoIterator>::IntoIter;
+  type Item = Ustr;
+  type IntoIter = <UstrSet as IntoIterator>::IntoIter;
 
   fn into_iter(self) -> Self::IntoIter {
     self.inner.into_iter()
   }
 }
 
 impl RuntimeSpec {
-  pub fn new(inner: ustr::UstrSet) -> Self {
+  pub fn new(inner: UstrSet) -> Self {
     let mut this = Self {
       inner,
-      key: String::new(),
+      key: Ustr::from(""),
     };
     this.update_key();
     this
@@ -105,7 +106,7 @@ impl RuntimeSpec {
     Self::new(res)
   }
 
-  pub fn insert(&mut self, r: ustr::Ustr) -> bool {
+  pub fn insert(&mut self, r: Ustr) -> bool {
     let update = self.inner.insert(r);
     if update {
       self.update_key();
@@ -126,20 +127,23 @@ impl RuntimeSpec {
       if self.key.is_empty() {
         return;
       }
-      self.key = String::new();
+      self.key = Ustr::from("");
       return;
     }
     let mut ordered = self.inner.iter().map(|s| s.as_str()).collect::<Vec<_>>();
     ordered.sort_unstable();
-    self.key = ordered.join("_");
+    let key = ordered.join("_");
+    self.key = Ustr::from(&key);
   }
 
   pub fn as_str(&self) -> &str {
     &self.key
   }
 }
 
-pub type RuntimeKey = String;
+pub type RuntimeKey = Ustr;
+
+pub type RuntimeKeyMap<T> = UstrMap<T>;
 
 #[derive(Default, Clone, Copy, Debug, PartialEq, Eq)]
 pub enum RuntimeMode {
@@ -209,7 +213,7 @@ pub fn filter_runtime(
     Some(runtime) => {
       let mut some = false;
       let mut every = true;
-      let mut result = ustr::UstrSet::default();
+      let mut result = UstrSet::default();
 
       for &r in runtime.iter() {
         let cur = RuntimeSpec::from_iter([r]);
@@ -287,7 +291,7 @@ pub fn subtract_runtime_condition(
       if let Some(a) = runtime {
         a.difference(b).copied().collect()
       } else {
-        ustr::UstrSet::default()
+        UstrSet::default()
       }
     }
   };
@@ -297,8 +301,8 @@ pub fn subtract_runtime_condition(
   RuntimeCondition::Spec(merged.into())
 }
 
-pub fn get_runtime_key(runtime: &RuntimeSpec) -> &str {
-  &runtime.key
+pub fn get_runtime_key(runtime: &RuntimeSpec) -> RuntimeKey {
+  runtime.key
 }
 
 pub fn compare_runtime(a: &RuntimeSpec, b: &RuntimeSpec) -> Ordering {
@@ -308,7 +312,7 @@ pub fn compare_runtime(a: &RuntimeSpec, b: &RuntimeSpec) -> Ordering {
 #[derive(Default, Clone, Debug, PartialEq, Eq)]
 pub struct RuntimeSpecMap<T> {
   pub mode: RuntimeMode,
-  pub map: HashMap<RuntimeKey, T>,
+  pub map: RuntimeKeyMap<T>,
 
   pub single_runtime: Option<RuntimeSpec>,
   pub single_value: Option<T>,
@@ -342,7 +346,7 @@ impl<T> RuntimeSpecMap<T> {
           None
         }
       }
-      RuntimeMode::Map => self.map.get(get_runtime_key(runtime)),
+      RuntimeMode::Map => self.map.get(&get_runtime_key(runtime)),
     }
   }
 
@@ -358,7 +362,7 @@ impl<T> RuntimeSpecMap<T> {
           None
         }
       }
-      RuntimeMode::Map => self.map.get_mut(get_runtime_key(runtime)),
+      RuntimeMode::Map => self.map.get_mut(&get_runtime_key(runtime)),
     }
   }
 
@@ -388,16 +392,12 @@ impl<T> RuntimeSpecMap<T> {
 
           self
             .map
-            .insert(get_runtime_key(&single_runtime).to_string(), single_value);
-          self
-            .map
-            .insert(get_runtime_key(&runtime).to_string(), value);
+            .insert(get_runtime_key(&single_runtime), single_value);
+          self.map.insert(get_runtime_key(&runtime), value);
         }
       }
       RuntimeMode::Map => {
-        self
-          .map
-          .insert(get_runtime_key(&runtime).to_string(), value);
+        self.map.insert(get_runtime_key(&runtime), value);
       }
     }
   }
@@ -439,22 +439,20 @@ impl<'a, T> Iterator for RuntimeSpecMapValues<'a, T> {
 
 #[derive(Default, Debug)]
 pub struct RuntimeSpecSet {
-  map: HashMap<RuntimeKey, RuntimeSpec>,
+  map: RuntimeKeyMap<RuntimeSpec>,
 }
 
 impl RuntimeSpecSet {
   pub fn get(&self, runtime: &RuntimeSpec) -> Option<&RuntimeSpec> {
-    self.map.get(get_runtime_key(runtime))
+    self.map.get(&get_runtime_key(runtime))
   }
 
   pub fn set(&mut self, runtime: RuntimeSpec) {
-    self
-      .map
-      .insert(get_runtime_key(&runtime).to_string(), runtime);
+    self.map.insert(get_runtime_key(&runtime), runtime);
   }
 
   pub fn contains(&self, runtime: &RuntimeSpec) -> bool {
-    self.map.contains_key(get_runtime_key(runtime))
+    self.map.contains_key(&get_runtime_key(runtime))
   }
 
   pub fn values(&self) -> hash_map::Values<'_, RuntimeKey, RuntimeSpec> {