feat: allow ModuleFactoryCreateData modify dependencies (#7895)

crates/node_binding/src/plugins/interceptor.rs

@@ -1267,8 +1267,7 @@ impl CompilationAfterSeal for CompilationAfterSealTap {
 #[async_trait]
 impl NormalModuleFactoryBeforeResolve for NormalModuleFactoryBeforeResolveTap {
   async fn run(&self, data: &mut ModuleFactoryCreateData) -> rspack_error::Result<Option<bool>> {
-    let dependency = data
-      .dependency
+    let dependency = data.dependencies[0]
       .as_module_dependency_mut()
       .expect("should be module dependency");
     match self
@@ -1304,8 +1303,7 @@ impl NormalModuleFactoryFactorize for NormalModuleFactoryFactorizeTap {
     &self,
     data: &mut ModuleFactoryCreateData,
   ) -> rspack_error::Result<Option<BoxModule>> {
-    let dependency = data
-      .dependency
+    let dependency = data.dependencies[0]
       .as_module_dependency_mut()
       .expect("should be module dependency");
     match self
@@ -1342,8 +1340,7 @@ impl NormalModuleFactoryResolve for NormalModuleFactoryResolveTap {
     &self,
     data: &mut ModuleFactoryCreateData,
   ) -> rspack_error::Result<Option<NormalModuleFactoryResolveResult>> {
-    let dependency = data
-      .dependency
+    let dependency = data.dependencies[0]
       .as_module_dependency_mut()
       .expect("should be module dependency");
     match self
@@ -1486,7 +1483,7 @@ impl NormalModuleFactoryCreateModule for NormalModuleFactoryCreateModuleTap {
     self
       .function
       .call_with_promise(JsNormalModuleFactoryCreateModuleArgs {
-        dependency_type: data.dependency.dependency_type().to_string(),
+        dependency_type: data.dependencies[0].dependency_type().to_string(),
         raw_request: create_data.raw_request.clone(),
         resource_resolve_data: create_data.resource_resolve_data.clone().into(),
         context: data.context.to_string(),

crates/rspack_core/src/compiler/make/repair/add.rs

@@ -4,15 +4,15 @@ use super::{build::BuildTask, MakeTaskContext};
 use crate::{
   module_graph::{ModuleGraph, ModuleGraphModule},
   utils::task_loop::{Task, TaskResult, TaskType},
-  DependencyId, Module, ModuleIdentifier, ModuleProfile,
+  BoxDependency, Module, ModuleIdentifier, ModuleProfile,
 };
 
 #[derive(Debug)]
 pub struct AddTask {
   pub original_module_identifier: Option<ModuleIdentifier>,
   pub module: Box<dyn Module>,
   pub module_graph_module: Box<ModuleGraphModule>,
-  pub dependencies: Vec<DependencyId>,
+  pub dependencies: Vec<BoxDependency>,
   pub current_profile: Option<Box<ModuleProfile>>,
 }
 
@@ -84,11 +84,16 @@ impl Task<MakeTaskContext> for AddTask {
 fn set_resolved_module(
   module_graph: &mut ModuleGraph,
   original_module_identifier: Option<ModuleIdentifier>,
-  dependencies: Vec<DependencyId>,
+  dependencies: Vec<BoxDependency>,
   module_identifier: ModuleIdentifier,
 ) -> Result<()> {
   for dependency in dependencies {
-    module_graph.set_resolved_module(original_module_identifier, dependency, module_identifier)?;
+    module_graph.set_resolved_module(
+      original_module_identifier,
+      *dependency.id(),
+      module_identifier,
+    )?;
+    module_graph.add_dependency(dependency);
   }
   Ok(())
 }

crates/rspack_core/src/compiler/make/repair/factorize.rs

@@ -8,9 +8,9 @@ use super::{add::AddTask, MakeTaskContext};
 use crate::{
   module_graph::ModuleGraphModule,
   utils::task_loop::{Task, TaskResult, TaskType},
-  BoxDependency, CompilerOptions, Context, DependencyId, ExportInfoData, ExportsInfoData,
-  ModuleFactory, ModuleFactoryCreateData, ModuleFactoryResult, ModuleIdentifier, ModuleLayer,
-  ModuleProfile, Resolve,
+  BoxDependency, CompilerOptions, Context, ExportInfoData, ExportsInfoData, ModuleFactory,
+  ModuleFactoryCreateData, ModuleFactoryResult, ModuleIdentifier, ModuleLayer, ModuleProfile,
+  Resolve,
 };
 
 #[derive(Debug)]
@@ -21,8 +21,7 @@ pub struct FactorizeTask {
   pub original_module_context: Option<Box<Context>>,
   pub issuer: Option<Box<str>>,
   pub issuer_layer: Option<ModuleLayer>,
-  pub dependency: BoxDependency,
-  pub dependencies: Vec<DependencyId>,
+  pub dependencies: Vec<BoxDependency>,
   pub resolve_options: Option<Box<Resolve>>,
   pub options: Arc<CompilerOptions>,
   pub current_profile: Option<Box<ModuleProfile>>,
@@ -37,7 +36,7 @@ impl Task<MakeTaskContext> for FactorizeTask {
     if let Some(current_profile) = &self.current_profile {
       current_profile.mark_factory_start();
     }
-    let dependency = self.dependency;
+    let dependency = &self.dependencies[0];
 
     let context = if let Some(context) = dependency.get_context()
       && !context.is_empty()
@@ -64,7 +63,7 @@ impl Task<MakeTaskContext> for FactorizeTask {
       //      dependency: dep_id,
       original_module_identifier: self.original_module_identifier,
       factory_result: None,
-      dependencies: self.dependencies,
+      dependencies: vec![],
       current_profile: self.current_profile,
       exports_info_related: ExportsInfoRelated {
         exports_info,
@@ -83,7 +82,7 @@ impl Task<MakeTaskContext> for FactorizeTask {
       resolve_options: self.resolve_options,
       options: self.options.clone(),
       context,
-      dependency,
+      dependencies: self.dependencies,
       issuer: self.issuer,
       issuer_identifier: self.original_module_identifier,
       issuer_layer,
@@ -101,6 +100,7 @@ impl Task<MakeTaskContext> for FactorizeTask {
         let diagnostics = create_data.diagnostics.drain(..).collect();
         Ok(vec![Box::new(
           factorize_result_task
+            .with_dependencies(create_data.dependencies)
             .with_factory_result(Some(result))
             .with_diagnostics(diagnostics)
             .with_file_dependencies(create_data.file_dependencies.drain())
@@ -125,11 +125,12 @@ impl Task<MakeTaskContext> for FactorizeTask {
           return Err(e);
         }
         let mut diagnostics = Vec::with_capacity(create_data.diagnostics.len() + 1);
-        diagnostics.push(Into::<Diagnostic>::into(e).with_loc(create_data.dependency.loc()));
+        diagnostics.push(Into::<Diagnostic>::into(e).with_loc(create_data.dependencies[0].loc()));
         diagnostics.append(&mut create_data.diagnostics);
         // Continue bundling if `options.bail` set to `false`.
         Ok(vec![Box::new(
           factorize_result_task
+            .with_dependencies(create_data.dependencies)
             .with_diagnostics(diagnostics)
             .with_file_dependencies(create_data.file_dependencies.drain())
             .with_missing_dependencies(create_data.missing_dependencies.drain())
@@ -154,7 +155,7 @@ pub struct FactorizeResultTask {
   pub original_module_identifier: Option<ModuleIdentifier>,
   /// Result will be available if [crate::ModuleFactory::create] returns `Ok`.
   pub factory_result: Option<ModuleFactoryResult>,
-  pub dependencies: Vec<DependencyId>,
+  pub dependencies: Vec<BoxDependency>,
   pub current_profile: Option<Box<ModuleProfile>>,
   pub exports_info_related: ExportsInfoRelated,
 
@@ -165,6 +166,11 @@ pub struct FactorizeResultTask {
 }
 
 impl FactorizeResultTask {
+  fn with_dependencies(mut self, dependencies: Vec<BoxDependency>) -> Self {
+    self.dependencies = dependencies;
+    self
+  }
+
   fn with_factory_result(mut self, factory_result: Option<ModuleFactoryResult>) -> Self {
     self.factory_result = factory_result;
     self
@@ -214,7 +220,7 @@ impl Task<MakeTaskContext> for FactorizeResultTask {
       } else {
         artifact
           .make_failed_dependencies
-          .insert((dependencies[0], None));
+          .insert((*dependencies[0].id(), None));
       }
     }
 
@@ -236,17 +242,13 @@ impl Task<MakeTaskContext> for FactorizeResultTask {
     let module_graph =
       &mut MakeTaskContext::get_module_graph_mut(&mut artifact.module_graph_partial);
     let Some(factory_result) = factory_result else {
-      let dep = module_graph
-        .dependency_by_id(&dependencies[0])
-        .expect("dep should available");
+      let dep = &dependencies[0];
       tracing::trace!("Module created with failure, but without bailout: {dep:?}");
       return Ok(vec![]);
     };
 
     let Some(module) = factory_result.module else {
-      let dep = module_graph
-        .dependency_by_id(&dependencies[0])
-        .expect("dep should available");
+      let dep = &dependencies[0];
       tracing::trace!("Module ignored: {dep:?}");
       return Ok(vec![]);
     };

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

@@ -128,8 +128,7 @@ pub fn repair(
           .and_then(|module| module.name_for_condition()),
         issuer_layer: parent_module.and_then(|m| m.get_layer()).cloned(),
         original_module_context: parent_module.and_then(|m| m.get_context()),
-        dependency: dependency.clone(),
-        dependencies: vec![id],
+        dependencies: vec![dependency.clone()],
         resolve_options: parent_module.and_then(|module| module.get_resolve_options()),
         options: compilation.options.clone(),
         current_profile,

crates/rspack_core/src/compiler/make/repair/process_dependencies.rs

@@ -57,7 +57,7 @@ impl Task<MakeTaskContext> for ProcessDependenciesTask {
         sorted_dependencies
           .entry(resource_identifier)
           .or_insert(vec![])
-          .push(dependency_id);
+          .push(dependency.clone());
       }
     }
 
@@ -71,10 +71,6 @@ impl Task<MakeTaskContext> for ProcessDependenciesTask {
         .compiler_options
         .profile
         .then(Box::<ModuleProfile>::default);
-      let dependency = module_graph
-        .dependency_by_id(&dependencies[0])
-        .expect("should have dependency")
-        .clone();
       let original_module_source = module_graph
         .module_by_identifier(&original_module_identifier)
         .and_then(|m| m.as_normal_module())
@@ -85,6 +81,7 @@ impl Task<MakeTaskContext> for ProcessDependenciesTask {
             None
           }
         });
+      let dependency = &dependencies[0];
       let dependency_type = dependency.dependency_type();
       // TODO move module_factory calculate to dependency factories
       let module_factory = context
@@ -107,7 +104,6 @@ impl Task<MakeTaskContext> for ProcessDependenciesTask {
           .as_normal_module()
           .and_then(|module| module.name_for_condition()),
         issuer_layer: module.get_layer().cloned(),
-        dependency,
         dependencies,
         resolve_options: module.get_resolve_options(),
         options: context.compiler_options.clone(),

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

@@ -40,7 +40,6 @@ impl Task<MakeTaskContext> for EntryTask {
         Ok(vec![])
       }
       EntryParam::Entry(dep) => {
-        let dep_id = *dep.id();
         module_graph.add_dependency(dep.clone());
         Ok(vec![Box::new(FactorizeTask {
           module_factory: context
@@ -58,8 +57,7 @@ impl Task<MakeTaskContext> for EntryTask {
           issuer: None,
           issuer_layer: None,
           original_module_context: None,
-          dependency: dep,
-          dependencies: vec![dep_id],
+          dependencies: vec![dep],
           resolve_options: None,
           options: context.compiler_options.clone(),
           current_profile: context

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

@@ -41,11 +41,7 @@ impl Task<MakeTaskContext> for OverwriteTask {
     // factorize result task
     if let Some(factorize_result_task) = origin_task.as_any().downcast_ref::<FactorizeResultTask>()
     {
-      let dep_id = factorize_result_task
-        .dependencies
-        .first()
-        .copied()
-        .expect("should have dep_id");
+      let dep_id = *factorize_result_task.dependencies[0].id();
       let original_module_identifier = factorize_result_task.original_module_identifier;
       let res = origin_task.sync_run(context)?;
       if res.is_empty() {
@@ -57,11 +53,7 @@ impl Task<MakeTaskContext> for OverwriteTask {
     }
     // add task
     if let Some(add_task) = origin_task.as_any().downcast_ref::<AddTask>() {
-      let dep_id = add_task
-        .dependencies
-        .first()
-        .copied()
-        .expect("should have dep_id");
+      let dep_id = *add_task.dependencies[0].id();
       let original_module_identifier = add_task.original_module_identifier;
       let target_module_identifier = add_task.module.identifier();
 

crates/rspack_core/src/context_module_factory.rs

@@ -154,8 +154,7 @@ impl ContextModuleFactory {
     data: &mut ModuleFactoryCreateData,
   ) -> Result<(ModuleFactoryResult, Option<ContextModuleOptions>)> {
     let plugin_driver = &self.plugin_driver;
-    let dependency = data
-      .dependency
+    let dependency = data.dependencies[0]
       .as_context_dependency()
       .expect("should be context dependency");
     let mut file_dependencies = Default::default();

crates/rspack_core/src/module_factory.rs

@@ -12,7 +12,7 @@ pub struct ModuleFactoryCreateData {
   pub resolve_options: Option<Box<Resolve>>,
   pub options: Arc<CompilerOptions>,
   pub context: Context,
-  pub dependency: BoxDependency,
+  pub dependencies: Vec<BoxDependency>,
   pub issuer: Option<Box<str>>,
   pub issuer_identifier: Option<ModuleIdentifier>,
   pub issuer_layer: Option<ModuleLayer>,
@@ -25,11 +25,14 @@ pub struct ModuleFactoryCreateData {
 
 impl ModuleFactoryCreateData {
   pub fn request(&self) -> Option<&str> {
-    self
-      .dependency
+    self.dependencies[0]
       .as_module_dependency()
       .map(|d| d.request())
-      .or_else(|| self.dependency.as_context_dependency().map(|d| d.request()))
+      .or_else(|| {
+        self.dependencies[0]
+          .as_context_dependency()
+          .map(|d| d.request())
+      })
   }
 
   pub fn add_file_dependency(&mut self, file: PathBuf) {

crates/rspack_core/src/normal_module_factory.rs

@@ -136,8 +136,7 @@ impl NormalModuleFactory {
     &self,
     data: &mut ModuleFactoryCreateData,
   ) -> Result<Option<ModuleFactoryResult>> {
-    let dependency = data
-      .dependency
+    let dependency = data.dependencies[0]
       .as_module_dependency()
       .expect("should be module dependency");
     let dependency_type = *dependency.dependency_type();
@@ -216,7 +215,7 @@ impl NormalModuleFactory {
           {
             Some((pos, _)) => &request_without_match_resource[pos..],
             None => {
-              unreachable!("Invalid dependency: {:?}", &data.dependency)
+              unreachable!("Invalid dependency: {:?}", &data.dependencies[0])
             }
           }
         } else {
@@ -389,7 +388,7 @@ impl NormalModuleFactory {
           } else {
             &resource_data
           },
-          data.dependency.as_ref(),
+          data.dependencies[0].as_ref(),
           data.issuer.as_deref(),
           data.issuer_layer.as_deref(),
         )

crates/rspack_plugin_externals/src/plugin.rs

@@ -133,8 +133,7 @@ impl ExternalsPlugin {
 
 #[plugin_hook(NormalModuleFactoryFactorize for ExternalsPlugin)]
 async fn factorize(&self, data: &mut ModuleFactoryCreateData) -> Result<Option<BoxModule>> {
-  let dependency = data
-    .dependency
+  let dependency = data.dependencies[0]
     .as_module_dependency()
     .expect("should be module dependency");
   let context = &data.context;

crates/rspack_plugin_extract_css/src/css_module.rs

@@ -241,8 +241,7 @@ pub(crate) struct CssModuleFactory;
 #[async_trait::async_trait]
 impl ModuleFactory for CssModuleFactory {
   async fn create(&self, data: &mut ModuleFactoryCreateData) -> Result<ModuleFactoryResult> {
-    let css_dep = data
-      .dependency
+    let css_dep = data.dependencies[0]
       .downcast_ref::<CssDependency>()
       .expect("unreachable");
 

crates/rspack_plugin_lazy_compilation/src/dependency.rs

@@ -12,8 +12,7 @@ pub(crate) struct LazyCompilationDependency {
 
 impl LazyCompilationDependency {
   pub fn new(original_module_create_data: ModuleFactoryCreateData) -> Self {
-    let dep = original_module_create_data
-      .dependency
+    let dep = original_module_create_data.dependencies[0]
       .as_module_dependency()
       .expect("LazyCompilation: should convert to module dependency");
     let request = dep.request().to_string();