fix

crates/rspack_core/src/compiler/compilation.rs

@@ -869,57 +869,45 @@ impl Compilation {
     let results = jobs
       .into_par_iter()
       .map(|job| {
-        let module = job.module;
-        let runtimes = job.runtimes.clone();
-        (
-          module,
-          runtimes,
-          self
-            .old_cache
-            .code_generate_occasion
-            .use_cache(job, |module, runtime| {
-              let module = module_graph
-                .module_by_identifier(&module)
-                .expect("should have module");
-              module.code_generation(self, Some(runtime), None)
-            }),
-        )
-      })
-      .map(|(module, runtime, result)| match result {
-        Ok((result, runtime, from_cache)) => (module, result, runtime, from_cache, None),
-        Err(err) => (
-          module,
-          CodeGenerationResult::default(),
-          runtime,
-          false,
-          Some(err),
-        ),
+        self
+          .old_cache
+          .code_generate_occasion
+          .use_cache(job, |module, runtime| {
+            let module = module_graph
+              .module_by_identifier(&module)
+              .expect("should have module");
+            module.code_generation(self, Some(runtime), None)
+          })
       })
       .collect::<Vec<_>>();
-    for (module, codegen_res, runtimes, from_cache, err) in results {
+    for result in results {
       if let Some(counter) = cache_counter {
-        if from_cache {
+        if result.from_cache {
           counter.hit();
         } else {
           counter.miss();
         }
       }
 
+      let module = result.module;
+      let codegen_res = match result.codegen_result {
+        Ok(res) => res,
+        Err(err) => {
+          self.push_diagnostic(Diagnostic::from(err).with_module_identifier(Some(module)));
+          CodeGenerationResult::default()
+        }
+      };
       let codegen_res_id = codegen_res.id;
       self
         .code_generation_results
         .module_generation_result_map
         .insert(codegen_res_id, codegen_res);
-      for runtime in runtimes {
+      for runtime in result.runtimes {
         self
           .code_generation_results
           .add(module, runtime, codegen_res_id);
       }
       self.code_generated_modules.insert(module);
-
-      if let Some(err) = err {
-        self.push_diagnostic(Diagnostic::from(err).with_module_identifier(Some(module)));
-      }
     }
     Ok(())
   }

crates/rspack_core/src/old_cache/occasion/code_generate.rs

@@ -11,6 +11,13 @@ pub struct CodeGenerateOccasion {
   storage: Option<Box<Storage>>,
 }
 
+pub struct CodeGenerateOccasionResult {
+  pub module: ModuleIdentifier,
+  pub runtimes: Vec<RuntimeSpec>,
+  pub from_cache: bool,
+  pub codegen_result: Result<CodeGenerationResult>,
+}
+
 impl CodeGenerateOccasion {
   pub fn new(storage: Option<Box<Storage>>) -> Self {
     Self { storage }
@@ -21,21 +28,38 @@ impl CodeGenerateOccasion {
     &self,
     job: CodeGenerationJob,
     provide: impl Fn(ModuleIdentifier, &RuntimeSpec) -> Result<CodeGenerationResult>,
-  ) -> Result<(CodeGenerationResult, Vec<RuntimeSpec>, bool)> {
+  ) -> CodeGenerateOccasionResult {
     let storage = match &self.storage {
       Some(s) => s,
       None => {
-        let res = provide(job.module, &job.runtime)?;
-        return Ok((res, job.runtimes, false));
+        let codegen_result = provide(job.module, &job.runtime);
+        return CodeGenerateOccasionResult {
+          module: job.module,
+          runtimes: job.runtimes,
+          from_cache: false,
+          codegen_result,
+        };
       }
     };
     let cache_key = Identifier::from(format!("{}|{}", job.module, job.hash.encoded()));
     if let Some(value) = storage.get(&cache_key) {
-      Ok((value, job.runtimes, true))
+      CodeGenerateOccasionResult {
+        module: job.module,
+        runtimes: job.runtimes,
+        from_cache: true,
+        codegen_result: Ok(value),
+      }
     } else {
-      let res = provide(job.module, &job.runtime)?;
-      storage.set(cache_key, res.clone());
-      Ok((res, job.runtimes, false))
+      let codegen_result = provide(job.module, &job.runtime);
+      if let Ok(res) = &codegen_result {
+        storage.set(cache_key, res.clone());
+      }
+      CodeGenerateOccasionResult {
+        module: job.module,
+        runtimes: job.runtimes,
+        from_cache: false,
+        codegen_result,
+      }
     }
   }
 }