refactor: build info save module asset (#9230)

* fix: build info save module asset

* fix: ci

* test: add test case

crates/node_binding/binding.d.ts

@@ -112,7 +112,6 @@ export declare class JsCompilation {
   deleteAssetSource(name: string): void
   getAssetFilenames(): Array<string>
   hasAsset(name: string): boolean
-  emitAssetFromLoader(filename: string, source: JsCompatSource, assetInfo: JsAssetInfo, module: string): void
   emitAsset(filename: string, source: JsCompatSource, assetInfo: JsAssetInfo): void
   deleteAsset(filename: string): void
   renameAsset(filename: string, newName: string): void
@@ -242,6 +241,7 @@ export declare class JsModule {
   libIdent(options: JsLibIdentOptions): string | null
   get resourceResolveData(): JsResourceData | undefined
   get matchResource(): string | undefined
+  emitFile(filename: string, source: JsCompatSource, assetInfo: JsAssetInfo): void
 }
 
 export declare class JsModuleGraph {
@@ -672,7 +672,6 @@ export interface JsExecuteModuleResult {
   buildDependencies: Array<string>
   missingDependencies: Array<string>
   cacheable: boolean
-  assets: Array<string>
   id: number
   error?: string
 }

crates/rspack_binding_values/src/compilation/mod.rs

@@ -14,7 +14,6 @@ use rspack_core::rspack_sources::BoxSource;
 use rspack_core::AssetInfo;
 use rspack_core::BoxDependency;
 use rspack_core::Compilation;
-use rspack_core::CompilationAsset;
 use rspack_core::CompilationId;
 use rspack_core::EntryDependency;
 use rspack_core::EntryOptions;
@@ -323,29 +322,6 @@ impl JsCompilation {
     Ok(compilation.assets().contains_key(&name))
   }
 
-  #[napi]
-  pub fn emit_asset_from_loader(
-    &mut self,
-    filename: String,
-    source: JsCompatSource,
-    asset_info: JsAssetInfo,
-    module: String,
-  ) -> Result<()> {
-    let compilation = self.as_mut()?;
-
-    compilation.emit_asset(
-      filename.clone(),
-      CompilationAsset::new(Some(source.into()), asset_info.into()),
-    );
-
-    compilation
-      .module_assets
-      .entry(ModuleIdentifier::from(module))
-      .or_default()
-      .insert(filename);
-    Ok(())
-  }
-
   #[napi]
   pub fn emit_asset(
     &mut self,
@@ -676,7 +652,6 @@ impl JsCompilation {
           .into_iter()
           .map(|d| d.to_string_lossy().to_string())
           .collect(),
-        assets: res.assets.into_iter().collect(),
         id: res.id,
         error: res.error,
       };
@@ -884,7 +859,6 @@ pub struct JsExecuteModuleResult {
   pub build_dependencies: Vec<String>,
   pub missing_dependencies: Vec<String>,
   pub cacheable: bool,
-  pub assets: Vec<String>,
   pub id: u32,
   pub error: Option<String>,
 }

crates/rspack_binding_values/src/module.rs

@@ -4,9 +4,9 @@ use napi::JsString;
 use napi_derive::napi;
 use rspack_collections::IdentifierMap;
 use rspack_core::{
-  BuildMeta, BuildMetaDefaultObject, BuildMetaExportsType, Compilation, CompilationId,
-  ExportsArgument, LibIdentOptions, Module, ModuleArgument, ModuleIdentifier, RuntimeModuleStage,
-  SourceType,
+  BuildMeta, BuildMetaDefaultObject, BuildMetaExportsType, Compilation, CompilationAsset,
+  CompilationId, ExportsArgument, LibIdentOptions, Module, ModuleArgument, ModuleIdentifier,
+  RuntimeModuleStage, SourceType,
 };
 use rspack_napi::{napi::bindgen_prelude::*, threadsafe_function::ThreadsafeFunction, OneShotRef};
 use rspack_plugin_runtime::RuntimeModuleFromJs;
@@ -15,7 +15,7 @@ use rustc_hash::FxHashMap as HashMap;
 
 use super::JsCompatSourceOwned;
 use crate::{
-  JsChunkWrapper, JsCodegenerationResults, JsCompatSource, JsDependenciesBlockWrapper,
+  JsAssetInfo, JsChunkWrapper, JsCodegenerationResults, JsCompatSource, JsDependenciesBlockWrapper,
   JsDependencyWrapper, JsResourceData, ToJsCompatSource,
 };
 
@@ -325,6 +325,22 @@ impl JsModule {
       None => Either::B(()),
     })
   }
+
+  #[napi]
+  pub fn emit_file(
+    &mut self,
+    filename: String,
+    source: JsCompatSource,
+    asset_info: JsAssetInfo,
+  ) -> napi::Result<()> {
+    let module = self.as_mut()?;
+
+    module.build_info_mut().assets.insert(
+      filename,
+      CompilationAsset::new(Some(source.into()), asset_info.into()),
+    );
+    Ok(())
+  }
 }
 
 type ModuleInstanceRefs = IdentifierMap<OneShotRef<JsModule>>;

crates/rspack_cacheable/src/with/as_preset/serde_json.rs

@@ -5,7 +5,7 @@ use rkyv::{
   with::{ArchiveWith, DeserializeWith, SerializeWith},
   Place,
 };
-use serde_json::Value;
+use serde_json::{Map, Value};
 
 use super::AsPreset;
 use crate::{DeserializeError, SerializeError};
@@ -15,6 +15,7 @@ pub struct SerdeJsonResolver {
   value: String,
 }
 
+// for Value
 impl ArchiveWith<Value> for AsPreset {
   type Archived = ArchivedString;
   type Resolver = SerdeJsonResolver;
@@ -49,3 +50,49 @@ where
       .map_err(|_| DeserializeError::MessageError("deserialize serde_json value failed"))
   }
 }
+
+// for Map<String, Value>
+impl ArchiveWith<Map<String, Value>> for AsPreset {
+  type Archived = ArchivedString;
+  type Resolver = SerdeJsonResolver;
+
+  #[inline]
+  fn resolve_with(
+    _field: &Map<String, Value>,
+    resolver: Self::Resolver,
+    out: Place<Self::Archived>,
+  ) {
+    let SerdeJsonResolver { inner, value } = resolver;
+    ArchivedString::resolve_from_str(&value, inner, out);
+  }
+}
+
+impl<S> SerializeWith<Map<String, Value>, S> for AsPreset
+where
+  S: Fallible<Error = SerializeError> + Writer,
+{
+  #[inline]
+  fn serialize_with(
+    field: &Map<String, Value>,
+    serializer: &mut S,
+  ) -> Result<Self::Resolver, SerializeError> {
+    let value = serde_json::to_string(field)
+      .map_err(|_| SerializeError::MessageError("serialize serde_json value failed"))?;
+    let inner = ArchivedString::serialize_from_str(&value, serializer)?;
+    Ok(SerdeJsonResolver { value, inner })
+  }
+}
+
+impl<D> DeserializeWith<ArchivedString, Map<String, Value>, D> for AsPreset
+where
+  D: Fallible<Error = DeserializeError>,
+{
+  #[inline]
+  fn deserialize_with(
+    field: &ArchivedString,
+    _: &mut D,
+  ) -> Result<Map<String, Value>, DeserializeError> {
+    serde_json::from_str(field)
+      .map_err(|_| DeserializeError::MessageError("deserialize serde_json value failed"))
+  }
+}

crates/rspack_core/src/compiler/compilation.rs

@@ -12,7 +12,10 @@ use dashmap::DashSet;
 use indexmap::{IndexMap, IndexSet};
 use itertools::Itertools;
 use rayon::prelude::*;
-use rspack_cacheable::cacheable;
+use rspack_cacheable::{
+  cacheable,
+  with::{AsOption, AsPreset},
+};
 use rspack_collections::{
   DatabaseItem, Identifiable, IdentifierDashMap, IdentifierMap, IdentifierSet, UkeyMap, UkeySet,
 };
@@ -173,7 +176,6 @@ pub struct Compilation {
   pub entrypoints: IndexMap<String, ChunkGroupUkey>,
   pub async_entrypoints: Vec<ChunkGroupUkey>,
   assets: CompilationAssets,
-  pub module_assets: IdentifierMap<HashSet<String>>,
   pub emitted_assets: DashSet<String, BuildHasherDefault<FxHasher>>,
   diagnostics: Vec<Diagnostic>,
   logging: CompilationLogging,
@@ -296,7 +298,6 @@ impl Compilation {
       entrypoints: Default::default(),
       async_entrypoints: Default::default(),
       assets: Default::default(),
-      module_assets: Default::default(),
       emitted_assets: Default::default(),
       diagnostics: Default::default(),
       logging: Default::default(),
@@ -618,7 +619,6 @@ impl Compilation {
     filename: &str,
     updater: impl FnOnce(BoxSource, AssetInfo) -> Result<(BoxSource, AssetInfo)>,
   ) -> Result<()> {
-    // Safety: we don't move anything from compilation
     let assets = &mut self.assets;
 
     let (new_source, new_info) = match assets.remove(filename) {
@@ -996,29 +996,39 @@ impl Compilation {
 
   #[instrument("Compilation:create_module_assets", skip_all)]
   async fn create_module_assets(&mut self, _plugin_driver: SharedPluginDriver) {
-    let mut temp = vec![];
-    for (module_identifier, assets) in self.module_assets.iter() {
+    let mut chunk_asset_map = vec![];
+    let mut module_assets = vec![];
+    let mg = self.get_module_graph();
+    for (identifier, module) in mg.modules() {
+      let assets = &module.build_info().assets;
+      if assets.is_empty() {
+        continue;
+      }
+
+      for (name, asset) in assets {
+        module_assets.push((name.clone(), asset.clone()));
+      }
       // assets of executed modules are not in this compilation
       if self
         .chunk_graph
         .chunk_graph_module_by_module_identifier
-        .contains_key(module_identifier)
+        .contains_key(&identifier)
       {
-        for chunk in self
-          .chunk_graph
-          .get_module_chunks(*module_identifier)
-          .iter()
-        {
-          for asset in assets {
-            temp.push((*chunk, asset.clone()))
+        for chunk in self.chunk_graph.get_module_chunks(identifier).iter() {
+          for name in assets.keys() {
+            chunk_asset_map.push((*chunk, name.clone()))
           }
         }
       }
     }
 
-    for (chunk, asset) in temp {
+    for (name, asset) in module_assets {
+      self.emit_asset(name, asset);
+    }
+
+    for (chunk, asset_name) in chunk_asset_map {
       let chunk = self.chunk_by_ukey.expect_get_mut(&chunk);
-      chunk.add_auxiliary_file(asset);
+      chunk.add_auxiliary_file(asset_name);
     }
   }
 
@@ -2260,8 +2270,10 @@ impl Compilation {
 
 pub type CompilationAssets = HashMap<String, CompilationAsset>;
 
+#[cacheable]
 #[derive(Debug, Clone)]
 pub struct CompilationAsset {
+  #[cacheable(with=AsOption<AsPreset>)]
   pub source: Option<BoxSource>,
   pub info: AssetInfo,
 }
@@ -2302,6 +2314,7 @@ impl CompilationAsset {
   }
 }
 
+#[cacheable]
 #[derive(Debug, Default, Clone)]
 pub struct AssetInfo {
   /// if the asset can be long term cached forever (contains a hash)
@@ -2339,6 +2352,7 @@ pub struct AssetInfo {
   /// But Napi.rs does not support Intersectiont types. This is a hack to store the additional fields
   /// in the rust struct and have the Js side to reshape and align with webpack.
   /// Related: packages/rspack/src/Compilation.ts
+  #[cacheable(with=AsPreset)]
   pub extras: serde_json::Map<String, serde_json::Value>,
   /// whether this asset is over the size limit
   pub is_over_size_limit: Option<bool>,
@@ -2437,6 +2451,7 @@ impl AssetInfo {
   }
 }
 
+#[cacheable]
 #[derive(Debug, Default, Clone)]
 pub struct AssetInfoRelated {
   pub source_map: Option<String>,

crates/rspack_core/src/compiler/module_executor/execute.rs

@@ -37,7 +37,6 @@ pub struct ExecuteModuleResult {
   pub missing_dependencies: HashSet<ArcPath>,
   pub build_dependencies: HashSet<ArcPath>,
   pub code_generated_modules: IdentifierSet,
-  pub assets: HashSet<String>,
   pub id: ExecuteModuleId,
 }
 
@@ -82,14 +81,19 @@ impl Task<MakeTaskContext> for ExecuteTask {
       .expect("should have module")
       .identifier();
     let mut queue = vec![entry_module_identifier];
+    let mut assets = CompilationAssets::default();
     let mut modules = IdentifierSet::default();
 
     while let Some(m) = queue.pop() {
       modules.insert(m);
-      for m in mg.get_outgoing_connections(&m) {
+      let module = mg.module_by_identifier(&m).expect("should have module");
+      for (name, asset) in &module.build_info().assets {
+        assets.insert(name.clone(), asset.clone());
+      }
+      for c in mg.get_outgoing_connections(&m) {
         // TODO: handle circle
-        if !modules.contains(m.module_identifier()) {
-          queue.push(*m.module_identifier());
+        if !modules.contains(c.module_identifier()) {
+          queue.push(*c.module_identifier());
         }
       }
     }
@@ -263,18 +267,8 @@ impl Task<MakeTaskContext> for ExecuteTask {
       }
     };
 
-    let assets = std::mem::take(compilation.assets_mut());
+    assets.extend(std::mem::take(compilation.assets_mut()));
     let code_generated_modules = std::mem::take(&mut compilation.code_generated_modules);
-    let module_assets = std::mem::take(&mut compilation.module_assets);
-    if execute_result.error.is_none() {
-      execute_result.assets = assets.keys().cloned().collect::<HashSet<_>>();
-      execute_result.assets.extend(
-        module_assets
-          .values()
-          .flat_map(|m| m.iter().map(|i| i.to_owned()).collect_vec())
-          .collect::<HashSet<String>>(),
-      );
-    }
     let executed_runtime_modules = runtime_modules
       .iter()
       .map(|runtime_id| {