refactor: changed ModuleGraph dependencies to BoxDependency (#4026)

Author: underfin

crates/rspack_core/src/compiler/compilation.rs

@@ -31,16 +31,16 @@ use crate::{
   cache::{use_code_splitting_cache, Cache, CodeSplittingCache},
   is_source_equal,
   tree_shaking::{optimizer, visitor::SymbolRef, BailoutFlag, OptimizeDependencyResult},
-  AddQueue, AddTask, AddTaskResult, AdditionalChunkRuntimeRequirementsArgs, BoxModule,
-  BoxModuleDependency, BuildQueue, BuildTask, BuildTaskResult, Chunk, ChunkByUkey,
-  ChunkContentHash, ChunkGraph, ChunkGroup, ChunkGroupUkey, ChunkHashArgs, ChunkKind, ChunkUkey,
-  CleanQueue, CleanTask, CleanTaskResult, CodeGenerationResult, CodeGenerationResults,
-  CompilationLogger, CompilationLogging, CompilerOptions, ContentHashArgs, DependencyId, Entry,
-  EntryData, EntryOptions, Entrypoint, FactorizeQueue, FactorizeTask, FactorizeTaskResult,
-  Filename, Logger, Module, ModuleGraph, ModuleIdentifier, ModuleProfile, ModuleType, PathData,
-  ProcessAssetsArgs, ProcessDependenciesQueue, ProcessDependenciesResult, ProcessDependenciesTask,
-  RenderManifestArgs, Resolve, ResolverFactory, RuntimeGlobals, RuntimeModule, RuntimeSpec,
-  SharedPluginDriver, SourceType, Stats, TaskResult, WorkerTask,
+  AddQueue, AddTask, AddTaskResult, AdditionalChunkRuntimeRequirementsArgs, BoxDependency,
+  BoxModule, BuildQueue, BuildTask, BuildTaskResult, Chunk, ChunkByUkey, ChunkContentHash,
+  ChunkGraph, ChunkGroup, ChunkGroupUkey, ChunkHashArgs, ChunkKind, ChunkUkey, CleanQueue,
+  CleanTask, CleanTaskResult, CodeGenerationResult, CodeGenerationResults, CompilationLogger,
+  CompilationLogging, CompilerOptions, ContentHashArgs, DependencyId, Entry, EntryData,
+  EntryOptions, Entrypoint, FactorizeQueue, FactorizeTask, FactorizeTaskResult, Filename, Logger,
+  Module, ModuleGraph, ModuleIdentifier, ModuleProfile, ModuleType, PathData, ProcessAssetsArgs,
+  ProcessDependenciesQueue, ProcessDependenciesResult, ProcessDependenciesTask, RenderManifestArgs,
+  Resolve, ResolverFactory, RuntimeGlobals, RuntimeModule, RuntimeSpec, SharedPluginDriver,
+  SourceType, Stats, TaskResult, WorkerTask,
 };
 use crate::{tree_shaking::visitor::OptimizeAnalyzeResult, Context};
 
@@ -427,7 +427,10 @@ impl Compilation {
           .expect("dependency not found");
         let parent_module =
           parent_module_identifier.and_then(|id| self.module_graph.module_by_identifier(&id));
-        if parent_module_identifier.is_some() && parent_module.is_none() {
+        if parent_module_identifier.is_some()
+          && parent_module.is_none()
+          && dependency.as_module_dependency().is_none()
+        {
           return;
         }
 
@@ -536,19 +539,26 @@ impl Compilation {
         let mut sorted_dependencies = HashMap::default();
 
         task.dependencies.into_iter().for_each(|dependency| {
-          // TODO need implement more dependency `resource_identifier()`
-          // https://github.com/webpack/webpack/blob/main/lib/Compilation.js#L1621
-          let resource_identifier =
-            if let Some(resource_identifier) = dependency.resource_identifier() {
-              resource_identifier.to_string()
-            } else {
-              format!("{}|{}", dependency.dependency_type(), dependency.request())
-            };
-
-          sorted_dependencies
-            .entry(resource_identifier)
-            .or_insert(vec![])
-            .push(dependency);
+          // only module dependency can put into resolve queue.
+          if let Some(module_dependency) = dependency.as_module_dependency() {
+            // TODO need implement more dependency `resource_identifier()`
+            // https://github.com/webpack/webpack/blob/main/lib/Compilation.js#L1621
+            let resource_identifier =
+              if let Some(resource_identifier) = module_dependency.resource_identifier() {
+                resource_identifier.to_string()
+              } else {
+                format!(
+                  "{}|{}",
+                  module_dependency.dependency_type(),
+                  module_dependency.request()
+                )
+              };
+
+            sorted_dependencies
+              .entry(resource_identifier)
+              .or_insert(vec![])
+              .push(dependency);
+          }
         });
 
         for dependencies in sorted_dependencies.into_values() {
@@ -677,9 +687,11 @@ impl Compilation {
 
               let mut dep_ids = vec![];
               for dependency in build_result.dependencies.iter() {
-                self
-                  .module_graph
-                  .set_dependency_import_var(module.identifier(), dependency.request());
+                if let Some(dependency) = dependency.as_module_dependency() {
+                  self
+                    .module_graph
+                    .set_dependency_import_var(module.identifier(), dependency.request());
+                }
                 dep_ids.push(*dependency.id());
               }
 
@@ -843,7 +855,7 @@ impl Compilation {
     queue: &mut FactorizeQueue,
     original_module_identifier: Option<ModuleIdentifier>,
     original_module_context: Option<Context>,
-    dependencies: Vec<BoxModuleDependency>,
+    dependencies: Vec<BoxDependency>,
     is_entry: bool,
     module_type: Option<ModuleType>,
     side_effects: Option<bool>,

crates/rspack_core/src/compiler/queue.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use rspack_error::{Diagnostic, Result};
 
 use crate::{
-  cache::Cache, BoxModuleDependency, BuildContext, BuildResult, Compilation, CompilerContext,
+  cache::Cache, BoxDependency, BuildContext, BuildResult, Compilation, CompilerContext,
   CompilerOptions, Context, ContextModuleFactory, DependencyType, Module, ModuleFactory,
   ModuleFactoryCreateData, ModuleFactoryResult, ModuleGraph, ModuleGraphModule, ModuleIdentifier,
   ModuleProfile, ModuleType, NormalModuleFactory, NormalModuleFactoryContext, Resolve,
@@ -27,7 +27,7 @@ pub struct FactorizeTask {
   pub original_module_identifier: Option<ModuleIdentifier>,
   pub original_module_context: Option<Context>,
   pub issuer: Option<String>,
-  pub dependencies: Vec<BoxModuleDependency>,
+  pub dependencies: Vec<BoxDependency>,
   pub is_entry: bool,
   pub module_type: Option<ModuleType>,
   pub side_effects: Option<bool>,
@@ -45,7 +45,7 @@ pub struct FactorizeTaskResult {
   pub original_module_identifier: Option<ModuleIdentifier>,
   pub factory_result: ModuleFactoryResult,
   pub module_graph_module: Box<ModuleGraphModule>,
-  pub dependencies: Vec<BoxModuleDependency>,
+  pub dependencies: Vec<BoxDependency>,
   pub diagnostics: Vec<Diagnostic>,
   pub is_entry: bool,
   pub current_profile: Option<ModuleProfile>,
@@ -131,7 +131,7 @@ pub struct AddTask {
   pub original_module_identifier: Option<ModuleIdentifier>,
   pub module: Box<dyn Module>,
   pub module_graph_module: Box<ModuleGraphModule>,
-  pub dependencies: Vec<BoxModuleDependency>,
+  pub dependencies: Vec<BoxDependency>,
   pub is_entry: bool,
   pub current_profile: Option<ModuleProfile>,
 }
@@ -203,7 +203,7 @@ impl AddTask {
   fn set_resolved_module(
     module_graph: &mut ModuleGraph,
     original_module_identifier: Option<ModuleIdentifier>,
-    dependencies: Vec<BoxModuleDependency>,
+    dependencies: Vec<BoxDependency>,
     module_identifier: ModuleIdentifier,
   ) -> Result<()> {
     for dependency in dependencies {
@@ -300,7 +300,7 @@ pub type BuildQueue = WorkerQueue<BuildTask>;
 
 pub struct ProcessDependenciesTask {
   pub original_module_identifier: ModuleIdentifier,
-  pub dependencies: Vec<BoxModuleDependency>,
+  pub dependencies: Vec<BoxDependency>,
   pub resolve_options: Option<Resolve>,
 }
 

crates/rspack_core/src/context_module.rs

@@ -17,11 +17,11 @@ use rustc_hash::FxHashMap as HashMap;
 use rustc_hash::FxHashSet as HashSet;
 
 use crate::{
-  contextify, get_exports_type_with_strict, stringify_map, BoxModuleDependency, BuildContext,
-  BuildInfo, BuildMeta, BuildResult, ChunkGraph, CodeGenerationResult, Compilation,
-  ContextElementDependency, DependencyCategory, DependencyId, DependencyType, ExportsType,
-  FakeNamespaceObjectMode, LibIdentOptions, Module, ModuleType, Resolve,
-  ResolveOptionsWithDependencyType, ResolverFactory, RuntimeGlobals, SourceType,
+  contextify, get_exports_type_with_strict, stringify_map, BoxDependency, BuildContext, BuildInfo,
+  BuildMeta, BuildResult, ChunkGraph, CodeGenerationResult, Compilation, ContextElementDependency,
+  DependencyCategory, DependencyId, DependencyType, ExportsType, FakeNamespaceObjectMode,
+  LibIdentOptions, Module, ModuleType, Resolve, ResolveOptionsWithDependencyType, ResolverFactory,
+  RuntimeGlobals, SourceType,
 };
 
 #[derive(Debug, Clone)]
@@ -272,18 +272,20 @@ impl ContextModule {
           .module_graph
           .module_identifier_by_dependency_id(dependency)
         {
-          let dependency = compilation
+          if let Some(dependency) = compilation
             .module_graph
             .dependency_by_id(dependency)
-            .expect("should have dependency");
-          map.insert(
-            dependency.user_request().to_string(),
-            if let Some(module_id) = compilation.chunk_graph.get_module_id(*module_identifier) {
-              format!("\"{module_id}\"")
-            } else {
-              "null".to_string()
-            },
-          );
+            .and_then(|d| d.as_module_dependency())
+          {
+            map.insert(
+              dependency.user_request().to_string(),
+              if let Some(module_id) = compilation.chunk_graph.get_module_id(*module_identifier) {
+                format!("\"{module_id}\"")
+              } else {
+                "null".to_string()
+              },
+            );
+          }
         }
       }
     }
@@ -559,7 +561,7 @@ impl ContextModule {
     fn visit_dirs(
       ctx: &str,
       dir: &Path,
-      dependencies: &mut Vec<BoxModuleDependency>,
+      dependencies: &mut Vec<BoxDependency>,
       options: &ContextModuleOptions,
       resolve_options: &nodejs_resolver::Options,
     ) -> Result<()> {

crates/rspack_core/src/context_module_factory.rs

@@ -4,10 +4,10 @@ use rspack_error::{IntoTWithDiagnosticArray, Result, TWithDiagnosticArray};
 use tracing::instrument;
 
 use crate::{
-  cache::Cache, resolve, BoxModule, ContextModule, ContextModuleOptions, MissingModule,
-  ModuleDependency, ModuleExt, ModuleFactory, ModuleFactoryCreateData, ModuleFactoryResult,
-  ModuleIdentifier, NormalModuleBeforeResolveArgs, RawModule, ResolveArgs, ResolveError,
-  ResolveResult, SharedPluginDriver,
+  cache::Cache, resolve, BoxModule, ContextModule, ContextModuleOptions, MissingModule, ModuleExt,
+  ModuleFactory, ModuleFactoryCreateData, ModuleFactoryResult, ModuleIdentifier,
+  NormalModuleBeforeResolveArgs, RawModule, ResolveArgs, ResolveError, ResolveResult,
+  SharedPluginDriver,
 };
 
 pub struct ContextModuleFactory {
@@ -41,16 +41,20 @@ impl ContextModuleFactory {
     &mut self,
     data: &mut ModuleFactoryCreateData,
   ) -> Result<Option<TWithDiagnosticArray<ModuleFactoryResult>>> {
+    let dependency = data
+      .dependency
+      .as_module_dependency_mut()
+      .expect("should be module dependency");
     let mut before_resolve_args = NormalModuleBeforeResolveArgs {
-      request: data.dependency.request().to_string(),
+      request: dependency.request().to_string(),
       context: data.context.to_string(),
     };
     if let Ok(Some(false)) = self
       .plugin_driver
       .context_module_before_resolve(&mut before_resolve_args)
       .await
     {
-      let specifier = data.dependency.request();
+      let specifier = dependency.request();
       let ident = format!("{}{specifier}", data.context);
 
       let module_identifier = ModuleIdentifier::from(format!("missing|{ident}"));
@@ -66,26 +70,30 @@ impl ContextModuleFactory {
       ));
     }
     data.context = before_resolve_args.context.into();
-    data.dependency.set_request(before_resolve_args.request);
+    dependency.set_request(before_resolve_args.request);
     Ok(None)
   }
 
   pub async fn resolve(
     &self,
     data: ModuleFactoryCreateData,
   ) -> Result<TWithDiagnosticArray<ModuleFactoryResult>> {
+    let dependency = data
+      .dependency
+      .as_module_dependency()
+      .expect("should be module dependency");
     let factory_meta = Default::default();
     let mut file_dependencies = Default::default();
     let mut missing_dependencies = Default::default();
     let context_dependencies = Default::default();
-    let specifier = data.dependency.request();
+    let specifier = dependency.request();
     let resolve_args = ResolveArgs {
       context: data.context.clone(),
       importer: None,
       specifier,
-      dependency_type: data.dependency.dependency_type(),
-      dependency_category: data.dependency.category(),
-      span: data.dependency.span().cloned(),
+      dependency_type: dependency.dependency_type(),
+      dependency_category: dependency.category(),
+      span: dependency.span().cloned(),
       resolve_options: data.resolve_options.clone(),
       resolve_to_context: true,
       optional: false,
@@ -106,11 +114,7 @@ impl ContextModuleFactory {
           resource_query: resource.query,
           resource_fragment: resource.fragment,
           resolve_options: data.resolve_options,
-          context_options: data
-            .dependency
-            .options()
-            .expect("should has options")
-            .clone(),
+          context_options: dependency.options().expect("should has options").clone(),
         },
         plugin_driver.resolver_factory.clone(),
       )) as BoxModule,

crates/rspack_core/src/dependency/context_element_dependency.rs

@@ -1,6 +1,6 @@
 use crate::{
-  Context, ContextMode, ContextOptions, Dependency, DependencyCategory, DependencyId,
-  DependencyType, ModuleDependency,
+  AsDependencyTemplate, Context, ContextMode, ContextOptions, Dependency, DependencyCategory,
+  DependencyId, DependencyType, ModuleDependency,
 };
 
 #[derive(Debug, Eq, PartialEq, Clone, Hash)]
@@ -16,6 +16,10 @@ pub struct ContextElementDependency {
 }
 
 impl Dependency for ContextElementDependency {
+  fn id(&self) -> &DependencyId {
+    &self.id
+  }
+
   fn category(&self) -> &DependencyCategory {
     &self.category
   }
@@ -30,10 +34,6 @@ impl Dependency for ContextElementDependency {
 }
 
 impl ModuleDependency for ContextElementDependency {
-  fn id(&self) -> &DependencyId {
-    &self.id
-  }
-
   fn request(&self) -> &str {
     &self.request
   }
@@ -65,3 +65,5 @@ impl ModuleDependency for ContextElementDependency {
     Some(&self.resource_identifier)
   }
 }
+
+impl AsDependencyTemplate for ContextElementDependency {}

crates/rspack_core/src/dependency/dependency_template.rs

@@ -21,3 +21,17 @@ pub trait DependencyTemplate: Debug + Sync + Send {
     code_generatable_context: &mut TemplateContext,
   );
 }
+
+pub type BoxDependencyTemplate = Box<dyn DependencyTemplate>;
+
+pub trait AsDependencyTemplate {
+  fn as_dependency_template(&self) -> Option<&dyn DependencyTemplate> {
+    None
+  }
+}
+
+impl<T: DependencyTemplate> AsDependencyTemplate for T {
+  fn as_dependency_template(&self) -> Option<&dyn DependencyTemplate> {
+    Some(self)
+  }
+}

crates/rspack_core/src/dependency/entry.rs

@@ -1,5 +1,6 @@
 use crate::{
-  Dependency, DependencyCategory, DependencyId, DependencyType, ErrorSpan, ModuleDependency,
+  AsDependencyTemplate, Dependency, DependencyCategory, DependencyId, DependencyType, ErrorSpan,
+  ModuleDependency,
 };
 
 #[derive(Debug, Hash, PartialEq, Eq, Clone)]
@@ -18,6 +19,10 @@ impl EntryDependency {
 }
 
 impl Dependency for EntryDependency {
+  fn id(&self) -> &DependencyId {
+    &self.id
+  }
+
   fn category(&self) -> &DependencyCategory {
     &DependencyCategory::Esm
   }
@@ -28,10 +33,6 @@ impl Dependency for EntryDependency {
 }
 
 impl ModuleDependency for EntryDependency {
-  fn id(&self) -> &DependencyId {
-    &self.id
-  }
-
   fn request(&self) -> &str {
     &self.request
   }
@@ -48,3 +49,5 @@ impl ModuleDependency for EntryDependency {
     self.request = request;
   }
 }
+
+impl AsDependencyTemplate for EntryDependency {}