perf: use module_graphe instead of stats

2heal1 · 2heal1 · commit 671e6494e7ea · 2025-10-16T20:10:43.000+08:00
diff --git a/crates/rspack_plugin_mf/src/manifest/mod.rs b/crates/rspack_plugin_mf/src/manifest/mod.rs
@@ -5,8 +5,6 @@ mod data;
 mod options;
 mod utils;
 
-use std::cell::RefCell;
-
 use asset::{
   collect_assets_for_module, collect_assets_from_chunk, collect_usage_files_for_module,
   empty_assets_group, merge_assets_group, normalize_assets_group, promote_primary_assets_to_sync,
@@ -22,8 +20,8 @@ pub use options::{
   RemoteAliasTarget,
 };
 use rspack_core::{
-  Compilation, CompilationAsset, CompilationProcessAssets, ExtendedStatsOptions, ModuleIdentifier,
-  Plugin, PublicPath, Stats as CoreStats,
+  Compilation, CompilationAsset, CompilationProcessAssets, ModuleIdentifier, ModuleType, Plugin,
+  PublicPath,
   rspack_sources::{RawStringSource, SourceExt},
 };
 use rspack_error::Result;
@@ -199,138 +197,109 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
       .collect::<Vec<_>>();
     (exposes, shared, remote_list)
   } else {
-    // Collect stats from module graph via Stats API
-    let stats = CoreStats::new(&*compilation);
-    let options: ExtendedStatsOptions = ExtendedStatsOptions {
-      modules: true,
-      reasons: true,
-      ids: true,
-      assets: false,
-      chunks: false,
-      entrypoints: rspack_core::EntrypointsStatsOption::Bool(true),
-      cached_modules: true,
-      hash: true,
-      chunk_relations: false,
-      chunk_groups: false,
-      chunk_group_auxiliary: false,
-      chunk_group_children: false,
-      chunk_modules: false,
-      depth: false,
-      module_assets: false,
-      nested_modules: false,
-      optimization_bailout: false,
-      provided_exports: false,
-      source: false,
-      used_exports: false,
-      warnings: false,
-      errors: false,
-    };
-    // Gather modules
-    let exposes_map = RefCell::new(HashMap::<String, StatsExpose>::default());
-    let shared_map = RefCell::new(HashMap::<String, StatsShared>::default());
-    let shared_usage_links = RefCell::new(Vec::<(String, String)>::new());
-    let provide_module_ids = RefCell::new(HashMap::<String, Vec<ModuleIdentifier>>::default());
-    let consume_module_ids = RefCell::new(HashMap::<String, Vec<ModuleIdentifier>>::default());
-    let remote_module_ids = RefCell::new(Vec::<ModuleIdentifier>::new());
-    let container_entry_module = RefCell::new(None::<ModuleIdentifier>);
-    let module_ids_by_name = RefCell::new(HashMap::<String, ModuleIdentifier>::default());
-    let self_issued_module_ids = RefCell::new(HashMap::<String, ModuleIdentifier>::default());
-    stats.get_modules(&options, |modules| {
-      for m in modules {
-        let module_identifier = match m.identifier {
-          Some(id) => id.clone(),
-          None => continue,
-        };
-        let identifier = module_identifier.to_string();
-        let module_type = m.module_type.as_str();
-        if let Some(name) = m.name.as_ref() {
-          module_ids_by_name
-            .borrow_mut()
-            .insert(name.to_string(), module_identifier.clone());
-          if let Some(issuer_name) = m.issuer_name.as_ref()
-            && issuer_name.as_ref() == name.as_ref()
-          {
-            self_issued_module_ids
-              .borrow_mut()
-              .insert(name.to_string(), module_identifier.clone());
+    let module_graph = compilation.get_module_graph();
+    let context = &compilation.options.context;
+
+    let mut exposes_map: HashMap<String, StatsExpose> = HashMap::default();
+    let mut shared_map: HashMap<String, StatsShared> = HashMap::default();
+    let mut shared_usage_links: Vec<(String, String)> = Vec::new();
+    let mut consume_module_ids: HashMap<String, Vec<ModuleIdentifier>> = HashMap::default();
+    let mut remote_module_ids: Vec<ModuleIdentifier> = Vec::new();
+    let mut container_entry_module: Option<ModuleIdentifier> = None;
+    let mut module_ids_by_name: HashMap<String, ModuleIdentifier> = HashMap::default();
+    let mut self_issued_module_ids: HashMap<String, ModuleIdentifier> = HashMap::default();
+
+    for (module_id, module) in module_graph.modules().into_iter() {
+      let module_identifier = module_id;
+      let module_name = module.readable_identifier(context).to_string();
+      if !module_name.is_empty() {
+        module_ids_by_name.insert(module_name.clone(), module_identifier);
+        if let Some(issuer_module) = module_graph.get_issuer(&module_identifier) {
+          let issuer_name = issuer_module.readable_identifier(context).to_string();
+          if issuer_name == module_name {
+            self_issued_module_ids.insert(issuer_name, module_identifier);
           }
         }
-        if identifier.starts_with("container entry") {
-          *container_entry_module.borrow_mut() = Some(module_identifier.clone());
-          if let Some(exposes) = parse_container_exposes_from_identifier(&identifier) {
-            let mut exposes_map_ref = exposes_map.borrow_mut();
-            for (expose_key, import_name, import_file) in exposes {
-              let name =
-                import_name.unwrap_or_else(|| expose_key.trim_start_matches("./").to_string());
-              let id_comp = compose_id_with_separator(&container_name, &name);
-              let expose_file_key = strip_ext(&import_file);
-              exposes_map_ref
-                .entry(expose_file_key.clone())
-                .or_insert(StatsExpose {
-                  path: expose_key.clone(),
-                  id: id_comp,
-                  name: name.clone(),
-                  requires: Vec::new(),
-                  assets: StatsAssetsGroup::default(),
-                });
-            }
+      }
+
+      let module_type = module.module_type();
+      let identifier = module_identifier.to_string();
+
+      if identifier.starts_with("container entry") {
+        container_entry_module = Some(module_identifier);
+        if let Some(exposes) = parse_container_exposes_from_identifier(&identifier) {
+          for (expose_key, import_name, import_file) in exposes {
+            let expose_name = import_name
+              .filter(|name| !name.is_empty())
+              .unwrap_or_else(|| expose_key.trim_start_matches("./").to_string());
+            let id_comp = compose_id_with_separator(&container_name, &expose_name);
+            let expose_file_key = strip_ext(&import_file);
+            exposes_map.entry(expose_file_key).or_insert(StatsExpose {
+              path: expose_key.clone(),
+              id: id_comp,
+              name: expose_name,
+              requires: Vec::new(),
+              assets: StatsAssetsGroup::default(),
+            });
           }
         }
-        if identifier.starts_with("remote ") {
-          remote_module_ids
-            .borrow_mut()
-            .push(module_identifier.clone());
+        continue;
+      }
+
+      if matches!(module_type, ModuleType::Remote) {
+        remote_module_ids.push(module_identifier);
+      }
+
+      if matches!(module_type, ModuleType::ProvideShared) {
+        if let Some((pkg, ver)) = parse_provide_shared_identifier(&identifier) {
+          let entry = ensure_shared_entry(&mut shared_map, &container_name, &pkg);
+          if entry.version.is_empty() {
+            entry.version = ver;
+          }
+          record_shared_usage(
+            &mut shared_usage_links,
+            &pkg,
+            &module_identifier,
+            &module_graph,
+            compilation,
+          );
         }
-        if module_type == "provide-module" {
-          if let Some((pkg, ver)) = parse_provide_shared_identifier(&identifier) {
-            provide_module_ids
-              .borrow_mut()
-              .entry(pkg.clone())
-              .or_default()
-              .push(module_identifier.clone());
-            let mut shared_map_ref = shared_map.borrow_mut();
-            let entry = ensure_shared_entry(&mut *shared_map_ref, &container_name, &pkg);
-            if entry.version.is_empty() {
-              entry.version = ver;
+        continue;
+      }
+
+      if matches!(module_type, ModuleType::ConsumeShared) {
+        if let Some((pkg, required)) = parse_consume_shared_identifier(&identifier) {
+          let mut target_ids: Vec<ModuleIdentifier> = Vec::new();
+          if let Some(issuer_module) = module_graph.get_issuer(&module_identifier) {
+            let issuer_name = issuer_module.readable_identifier(context).to_string();
+            if let Some(target) = self_issued_module_ids.get(&issuer_name) {
+              target_ids.push(*target);
+            } else if let Some(target) = module_ids_by_name.get(&issuer_name) {
+              target_ids.push(*target);
             }
-            drop(shared_map_ref);
-            record_shared_usage(&shared_usage_links, &pkg, &m);
           }
-        } else if module_type == "consume-shared-module" {
-          if let Some((pkg, required)) = parse_consume_shared_identifier(&identifier) {
-            let mut target_ids: Vec<ModuleIdentifier> = Vec::new();
-            if let Some(issuer_name) = m.issuer_name.as_ref() {
-              if let Some(target) = self_issued_module_ids.borrow().get(issuer_name.as_ref()) {
-                target_ids.push(target.clone());
-              } else if let Some(target) = module_ids_by_name.borrow().get(issuer_name.as_ref()) {
-                target_ids.push(target.clone());
-              }
-            }
-            if target_ids.is_empty() {
-              target_ids.push(module_identifier.clone());
-            }
-            consume_module_ids
-              .borrow_mut()
-              .entry(pkg.clone())
-              .or_default()
-              .extend(target_ids);
-            let mut shared_map_ref = shared_map.borrow_mut();
-            let entry = ensure_shared_entry(&mut *shared_map_ref, &container_name, &pkg);
-            if entry.requiredVersion.is_none() && required.is_some() {
-              entry.requiredVersion = required;
-            }
-            drop(shared_map_ref);
-            record_shared_usage(&shared_usage_links, &pkg, &m);
+          if target_ids.is_empty() {
+            target_ids.push(module_identifier);
           }
+          consume_module_ids
+            .entry(pkg.clone())
+            .or_default()
+            .extend(target_ids);
+          let entry = ensure_shared_entry(&mut shared_map, &container_name, &pkg);
+          if entry.requiredVersion.is_none() && required.is_some() {
+            entry.requiredVersion = required;
+          }
+          record_shared_usage(
+            &mut shared_usage_links,
+            &pkg,
+            &module_identifier,
+            &module_graph,
+            compilation,
+          );
         }
       }
-    })?;
-    let mut exposes_map = exposes_map.into_inner();
-    let mut shared_map = shared_map.into_inner();
-    let consume_module_ids = consume_module_ids.into_inner();
-    let remote_module_ids = remote_module_ids.into_inner();
-    let container_entry_module = container_entry_module.into_inner();
-    let shared_usage_links = shared_usage_links.into_inner();
+    }
+
     collect_expose_requirements(&mut shared_map, &mut exposes_map, shared_usage_links);
 
     let mut aggregated_shared_assets: HashMap<String, StatsAssetsGroup> = HashMap::default();
diff --git a/crates/rspack_plugin_mf/src/manifest/utils.rs b/crates/rspack_plugin_mf/src/manifest/utils.rs
@@ -1,7 +1,8 @@
-use std::{cell::RefCell, path::Path};
+use std::path::Path;
 
-use rspack_core::StatsModule;
+use rspack_core::{Compilation, ModuleGraph, ModuleIdentifier};
 use rspack_util::fx_hash::FxHashMap as HashMap;
+use serde_json::Value;
 
 use super::data::{StatsExpose, StatsShared};
 
@@ -53,7 +54,7 @@ pub fn parse_container_exposes_from_identifier(
   }
   let end = end_idx?;
   let json_str = &slice[..=end];
-  let val: serde_json::Value = serde_json::from_str(json_str).ok()?;
+  let val: Value = serde_json::from_str(json_str).ok()?;
   let arr = val.as_array()?;
   let mut ret: Vec<(String, Option<String>, String)> = Vec::new();
   for item in arr {
@@ -98,20 +99,41 @@ pub fn ensure_shared_entry<'a>(
     })
 }
 
-pub fn record_shared_usage<'a>(
-  shared_usage_links: &RefCell<Vec<(String, String)>>,
+pub fn record_shared_usage(
+  shared_usage_links: &mut Vec<(String, String)>,
   pkg: &str,
-  module: &StatsModule<'a>,
+  module_identifier: &ModuleIdentifier,
+  module_graph: &ModuleGraph,
+  compilation: &Compilation,
 ) {
-  if let Some(issuer_name) = module.issuer_name.as_ref() {
-    let key = strip_ext(issuer_name);
-    shared_usage_links.borrow_mut().push((pkg.to_string(), key));
+  if let Some(issuer_module) = module_graph.get_issuer(module_identifier) {
+    let issuer_name = issuer_module
+      .readable_identifier(&compilation.options.context)
+      .to_string();
+    if !issuer_name.is_empty() {
+      let key = strip_ext(&issuer_name);
+      shared_usage_links.push((pkg.to_string(), key));
+    }
   }
-  if let Some(reasons) = module.reasons.as_ref() {
-    for reason in reasons {
-      if let Some(module_name) = reason.user_request {
-        let key = strip_ext(module_name);
-        shared_usage_links.borrow_mut().push((pkg.to_string(), key));
+  if let Some(mgm) = module_graph.module_graph_module_by_identifier(module_identifier) {
+    for dep_id in mgm.incoming_connections() {
+      let Some(connection) = module_graph.connection_by_dependency_id(dep_id) else {
+        continue;
+      };
+      let Some(dependency) = module_graph.dependency_by_id(&connection.dependency_id) else {
+        continue;
+      };
+      let maybe_request = dependency
+        .as_module_dependency()
+        .map(|dep| dep.user_request().to_string())
+        .or_else(|| {
+          dependency
+            .as_context_dependency()
+            .map(|dep| dep.request().to_string())
+        });
+      if let Some(request) = maybe_request {
+        let key = strip_ext(&request);
+        shared_usage_links.push((pkg.to_string(), key));
       }
     }
   }
diff --git a/packages/rspack/src/container/ModuleFederationManifestPlugin.ts b/packages/rspack/src/container/ModuleFederationManifestPlugin.ts
@@ -256,6 +256,8 @@ export class ModuleFederationManifestPlugin extends RspackBuiltinPlugin {
 
 		compiler.hooks.thisCompilation.tap(this.name, compilation => {
 			compilation.hooks.afterProcessAssets.tap(this.name, () => {
+				if (typeof this.opts.additionalData !== "function") return;
+
 				const manifestAsset = compilation.getAsset(manifestFileName);
 				const statsAsset = compilation.getAsset(statsFileName);
 				if (!manifestAsset || !statsAsset) {
@@ -264,26 +266,16 @@ export class ModuleFederationManifestPlugin extends RspackBuiltinPlugin {
 				const manifestStr = toStringSource(manifestAsset.source);
 				const statsStr = toStringSource(statsAsset.source);
 				if (!manifestStr || !statsStr) return;
-				let manifest: Manifest;
-				let stats: Stats;
-				try {
-					manifest = JSON.parse(manifestStr);
-					stats = JSON.parse(statsStr);
-				} catch (_e) {
-					return;
-				}
-				if (typeof this.opts.additionalData !== "function") return;
-				try {
-					this.opts.additionalData({
-						stats,
-						manifest,
-						compilation,
-						compiler,
-						bundler: "rspack"
-					});
-				} catch (_e) {
-					return;
-				}
+
+				const manifest: Manifest = JSON.parse(manifestStr);
+				const stats: Stats = JSON.parse(statsStr);
+				this.opts.additionalData({
+					stats,
+					manifest,
+					compilation,
+					compiler,
+					bundler: "rspack"
+				});
 
 				compilation.updateAsset(
 					manifestFileName,
diff --git a/tests/rspack-test/configCases/container-1-5/manifest-disable-assets-analyze/rspack.config.js b/tests/rspack-test/configCases/container-1-5/manifest-disable-assets-analyze/rspack.config.js
@@ -27,10 +27,7 @@ module.exports = {
 			manifest: {
 				disableAssetsAnalyze: true,
 				additionalData({ manifest }) {
-					return {
-						...manifest,
-						extra: true
-					};
+					manifest.extra = true
 				}
 			}
 		})
diff --git a/tests/rspack-test/configCases/container-1-5/manifest-file-name/rspack.config.js b/tests/rspack-test/configCases/container-1-5/manifest-file-name/rspack.config.js
@@ -28,10 +28,7 @@ module.exports = {
 				fileName: "custom-manifest.json",
 				filePath:'custom-path',
 				additionalData({ manifest }) {
-					return {
-						...manifest,
-						extra: true
-					};
+					manifest.extra = true
 				}
 			}
 		})
diff --git a/tests/rspack-test/configCases/container-1-5/manifest/rspack.config.js b/tests/rspack-test/configCases/container-1-5/manifest/rspack.config.js

Original file line number	Diff line number	Diff line change
`@@ -27,10 +27,7 @@ module.exports = {`
`27`	`27`	`manifest: {`
`28`	`28`	`disableAssetsAnalyze: true,`
`29`	`29`	`additionalData({ manifest }) {`
`30`		`- return {`
`31`		`- ...manifest,`
`32`		`- extra: true`
`33`		`- };`
	`30`	`+ manifest.extra = true`
`34`	`31`	`}`
`35`	`32`	`}`
`36`	`33`	`})`
Original file line number	Diff line number	Diff line change
`@@ -28,10 +28,7 @@ module.exports = {`
`28`	`28`	`fileName: "custom-manifest.json",`
`29`	`29`	`filePath:'custom-path',`
`30`	`30`	`additionalData({ manifest }) {`
`31`		`- return {`
`32`		`- ...manifest,`
`33`		`- extra: true`
`34`		`- };`
	`31`	`+ manifest.extra = true`
`35`	`32`	`}`
`36`	`33`	`}`
`37`	`34`	`})`