feat: add build time executed modules to stats (#6829)

* feat: add build time executed modules

* feat: add build time executed runtime modules

crates/node_binding/binding.d.ts

@@ -556,6 +556,7 @@ export interface JsStatsModule {
   postOrderIndex?: number
   built: boolean
   codeGenerated: boolean
+  buildTimeExecuted: boolean
   cached: boolean
   cacheable: boolean
   optional: boolean

crates/rspack_binding_values/src/stats.rs

@@ -245,6 +245,7 @@ pub struct JsStatsModule {
   pub post_order_index: Option<u32>,
   pub built: bool,
   pub code_generated: bool,
+  pub build_time_executed: bool,
   pub cached: bool,
   pub cacheable: bool,
   pub optional: bool,
@@ -316,6 +317,7 @@ impl TryFrom<rspack_core::StatsModule<'_>> for JsStatsModule {
       post_order_index: stats.post_order_index,
       built: stats.built,
       code_generated: stats.code_generated,
+      build_time_executed: stats.build_time_executed,
       cached: stats.cached,
       cacheable: stats.cacheable,
       optional: stats.optional,

crates/rspack_core/src/compiler/compilation.rs

@@ -157,6 +157,7 @@ pub struct Compilation {
   pub code_generation_results: CodeGenerationResults,
   pub built_modules: IdentifierSet,
   pub code_generated_modules: IdentifierSet,
+  pub build_time_executed_modules: IdentifierSet,
   pub old_cache: Arc<OldCache>,
   pub code_splitting_cache: CodeSplittingCache,
   pub hash: Option<RspackHashDigest>,
@@ -238,6 +239,7 @@ impl Compilation {
       code_generation_results: Default::default(),
       built_modules: Default::default(),
       code_generated_modules: Default::default(),
+      build_time_executed_modules: Default::default(),
       old_cache,
       code_splitting_cache: Default::default(),
       hash: None,
@@ -1002,7 +1004,9 @@ impl Compilation {
     }
 
     // take built_modules
-    self.built_modules = self.make_artifact.take_built_modules();
+    self
+      .built_modules
+      .extend(self.make_artifact.take_built_modules());
     Ok(())
   }
 

crates/rspack_core/src/compiler/make/mod.rs

@@ -33,10 +33,10 @@ pub struct MakeArtifact {
 }
 
 impl MakeArtifact {
-  fn get_module_graph(&self) -> ModuleGraph {
+  pub fn get_module_graph(&self) -> ModuleGraph {
     ModuleGraph::new(vec![&self.module_graph_partial], None)
   }
-  fn get_module_graph_mut(&mut self) -> ModuleGraph {
+  pub fn get_module_graph_mut(&mut self) -> ModuleGraph {
     ModuleGraph::new(vec![], Some(&mut self.module_graph_partial))
   }
   // TODO remove it

crates/rspack_core/src/compiler/mod.rs

@@ -16,7 +16,7 @@ use tracing::instrument;
 
 pub use self::compilation::*;
 pub use self::hmr::{collect_changed_modules, CompilationRecords};
-pub use self::module_executor::{ExecuteModuleId, ModuleExecutor};
+pub use self::module_executor::{ExecuteModuleId, ExecutedRuntimeModule, ModuleExecutor};
 use crate::old_cache::Cache as OldCache;
 use crate::{
   fast_set, BoxPlugin, CompilerOptions, Logger, PluginDriver, ResolverFactory, SharedPluginDriver,

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

@@ -1,8 +1,10 @@
 use std::{iter::once, sync::atomic::AtomicU32};
 
+use itertools::Itertools;
 use rayon::prelude::*;
 use rspack_error::Result;
-use rspack_identifier::IdentifierSet;
+use rspack_identifier::{Identifier, IdentifierSet};
+use rustc_hash::FxHashMap as HashMap;
 use rustc_hash::FxHashSet as HashSet;
 use tokio::{runtime::Handle, sync::oneshot::Sender};
 
@@ -12,9 +14,19 @@ use crate::{
   utils::task_loop::{Task, TaskResult, TaskType},
   Chunk, ChunkGraph, ChunkKind, CodeGenerationDataAssetInfo, CodeGenerationDataFilename,
   CodeGenerationResult, CompilationAsset, CompilationAssets, DependencyId, EntryOptions,
-  Entrypoint, RuntimeSpec, SourceType,
+  Entrypoint, ModuleType, RuntimeSpec, SourceType,
 };
 
+#[derive(Debug, Clone)]
+pub struct ExecutedRuntimeModule {
+  pub identifier: Identifier,
+  pub name: String,
+  pub name_for_condition: Option<String>,
+  pub module_type: ModuleType,
+  pub size: f64,
+  pub cacheable: bool,
+}
+
 static EXECUTE_MODULE_ID: AtomicU32 = AtomicU32::new(0);
 pub type ExecuteModuleId = u32;
 
@@ -25,6 +37,7 @@ pub struct ExecuteModuleResult {
   pub context_dependencies: HashSet<std::path::PathBuf>,
   pub missing_dependencies: HashSet<std::path::PathBuf>,
   pub build_dependencies: HashSet<std::path::PathBuf>,
+  pub code_generated_modules: IdentifierSet,
   pub assets: HashSet<String>,
   pub id: ExecuteModuleId,
 }
@@ -34,7 +47,12 @@ pub struct ExecuteTask {
   pub entry_dep_id: DependencyId,
   pub public_path: Option<String>,
   pub base_uri: Option<String>,
-  pub result_sender: Sender<(Result<ExecuteModuleResult>, CompilationAssets)>,
+  pub result_sender: Sender<(
+    Result<ExecuteModuleResult>,
+    CompilationAssets,
+    IdentifierSet,
+    Vec<ExecutedRuntimeModule>,
+  )>,
 }
 
 impl Task<MakeTaskContext> for ExecuteTask {
@@ -143,7 +161,16 @@ impl Task<MakeTaskContext> for ExecuteTask {
     // replace code_generation_results is the same reason
     compilation.chunk_graph = chunk_graph;
 
-    compilation.code_generation_modules(&mut None, false, modules.par_iter().copied())?;
+    let code_generation_results =
+      compilation.code_generation_modules(&mut None, false, modules.par_iter().copied())?;
+
+    code_generation_results
+      .iter()
+      .for_each(|module_identifier| {
+        compilation
+          .code_generated_modules
+          .insert(*module_identifier);
+      });
 
     Handle::current().block_on(async {
       compilation
@@ -170,14 +197,19 @@ impl Task<MakeTaskContext> for ExecuteTask {
         .collect::<Vec<_>>()
     );
 
+    let mut runtime_module_size = HashMap::default();
     for runtime_id in &runtime_modules {
       let runtime_module = compilation
         .runtime_modules
         .get(runtime_id)
         .expect("runtime module exist");
 
-      let result =
-        CodeGenerationResult::default().with_javascript(runtime_module.generate(&compilation)?);
+      let runtime_module_source = runtime_module.generate(&compilation)?;
+      runtime_module_size.insert(
+        runtime_module.identifier(),
+        runtime_module_source.size() as f64,
+      );
+      let result = CodeGenerationResult::default().with_javascript(runtime_module_source);
       let result_id = result.id;
 
       compilation
@@ -187,6 +219,9 @@ impl Task<MakeTaskContext> for ExecuteTask {
       compilation
         .code_generation_results
         .add(*runtime_id, runtime.clone(), result_id);
+      compilation
+        .code_generated_modules
+        .insert(runtime_module.identifier());
     }
 
     let codegen_results = compilation.code_generation_results.clone();
@@ -257,12 +292,39 @@ impl Task<MakeTaskContext> for ExecuteTask {
     };
 
     let assets = std::mem::take(compilation.assets_mut());
+    let code_generated_modules = std::mem::take(&mut compilation.code_generated_modules);
     if let Ok(ref mut result) = execute_result {
       result.assets = assets.keys().cloned().collect::<HashSet<_>>();
     }
+    let executed_runtime_modules = runtime_modules
+      .iter()
+      .map(|runtime_id| {
+        let runtime_module = compilation
+          .runtime_modules
+          .get(runtime_id)
+          .expect("runtime module exist");
+        let identifier = runtime_module.identifier();
+        ExecutedRuntimeModule {
+          identifier,
+          name: runtime_module.name().to_string(),
+          name_for_condition: runtime_module.name_for_condition().map(|n| n.to_string()),
+          module_type: *runtime_module.module_type(),
+          cacheable: runtime_module.cacheable(),
+          size: runtime_module_size
+            .get(&identifier)
+            .map(|s| s.to_owned())
+            .unwrap_or(0 as f64),
+        }
+      })
+      .collect_vec();
     context.recovery_from_temp_compilation(compilation);
     result_sender
-      .send((execute_result, assets))
+      .send((
+        execute_result,
+        assets,
+        code_generated_modules,
+        executed_runtime_modules,
+      ))
       .expect("should send result success");
     Ok(vec![])
   }

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

@@ -3,10 +3,12 @@ mod entry;
 mod execute;
 mod overwrite;
 
-use dashmap::mapref::entry::Entry;
 use dashmap::DashMap;
+use dashmap::{mapref::entry::Entry, DashSet};
 pub use execute::ExecuteModuleId;
+pub use execute::ExecutedRuntimeModule;
 use rspack_error::Result;
+use rspack_identifier::Identifier;
 use tokio::sync::{
   mpsc::{unbounded_channel, UnboundedSender},
   oneshot,
@@ -32,6 +34,8 @@ pub struct ModuleExecutor {
   event_sender: Option<UnboundedSender<Event>>,
   stop_receiver: Option<oneshot::Receiver<MakeArtifact>>,
   assets: DashMap<String, CompilationAsset>,
+  code_generated_modules: DashSet<Identifier>,
+  pub executed_runtime_modules: DashMap<Identifier, ExecutedRuntimeModule>,
 }
 
 impl ModuleExecutor {
@@ -107,6 +111,16 @@ impl ModuleExecutor {
 
     let diagnostics = self.make_artifact.take_diagnostics();
     compilation.extend_diagnostics(diagnostics);
+
+    let built_modules = self.make_artifact.take_built_modules();
+    for id in built_modules {
+      compilation.built_modules.insert(id);
+    }
+
+    let code_generated_modules = std::mem::take(&mut self.code_generated_modules);
+    for id in code_generated_modules {
+      compilation.code_generated_modules.insert(id);
+    }
   }
 
   #[allow(clippy::too_many_arguments)]
@@ -149,12 +163,23 @@ impl ModuleExecutor {
         },
       ))
       .expect("should success");
-    let (execute_result, assets) = rx.await.expect("should receiver success");
+    let (execute_result, assets, code_generated_modules, executed_runtime_modules) =
+      rx.await.expect("should receiver success");
 
     for (key, value) in assets {
       self.assets.insert(key, value);
     }
 
+    for id in code_generated_modules {
+      self.code_generated_modules.insert(id);
+    }
+
+    for runtime_module in executed_runtime_modules {
+      self
+        .executed_runtime_modules
+        .insert(runtime_module.identifier, runtime_module);
+    }
+
     execute_result
   }
 }