fix: runtime chunk hash should respect their reference order (#8303)

crates/node_binding/binding.d.ts

@@ -324,7 +324,8 @@ export function formatDiagnostic(diagnostic: JsDiagnostic): ExternalObject<'Diag
 export interface JsAddingRuntimeModule {
   name: string
   generator: () => String
-  cacheable: boolean
+  dependentHash: boolean
+  fullHash: boolean
   isolate: boolean
   stage: number
 }

crates/rspack_binding_values/src/codegen_result.rs

@@ -29,11 +29,10 @@ impl From<CodeGenerationResult> for JsCodegenerationResult {
 
 impl From<CodeGenerationResults> for JsCodegenerationResults {
   fn from(results: CodeGenerationResults) -> Self {
-    let id_result_map = results.module_generation_result_map;
+    let (map, id_result_map) = results.into_inner();
 
     Self {
-      map: results
-        .map
+      map: map
         .into_iter()
         .map(|(module_id, runtime_result_map)| {
           let mut runtime_map: HashMap<String, JsCodegenerationResult> = Default::default();

crates/rspack_binding_values/src/module.rs

@@ -499,7 +499,8 @@ pub struct JsAddingRuntimeModule {
   pub name: String,
   #[napi(ts_type = "() => String")]
   pub generator: GenerateFn,
-  pub cacheable: bool,
+  pub dependent_hash: bool,
+  pub full_hash: bool,
   pub isolate: bool,
   pub stage: u32,
 }
@@ -508,7 +509,8 @@ impl From<JsAddingRuntimeModule> for RuntimeModuleFromJs {
   fn from(value: JsAddingRuntimeModule) -> Self {
     Self {
       name: value.name,
-      cacheable: value.cacheable,
+      full_hash: value.full_hash,
+      dependent_hash: value.dependent_hash,
       isolate: value.isolate,
       stage: RuntimeModuleStage::from(value.stage),
       generator: Arc::new(move || value.generator.blocking_call_with_sync(())),

crates/rspack_core/src/cgm_runtime_requirement_results.rs

@@ -13,19 +13,6 @@ impl CgmRuntimeRequirementsResults {
     requirements.get(runtime)
   }
 
-  pub fn set(
-    &mut self,
-    module: ModuleIdentifier,
-    runtime: RuntimeSpec,
-    runtime_requirements: RuntimeGlobals,
-  ) {
-    let requirements = self
-      .module_to_runtime_requirements
-      .entry(module)
-      .or_default();
-    requirements.set(runtime, runtime_requirements);
-  }
-
   pub fn set_runtime_requirements(
     &mut self,
     module: ModuleIdentifier,
@@ -35,4 +22,8 @@ impl CgmRuntimeRequirementsResults {
       .module_to_runtime_requirements
       .insert(module, runtime_requirements_map);
   }
+
+  pub fn remove(&mut self, module: &ModuleIdentifier) -> Option<RuntimeSpecMap<RuntimeGlobals>> {
+    self.module_to_runtime_requirements.remove(module)
+  }
 }

crates/rspack_core/src/chunk.rs

@@ -426,12 +426,28 @@ impl Chunk {
       .chunk_graph
       .get_ordered_chunk_modules(&self.ukey, &compilation.get_module_graph())
     {
-      if let Some(hash) = compilation
+      let module_identifier = module.identifier();
+      let hash = compilation
         .code_generation_results
-        .get_hash(&module.identifier(), Some(&self.runtime))
-      {
-        hash.hash(hasher);
-      }
+        .get_hash(&module_identifier, Some(&self.runtime))
+        .unwrap_or_else(|| {
+          panic!("Module ({module_identifier}) should have hash result when updating chunk hash.");
+        });
+      hash.hash(hasher);
+    }
+    for (runtime_module_identifier, _) in compilation
+      .chunk_graph
+      .get_chunk_runtime_modules_in_order(&self.ukey, compilation)
+    {
+      let hash = compilation
+        .runtime_modules_hash
+        .get(runtime_module_identifier)
+        .unwrap_or_else(|| {
+          panic!(
+            "Runtime module ({runtime_module_identifier}) should have hash result when updating chunk hash."
+          );
+        });
+      hash.hash(hasher);
     }
     "entry".hash(hasher);
     for (module, chunk_group) in compilation

crates/rspack_core/src/chunk_graph/chunk_graph_chunk.rs

@@ -314,11 +314,19 @@ impl ChunkGraph {
       .collect()
   }
 
-  pub fn get_chunk_module_identifiers(&self, chunk: &ChunkUkey) -> &IdentifierSet {
+  pub fn get_chunk_modules_identifier(&self, chunk: &ChunkUkey) -> &IdentifierSet {
     let chunk_graph_chunk = self.expect_chunk_graph_chunk(chunk);
     &chunk_graph_chunk.modules
   }
 
+  pub fn get_ordered_chunk_modules_identifier(&self, chunk: &ChunkUkey) -> Vec<ModuleIdentifier> {
+    let chunk_graph_chunk = self.expect_chunk_graph_chunk(chunk);
+    let mut modules: Vec<ModuleIdentifier> = chunk_graph_chunk.modules.iter().copied().collect();
+    // SAFETY: module identifier is unique
+    modules.sort_unstable_by_key(|m| m.as_str());
+    modules
+  }
+
   pub fn get_ordered_chunk_modules<'module>(
     &self,
     chunk: &ChunkUkey,
@@ -427,6 +435,23 @@ impl ChunkGraph {
     cgc.entry_modules.len()
   }
 
+  pub fn has_chunk_full_hash_modules(
+    &self,
+    chunk: &ChunkUkey,
+    runtime_modules: &IdentifierMap<Box<dyn RuntimeModule>>,
+  ) -> bool {
+    let cgc = self.expect_chunk_graph_chunk(chunk);
+    for runtime_module in &cgc.runtime_modules {
+      let runtime_module = runtime_modules
+        .get(runtime_module)
+        .expect("should have runtime_module");
+      if !runtime_module.full_hash() {
+        return true;
+      }
+    }
+    false
+  }
+
   pub fn add_chunk_runtime_requirements(
     &mut self,
     chunk_ukey: &ChunkUkey,

crates/rspack_core/src/code_generation_results.rs

@@ -171,6 +171,7 @@ impl CodeGenerationResult {
       source.hash(&mut hasher);
     }
     self.chunk_init_fragments.hash(&mut hasher);
+    self.runtime_requirements.hash(&mut hasher);
     self.hash = Some(hasher.digest(hash_digest));
   }
 }
@@ -188,8 +189,8 @@ pub static CODE_GEN_RESULT_ID: AtomicU32 = AtomicU32::new(0);
 
 #[derive(Debug, Default, Clone)]
 pub struct CodeGenerationResults {
-  pub module_generation_result_map: HashMap<CodeGenResultId, CodeGenerationResult>,
-  pub map: IdentifierMap<RuntimeSpecMap<CodeGenResultId>>,
+  module_generation_result_map: HashMap<CodeGenResultId, CodeGenerationResult>,
+  map: IdentifierMap<RuntimeSpecMap<CodeGenResultId>>,
 }
 
 impl CodeGenerationResults {
@@ -210,6 +211,21 @@ impl CodeGenerationResults {
       })
   }
 
+  pub fn insert(
+    &mut self,
+    module_identifier: ModuleIdentifier,
+    codegen_res: CodeGenerationResult,
+    runtimes: impl IntoIterator<Item = RuntimeSpec>,
+  ) {
+    let codegen_res_id = codegen_res.id;
+    self
+      .module_generation_result_map
+      .insert(codegen_res_id, codegen_res);
+    for runtime in runtimes {
+      self.add(module_identifier, runtime, codegen_res_id);
+    }
+  }
+
   pub fn remove(&mut self, module_identifier: &ModuleIdentifier) -> Option<()> {
     let runtime_map = self.map.remove(module_identifier)?;
     for result in runtime_map.get_values() {
@@ -303,6 +319,15 @@ impl CodeGenerationResults {
 
     code_generation_result.hash.as_ref()
   }
+
+  pub fn into_inner(
+    self,
+  ) -> (
+    IdentifierMap<RuntimeSpecMap<CodeGenResultId>>,
+    HashMap<CodeGenResultId, CodeGenerationResult>,
+  ) {
+    (self.map, self.module_generation_result_map)
+  }
 }
 
 #[derive(Debug)]