diff --git a/crates/rspack_binding_api/src/module_graph.rs b/crates/rspack_binding_api/src/module_graph.rs index f0257ae38a2e..0c73e69150cc 100644 --- a/crates/rspack_binding_api/src/module_graph.rs +++ b/crates/rspack_binding_api/src/module_graph.rs @@ -257,6 +257,9 @@ impl JsModuleGraph { #[napi(ts_args_type = "module: Module")] pub fn is_async(&self, module: ModuleObjectRef) -> napi::Result { let (compilation, _) = self.as_ref()?; - Ok(ModuleGraph::is_async(compilation, &module.identifier)) + Ok(ModuleGraph::is_async( + &compilation.collect_build_module_graph_effects_artifact, + &module.identifier, + )) } } diff --git a/crates/rspack_binding_api/src/plugins/interceptor.rs b/crates/rspack_binding_api/src/plugins/interceptor.rs index bd3854839883..d0c4e6c4cae8 100644 --- a/crates/rspack_binding_api/src/plugins/interceptor.rs +++ b/crates/rspack_binding_api/src/plugins/interceptor.rs @@ -41,7 +41,8 @@ use rspack_core::{ NormalModuleFactoryFactorizeHook, NormalModuleFactoryResolve, NormalModuleFactoryResolveForScheme, NormalModuleFactoryResolveForSchemeHook, NormalModuleFactoryResolveHook, NormalModuleFactoryResolveResult, ResourceData, RuntimeGlobals, - Scheme, parse_resource, rspack_sources::RawStringSource, + Scheme, collect_module_graph_effects::artifact::CollectModuleGraphEffectsArtifact, + incremental::Mutations, parse_resource, rspack_sources::RawStringSource, }; use rspack_hash::RspackHash; use rspack_hook::{Hook, Interceptor}; @@ -1211,7 +1212,11 @@ impl CompilationExecuteModule for CompilationExecuteModuleTap { #[async_trait] impl CompilationFinishModules for CompilationFinishModulesTap { - async fn run(&self, compilation: &mut Compilation) -> rspack_error::Result<()> { + async fn run( + &self, + compilation: &mut Compilation, + _artifacts: &mut CollectModuleGraphEffectsArtifact, + ) -> rspack_error::Result<()> { let compilation = JsCompilationWrapper::new(compilation); self.function.call_with_promise(compilation).await } diff --git a/crates/rspack_core/src/artifacts/mod.rs b/crates/rspack_core/src/artifacts/mod.rs index de3b95de3cf2..88ee0010de73 100644 --- a/crates/rspack_core/src/artifacts/mod.rs +++ b/crates/rspack_core/src/artifacts/mod.rs @@ -1,5 +1,4 @@ use rspack_collections::{IdentifierMap, IdentifierSet, UkeyMap}; -use rspack_error::Diagnostic; use crate::{ChunkRenderResult, ChunkUkey, ModuleId, RuntimeGlobals, chunk_graph_chunk::ChunkId}; @@ -23,7 +22,7 @@ pub use side_effects_do_optimize_artifact::*; pub type AsyncModulesArtifact = IdentifierSet; pub type ImportedByDeferModulesArtifact = IdentifierSet; -pub type DependenciesDiagnosticsArtifact = IdentifierMap>; + pub type ModuleIdsArtifact = IdentifierMap; pub type ChunkIdsArtifact = UkeyMap; pub type CgcRuntimeRequirementsArtifact = UkeyMap; diff --git a/crates/rspack_core/src/chunk_graph/chunk_graph_module.rs b/crates/rspack_core/src/chunk_graph/chunk_graph_module.rs index de366a13f710..bacf2750b678 100644 --- a/crates/rspack_core/src/chunk_graph/chunk_graph_module.rs +++ b/crates/rspack_core/src/chunk_graph/chunk_graph_module.rs @@ -383,7 +383,11 @@ impl ChunkGraph { .hash(&mut hasher); module.source_types(&mg).dyn_hash(&mut hasher); - ModuleGraph::is_async(compilation, &module_identifier).dyn_hash(&mut hasher); + ModuleGraph::is_async( + &compilation.collect_build_module_graph_effects_artifact, + &module_identifier, + ) + .dyn_hash(&mut hasher); let exports_info = mg.get_prefetched_exports_info(&module_identifier, PrefetchExportsInfoMode::Full); let (entry, exports) = exports_info.meta(); diff --git a/crates/rspack_core/src/compilation/collect_module_graph_effects/artifact.rs b/crates/rspack_core/src/compilation/collect_module_graph_effects/artifact.rs new file mode 100644 index 000000000000..f6f673de3e64 --- /dev/null +++ b/crates/rspack_core/src/compilation/collect_module_graph_effects/artifact.rs @@ -0,0 +1,13 @@ +use rspack_collections::{IdentifierMap, IdentifierSet}; +use rspack_error::Diagnostic; + +use crate::incremental::Incremental; + +#[derive(Debug, Default)] +pub struct CollectModuleGraphEffectsArtifact { + pub dependencies_diagnostics: DependenciesDiagnostics, + pub async_module_info: IdentifierSet, + pub incremental: Incremental, +} + +pub type DependenciesDiagnostics = IdentifierMap>; diff --git a/crates/rspack_core/src/compilation/collect_module_graph_effects/mod.rs b/crates/rspack_core/src/compilation/collect_module_graph_effects/mod.rs new file mode 100644 index 000000000000..2ed0b4ee716b --- /dev/null +++ b/crates/rspack_core/src/compilation/collect_module_graph_effects/mod.rs @@ -0,0 +1,166 @@ +pub mod artifact; +use std::mem; + +use rayon::iter::{IntoParallelRefIterator as _, ParallelIterator}; +use rspack_error::Result; + +use crate::{ + Compilation, Logger as _, + collect_module_graph_effects::artifact::{ + CollectModuleGraphEffectsArtifact, DependenciesDiagnostics, + }, + incremental::{self, IncrementalPasses, Mutation}, +}; +pub async fn collect_build_module_graph_effects(compilation: &mut Compilation) -> Result<()> { + let mut artifact = mem::take(&mut compilation.collect_build_module_graph_effects_artifact); + collect_build_module_graph_effects_inner(compilation, &mut artifact).await?; + compilation.diagnostics.extend( + artifact + .dependencies_diagnostics + .clone() + .into_values() + .flatten(), + ); + if let Some(mutations) = artifact.incremental.mutations_take() { + for mutation in mutations { + if let Some(mutations) = compilation.incremental.mutations_write() { + mutations.add(mutation); + } + } + } + + compilation.collect_build_module_graph_effects_artifact = artifact; + Ok(()) +} +// collect build module graph effects for incremental compilation +#[tracing::instrument("Compilation:collect_build_module_graph_effects", skip_all)] +pub async fn collect_build_module_graph_effects_inner( + ctx: &mut Compilation, + artifact: &mut CollectModuleGraphEffectsArtifact, +) -> Result<()> { + let logger = ctx.get_logger("rspack.Compilation"); + if let Some(mutations) = artifact.incremental.mutations_write() { + mutations.extend( + ctx + .build_module_graph_artifact + .affected_dependencies + .updated() + .iter() + .map(|&dependency| Mutation::DependencyUpdate { dependency }), + ); + + mutations.extend( + ctx + .build_module_graph_artifact + .affected_modules + .removed() + .iter() + .map(|&module| Mutation::ModuleRemove { module }), + ); + mutations.extend( + ctx + .build_module_graph_artifact + .affected_modules + .updated() + .iter() + .map(|&module| Mutation::ModuleUpdate { module }), + ); + mutations.extend( + ctx + .build_module_graph_artifact + .affected_modules + .added() + .iter() + .map(|&module| Mutation::ModuleAdd { module }), + ); + tracing::debug!(target: incremental::TRACING_TARGET, passes = %IncrementalPasses::MAKE, %mutations); + } + + let start = logger.time("finish modules"); + // finish_modules means the module graph (modules, connections, dependencies) are + // frozen and start to optimize (provided exports, infer async, etc.) based on the + // module graph, so any kind of change that affect these should be done before the + // finish_modules + + ctx + .plugin_driver + .clone() + .compilation_hooks + .finish_modules + .call(ctx, artifact) + .await?; + + logger.time_end(start); + + // https://github.com/webpack/webpack/blob/19ca74127f7668aaf60d59f4af8fcaee7924541a/lib/Compilation.js#L2988 + ctx.module_graph_cache_artifact.freeze(); + // Collect dependencies diagnostics at here to make sure: + // 1. after finish_modules: has provide exports info + // 2. before optimize dependencies: side effects free module hasn't been skipped + collect_dependencies_diagnostics(ctx, artifact); + ctx.module_graph_cache_artifact.unfreeze(); + Ok(()) +} +#[tracing::instrument("Compilation:collect_dependencies_diagnostics", skip_all)] +fn collect_dependencies_diagnostics( + ctx: &Compilation, + artifact: &mut CollectModuleGraphEffectsArtifact, +) { + let mutations = ctx + .incremental + .mutations_read(IncrementalPasses::DEPENDENCIES_DIAGNOSTICS); + // TODO move diagnostic collect to make + let modules = if let Some(mutations) = mutations + && !artifact.dependencies_diagnostics.is_empty() + { + let revoked_modules = mutations.iter().filter_map(|mutation| match mutation { + Mutation::ModuleRemove { module } => Some(*module), + _ => None, + }); + for revoked_module in revoked_modules { + artifact.dependencies_diagnostics.remove(&revoked_module); + } + let modules = mutations.get_affected_modules_with_module_graph(&ctx.get_module_graph()); + let logger = ctx.get_logger("rspack.incremental.dependenciesDiagnostics"); + logger.log(format!( + "{} modules are affected, {} in total", + modules.len(), + ctx.get_module_graph().modules().len() + )); + modules + } else { + ctx.get_module_graph().modules().keys().copied().collect() + }; + let module_graph = ctx.get_module_graph(); + let module_graph_cache = &ctx.module_graph_cache_artifact; + let dependencies_diagnostics: DependenciesDiagnostics = modules + .par_iter() + .map(|module_identifier| { + let mgm = module_graph + .module_graph_module_by_identifier(module_identifier) + .expect("should have mgm"); + let diagnostics = mgm + .all_dependencies + .iter() + .filter_map(|dependency_id| module_graph.dependency_by_id(dependency_id)) + .filter_map(|dependency| { + dependency + .get_diagnostics(&module_graph, module_graph_cache) + .map(|diagnostics| { + diagnostics.into_iter().map(|mut diagnostic| { + diagnostic.module_identifier = Some(*module_identifier); + diagnostic.loc = dependency.loc(); + diagnostic + }) + }) + }) + .flatten() + .collect::>(); + (*module_identifier, diagnostics) + }) + .collect(); + + artifact + .dependencies_diagnostics + .extend(dependencies_diagnostics); +} diff --git a/crates/rspack_core/src/compilation/mod.rs b/crates/rspack_core/src/compilation/mod.rs index b39db6bc086a..8ad54270f7ca 100644 --- a/crates/rspack_core/src/compilation/mod.rs +++ b/crates/rspack_core/src/compilation/mod.rs @@ -1,5 +1,6 @@ pub mod build_chunk_graph; pub mod build_module_graph; +pub mod collect_module_graph_effects; use std::{ collections::{VecDeque, hash_map}, fmt::{self, Debug}, @@ -40,21 +41,21 @@ use tracing::instrument; use ustr::Ustr; use crate::{ - AsyncModulesArtifact, BindingCell, BoxDependency, BoxModule, CacheCount, CacheOptions, - CgcRuntimeRequirementsArtifact, CgmHashArtifact, CgmRuntimeRequirementsArtifact, Chunk, - ChunkByUkey, ChunkContentHash, ChunkGraph, ChunkGroupByUkey, ChunkGroupUkey, ChunkHashesArtifact, - ChunkIdsArtifact, ChunkKind, ChunkRenderArtifact, ChunkRenderCacheArtifact, ChunkRenderResult, - ChunkUkey, CodeGenerationJob, CodeGenerationResult, CodeGenerationResults, CompilationLogger, - CompilationLogging, CompilerOptions, ConcatenationScope, DependenciesDiagnosticsArtifact, - DependencyCodeGeneration, DependencyTemplate, DependencyTemplateType, DependencyType, Entry, - EntryData, EntryOptions, EntryRuntime, Entrypoint, ExecuteModuleId, Filename, ImportPhase, - ImportVarMap, ImportedByDeferModulesArtifact, Logger, MemoryGCStorage, ModuleFactory, - ModuleGraph, ModuleGraphCacheArtifact, ModuleGraphMut, ModuleGraphPartial, ModuleGraphRef, - ModuleIdentifier, ModuleIdsArtifact, ModuleStaticCacheArtifact, PathData, ResolverFactory, - RuntimeGlobals, RuntimeKeyMap, RuntimeMode, RuntimeModule, RuntimeSpec, RuntimeSpecMap, - RuntimeTemplate, SharedPluginDriver, SideEffectsOptimizeArtifact, SourceType, Stats, - ValueCacheVersions, + BindingCell, BoxDependency, BoxModule, CacheCount, CacheOptions, CgcRuntimeRequirementsArtifact, + CgmHashArtifact, CgmRuntimeRequirementsArtifact, Chunk, ChunkByUkey, ChunkContentHash, + ChunkGraph, ChunkGroupByUkey, ChunkGroupUkey, ChunkHashesArtifact, ChunkIdsArtifact, ChunkKind, + ChunkRenderArtifact, ChunkRenderCacheArtifact, ChunkRenderResult, ChunkUkey, CodeGenerationJob, + CodeGenerationResult, CodeGenerationResults, CompilationLogger, CompilationLogging, + CompilerOptions, ConcatenationScope, DependencyCodeGeneration, DependencyTemplate, + DependencyTemplateType, DependencyType, Entry, EntryData, EntryOptions, EntryRuntime, Entrypoint, + ExecuteModuleId, Filename, ImportPhase, ImportVarMap, ImportedByDeferModulesArtifact, Logger, + MemoryGCStorage, ModuleFactory, ModuleGraph, ModuleGraphCacheArtifact, ModuleGraphMut, + ModuleGraphPartial, ModuleGraphRef, ModuleIdentifier, ModuleIdsArtifact, + ModuleStaticCacheArtifact, PathData, ResolverFactory, RuntimeGlobals, RuntimeKeyMap, RuntimeMode, + RuntimeModule, RuntimeSpec, RuntimeSpecMap, RuntimeTemplate, SharedPluginDriver, + SideEffectsOptimizeArtifact, SourceType, Stats, ValueCacheVersions, build_chunk_graph::artifact::BuildChunkGraphArtifact, + collect_module_graph_effects::artifact::CollectModuleGraphEffectsArtifact, compilation::build_module_graph::{ BuildModuleGraphArtifact, ModuleExecutor, UpdateParam, build_module_graph, finish_build_module_graph, update_module_graph, @@ -74,7 +75,7 @@ define_hook!(CompilationStillValidModule: Series(compiler_id: CompilerId, compil define_hook!(CompilationSucceedModule: Series(compiler_id: CompilerId, compilation_id: CompilationId, module: &mut BoxModule),tracing=false); define_hook!(CompilationExecuteModule: Series(module: &ModuleIdentifier, runtime_modules: &IdentifierSet, code_generation_results: &BindingCell, execute_module_id: &ExecuteModuleId)); -define_hook!(CompilationFinishModules: Series(compilation: &mut Compilation)); +define_hook!(CompilationFinishModules: Series(compilation: &mut Compilation,artifacts: &mut CollectModuleGraphEffectsArtifact)); define_hook!(CompilationSeal: Series(compilation: &mut Compilation)); define_hook!(CompilationConcatenationScope: SeriesBail(compilation: &Compilation, curr_module: ModuleIdentifier) -> ConcatenationScope); define_hook!(CompilationOptimizeDependencies: SeriesBail(compilation: &mut Compilation) -> bool); @@ -234,7 +235,7 @@ pub struct Compilation { assets: CompilationAssets, assets_related_in: HashMap>, pub emitted_assets: DashSet>, - diagnostics: Vec, + pub(crate) diagnostics: Vec, logging: CompilationLogging, pub plugin_driver: SharedPluginDriver, pub buildtime_plugin_driver: SharedPluginDriver, @@ -243,11 +244,7 @@ pub struct Compilation { pub named_chunks: HashMap, pub named_chunk_groups: HashMap, pub runtime_template: RuntimeTemplate, - - // artifact for infer_async_modules_plugin - pub async_modules_artifact: AsyncModulesArtifact, - // artifact for collect_dependencies_diagnostics - pub dependencies_diagnostics_artifact: DependenciesDiagnosticsArtifact, + /**** legacy artifact start ****/ // artifact for side_effects_flag_plugin pub side_effects_optimize_artifact: SideEffectsOptimizeArtifact, // artifact for module_ids @@ -274,10 +271,14 @@ pub struct Compilation { pub chunk_render_cache_artifact: ChunkRenderCacheArtifact, pub imported_by_defer_modules_artifact: ImportedByDeferModulesArtifact, + /**** legacy artifact end ****/ pub code_generated_modules: IdentifierSet, pub build_time_executed_modules: IdentifierSet, pub old_cache: Arc, + // new staged base artifact start ****/ pub build_chunk_graph_artifact: BuildChunkGraphArtifact, + pub collect_build_module_graph_effects_artifact: CollectModuleGraphEffectsArtifact, + // new staged base artifact end ****/ pub incremental: Incremental, pub hash: Option, @@ -383,10 +384,8 @@ impl Compilation { loader_resolver_factory, named_chunks: Default::default(), named_chunk_groups: Default::default(), - - async_modules_artifact: Default::default(), imported_by_defer_modules_artifact: Default::default(), - dependencies_diagnostics_artifact: Default::default(), + collect_build_module_graph_effects_artifact: Default::default(), side_effects_optimize_artifact: Default::default(), module_ids_artifact: Default::default(), chunk_ids_artifact: Default::default(), @@ -1469,143 +1468,6 @@ impl Compilation { // make finished, make artifact should be readonly thereafter. Ok(()) } - // collect build module graph effects for incremental compilation - #[tracing::instrument("Compilation:collect_build_module_graph_effects", skip_all)] - pub async fn collect_build_module_graph_effects(&mut self) -> Result<()> { - let logger = self.get_logger("rspack.Compilation"); - if let Some(mutations) = self.incremental.mutations_write() { - mutations.extend( - self - .build_module_graph_artifact - .affected_dependencies - .updated() - .iter() - .map(|&dependency| Mutation::DependencyUpdate { dependency }), - ); - mutations.extend( - self - .build_module_graph_artifact - .affected_modules - .removed() - .iter() - .map(|&module| Mutation::ModuleRemove { module }), - ); - mutations.extend( - self - .build_module_graph_artifact - .affected_modules - .updated() - .iter() - .map(|&module| Mutation::ModuleUpdate { module }), - ); - mutations.extend( - self - .build_module_graph_artifact - .affected_modules - .added() - .iter() - .map(|&module| Mutation::ModuleAdd { module }), - ); - tracing::debug!(target: incremental::TRACING_TARGET, passes = %IncrementalPasses::MAKE, %mutations); - } - - let start = logger.time("finish modules"); - // finish_modules means the module graph (modules, connections, dependencies) are - // frozen and start to optimize (provided exports, infer async, etc.) based on the - // module graph, so any kind of change that affect these should be done before the - // finish_modules - - self - .plugin_driver - .clone() - .compilation_hooks - .finish_modules - .call(self) - .await?; - - logger.time_end(start); - - // https://github.com/webpack/webpack/blob/19ca74127f7668aaf60d59f4af8fcaee7924541a/lib/Compilation.js#L2988 - self.module_graph_cache_artifact.freeze(); - // Collect dependencies diagnostics at here to make sure: - // 1. after finish_modules: has provide exports info - // 2. before optimize dependencies: side effects free module hasn't been skipped - self.collect_dependencies_diagnostics(); - self.module_graph_cache_artifact.unfreeze(); - - // take make diagnostics - let diagnostics = self.build_module_graph_artifact.diagnostics(); - self.extend_diagnostics(diagnostics); - Ok(()) - } - #[tracing::instrument("Compilation:collect_dependencies_diagnostics", skip_all)] - fn collect_dependencies_diagnostics(&mut self) { - let mutations = self - .incremental - .mutations_read(IncrementalPasses::DEPENDENCIES_DIAGNOSTICS); - // TODO move diagnostic collect to make - let modules = if let Some(mutations) = mutations - && !self.dependencies_diagnostics_artifact.is_empty() - { - let revoked_modules = mutations.iter().filter_map(|mutation| match mutation { - Mutation::ModuleRemove { module } => Some(*module), - _ => None, - }); - for revoked_module in revoked_modules { - self - .dependencies_diagnostics_artifact - .remove(&revoked_module); - } - let modules = mutations.get_affected_modules_with_module_graph(&self.get_module_graph()); - let logger = self.get_logger("rspack.incremental.dependenciesDiagnostics"); - logger.log(format!( - "{} modules are affected, {} in total", - modules.len(), - self.get_module_graph().modules().len() - )); - modules - } else { - self.get_module_graph().modules().keys().copied().collect() - }; - let module_graph = self.get_module_graph(); - let module_graph_cache = &self.module_graph_cache_artifact; - let dependencies_diagnostics: DependenciesDiagnosticsArtifact = modules - .par_iter() - .map(|module_identifier| { - let mgm = module_graph - .module_graph_module_by_identifier(module_identifier) - .expect("should have mgm"); - let diagnostics = mgm - .all_dependencies - .iter() - .filter_map(|dependency_id| module_graph.dependency_by_id(dependency_id)) - .filter_map(|dependency| { - dependency - .get_diagnostics(&module_graph, module_graph_cache) - .map(|diagnostics| { - diagnostics.into_iter().map(|mut diagnostic| { - diagnostic.module_identifier = Some(*module_identifier); - diagnostic.loc = dependency.loc(); - diagnostic - }) - }) - }) - .flatten() - .collect::>(); - (*module_identifier, diagnostics) - }) - .collect(); - let all_modules_diagnostics = if mutations.is_some() { - self - .dependencies_diagnostics_artifact - .extend(dependencies_diagnostics); - self.dependencies_diagnostics_artifact.clone() - } else { - dependencies_diagnostics - }; - self.extend_diagnostics(all_modules_diagnostics.into_values().flatten()); - } - #[instrument("Compilation:seal", skip_all)] pub async fn seal(&mut self, plugin_driver: SharedPluginDriver) -> Result<()> { self.other_module_graph = Some(ModuleGraphPartial::default()); diff --git a/crates/rspack_core/src/compiler/mod.rs b/crates/rspack_core/src/compiler/mod.rs index beddd042103e..1412e45cc192 100644 --- a/crates/rspack_core/src/compiler/mod.rs +++ b/crates/rspack_core/src/compiler/mod.rs @@ -18,6 +18,7 @@ use crate::{ Filename, KeepPattern, Logger, NormalModuleFactory, PluginDriver, ResolverFactory, SharedPluginDriver, cache::{Cache, new_cache}, + collect_module_graph_effects::collect_build_module_graph_effects, compilation::build_module_graph::ModuleExecutor, fast_set, include_hash, incremental::{Incremental, IncrementalPasses}, @@ -253,6 +254,7 @@ impl Compiler { Ok(()) } + #[instrument("Compiler:build_module_graph", target=TRACING_BENCH_TARGET,skip_all)] async fn build_module_graph(&mut self) -> Result<()> { let mut compilation_params = self.new_compilation_params(); // FOR BINDING SAFETY: @@ -306,7 +308,10 @@ impl Compiler { .cache .after_build_module_graph(&self.compilation.build_module_graph_artifact) .await; - + self + .compilation + .diagnostics + .extend(self.compilation.build_module_graph_artifact.diagnostics()); logger.time_end(start); Ok(()) } @@ -320,10 +325,9 @@ impl Compiler { wait_for_signal("seal compilation"); } self.build_module_graph().await?; - self - .compilation - .collect_build_module_graph_effects() - .await?; + + collect_build_module_graph_effects(&mut self.compilation).await?; + self.compilation.seal(self.plugin_driver.clone()).await?; logger.time_end(start); diff --git a/crates/rspack_core/src/compiler/rebuild.rs b/crates/rspack_core/src/compiler/rebuild.rs index a220aa372714..22e8e1fb8601 100644 --- a/crates/rspack_core/src/compiler/rebuild.rs +++ b/crates/rspack_core/src/compiler/rebuild.rs @@ -95,19 +95,16 @@ impl Compiler { // reuse module executor new_compilation.module_executor = std::mem::take(&mut self.compilation.module_executor); } - if new_compilation - .incremental - .mutations_readable(IncrementalPasses::INFER_ASYNC_MODULES) - { - new_compilation.async_modules_artifact = - std::mem::take(&mut self.compilation.async_modules_artifact); - } + if new_compilation .incremental .mutations_readable(IncrementalPasses::DEPENDENCIES_DIAGNOSTICS) + || new_compilation + .incremental + .mutations_readable(IncrementalPasses::INFER_ASYNC_MODULES) { - new_compilation.dependencies_diagnostics_artifact = - std::mem::take(&mut self.compilation.dependencies_diagnostics_artifact); + new_compilation.collect_build_module_graph_effects_artifact = + std::mem::take(&mut self.compilation.collect_build_module_graph_effects_artifact); } if new_compilation .incremental diff --git a/crates/rspack_core/src/dependency/runtime_template.rs b/crates/rspack_core/src/dependency/runtime_template.rs index 7290b1bf3dbc..56190847fdad 100644 --- a/crates/rspack_core/src/dependency/runtime_template.rs +++ b/crates/rspack_core/src/dependency/runtime_template.rs @@ -475,7 +475,10 @@ fn get_outgoing_async_modules( visited: &mut HashSet, ) { let module_identifier = module.identifier(); - if !ModuleGraph::is_async(compilation, &module_identifier) { + if !ModuleGraph::is_async( + &compilation.collect_build_module_graph_effects_artifact, + &module_identifier, + ) { return; } if !visited.insert(module_identifier) { @@ -667,7 +670,7 @@ pub fn module_namespace_promise( } runtime_requirements.insert(RuntimeGlobals::CREATE_FAKE_NAMESPACE_OBJECT); if ModuleGraph::is_async( - compilation, + &compilation.collect_build_module_graph_effects_artifact, compilation .get_module_graph() .module_identifier_by_dependency_id(dep_id) diff --git a/crates/rspack_core/src/incremental/mod.rs b/crates/rspack_core/src/incremental/mod.rs index 55ec64d42777..d17c7e60d519 100644 --- a/crates/rspack_core/src/incremental/mod.rs +++ b/crates/rspack_core/src/incremental/mod.rs @@ -108,6 +108,15 @@ pub struct Incremental { state: IncrementalState, } +impl Default for Incremental { + fn default() -> Self { + Self { + silent: true, + passes: IncrementalPasses::empty(), + state: IncrementalState::Cold, + } + } +} impl Incremental { pub fn new_cold(options: IncrementalOptions) -> Self { Self { @@ -188,6 +197,12 @@ impl Incremental { } None } + pub fn mutations_take(&mut self) -> Option { + if let IncrementalState::Hot { mutations } = &mut self.state { + return Some(std::mem::take(mutations)); + } + None + } } #[derive(Debug)] diff --git a/crates/rspack_core/src/module_graph/mod.rs b/crates/rspack_core/src/module_graph/mod.rs index 70a14e1771f3..08545de048d2 100644 --- a/crates/rspack_core/src/module_graph/mod.rs +++ b/crates/rspack_core/src/module_graph/mod.rs @@ -14,6 +14,7 @@ use crate::{ AsyncDependenciesBlock, AsyncDependenciesBlockIdentifier, Compilation, DependenciesBlock, Dependency, ExportInfo, ExportName, ImportedByDeferModulesArtifact, ModuleGraphCacheArtifact, RuntimeSpec, UsedNameItem, + collect_module_graph_effects::artifact::CollectModuleGraphEffectsArtifact, }; mod module; pub use module::*; @@ -444,8 +445,15 @@ impl<'a> ModuleGraph<'a> { new_mgm.depth = assign_tuple.2; new_mgm.exports = assign_tuple.3; - let is_async = ModuleGraph::is_async(compilation, source_module); - ModuleGraph::set_async(compilation, *target_module, is_async); + let is_async = ModuleGraph::is_async( + &compilation.collect_build_module_graph_effects_artifact, + source_module, + ); + ModuleGraph::set_async( + &mut compilation.collect_build_module_graph_effects_artifact, + *target_module, + is_async, + ); } pub fn move_module_connections( @@ -1009,11 +1017,6 @@ impl<'a> ModuleGraph<'a> { } has_connections } - - pub fn is_async(compilation: &Compilation, module_id: &ModuleIdentifier) -> bool { - compilation.async_modules_artifact.contains(module_id) - } - pub fn is_deferred( &self, imported_by_defer_modules_artifact: &ImportedByDeferModulesArtifact, @@ -1029,22 +1032,6 @@ impl<'a> ModuleGraph<'a> { !module.build_meta().has_top_level_await } - pub fn set_async( - compilation: &mut Compilation, - module_id: ModuleIdentifier, - is_async: bool, - ) -> bool { - let original = Self::is_async(compilation, &module_id); - if original == is_async { - return false; - } - if original { - compilation.async_modules_artifact.remove(&module_id) - } else { - compilation.async_modules_artifact.insert(module_id) - } - } - pub fn get_outgoing_connections( &self, module_id: &ModuleIdentifier, @@ -1315,3 +1302,28 @@ impl<'a> ModuleGraph<'a> { } } } + +impl<'a> ModuleGraph<'a> { + pub fn set_async( + artifact: &mut CollectModuleGraphEffectsArtifact, + module_id: ModuleIdentifier, + is_async: bool, + ) -> bool { + let original = ModuleGraph::is_async(artifact, &module_id); + if original == is_async { + return false; + } + if original { + artifact.async_module_info.remove(&module_id) + } else { + artifact.async_module_info.insert(module_id) + } + } + + pub fn is_async( + artifact: &CollectModuleGraphEffectsArtifact, + module_id: &ModuleIdentifier, + ) -> bool { + artifact.async_module_info.contains(module_id) + } +} diff --git a/crates/rspack_plugin_esm_library/src/dependency/dyn_import.rs b/crates/rspack_plugin_esm_library/src/dependency/dyn_import.rs index 39673ee4bfbe..9da51164d45a 100644 --- a/crates/rspack_plugin_esm_library/src/dependency/dyn_import.rs +++ b/crates/rspack_plugin_esm_library/src/dependency/dyn_import.rs @@ -66,7 +66,7 @@ fn then_expr( } runtime_requirements.insert(RuntimeGlobals::CREATE_FAKE_NAMESPACE_OBJECT); if ModuleGraph::is_async( - compilation, + &compilation.collect_build_module_graph_effects_artifact, compilation .get_module_graph() .module_identifier_by_dependency_id(dep_id) diff --git a/crates/rspack_plugin_esm_library/src/plugin.rs b/crates/rspack_plugin_esm_library/src/plugin.rs index b2a8ac64a8f6..92c4313c8007 100644 --- a/crates/rspack_plugin_esm_library/src/plugin.rs +++ b/crates/rspack_plugin_esm_library/src/plugin.rs @@ -14,7 +14,9 @@ use rspack_core::{ CompilationRuntimeRequirementInTree, CompilerCompilation, ConcatenatedModuleInfo, ConcatenationScope, DependencyType, ExternalModuleInfo, Logger, ModuleGraph, ModuleIdentifier, ModuleInfo, ModuleType, NormalModuleFactoryParser, ParserAndGenerator, ParserOptions, Plugin, - PrefetchExportsInfoMode, RuntimeGlobals, get_target, is_esm_dep_like, + PrefetchExportsInfoMode, RuntimeGlobals, + collect_module_graph_effects::artifact::CollectModuleGraphEffectsArtifact, + get_target, is_esm_dep_like, rspack_sources::{ReplaceSource, Source}, }; use rspack_error::Result; @@ -93,7 +95,11 @@ async fn render_chunk_content( } #[plugin_hook(CompilationFinishModules for EsmLibraryPlugin, stage = 100)] -async fn finish_modules(&self, compilation: &mut Compilation) -> Result<()> { +async fn finish_modules( + &self, + compilation: &mut Compilation, + _next_mutations: &mut CollectModuleGraphEffectsArtifact, +) -> Result<()> { let module_graph = compilation.get_module_graph(); let mut modules_map = IdentifierIndexMap::default(); let modules = module_graph.modules(); @@ -112,7 +118,10 @@ async fn finish_modules(&self, compilation: &mut Compilation) -> Result<()> { "module {module_identifier} has bailout reason: {reason}", )); should_scope_hoisting = false; - } else if ModuleGraph::is_async(compilation, module_identifier) { + } else if ModuleGraph::is_async( + &compilation.collect_build_module_graph_effects_artifact, + module_identifier, + ) { logger.debug(format!("module {module_identifier} is an async module")); should_scope_hoisting = false; } diff --git a/crates/rspack_plugin_javascript/src/dependency/esm/esm_compatibility_dependency.rs b/crates/rspack_plugin_javascript/src/dependency/esm/esm_compatibility_dependency.rs index 3b961d160dfc..d173134a2d20 100644 --- a/crates/rspack_plugin_javascript/src/dependency/esm/esm_compatibility_dependency.rs +++ b/crates/rspack_plugin_javascript/src/dependency/esm/esm_compatibility_dependency.rs @@ -76,7 +76,10 @@ impl DependencyTemplate for ESMCompatibilityDependencyTemplate { ))); } - if ModuleGraph::is_async(compilation, &module.identifier()) { + if ModuleGraph::is_async( + &compilation.collect_build_module_graph_effects_artifact, + &module.identifier(), + ) { runtime_requirements.insert(RuntimeGlobals::MODULE); runtime_requirements.insert(RuntimeGlobals::ASYNC_MODULE); init_fragments.push(Box::new(NormalInitFragment::new( diff --git a/crates/rspack_plugin_javascript/src/dependency/esm/esm_export_imported_specifier_dependency.rs b/crates/rspack_plugin_javascript/src/dependency/esm/esm_export_imported_specifier_dependency.rs index a5cd8d1d8630..e6636752165c 100644 --- a/crates/rspack_plugin_javascript/src/dependency/esm/esm_export_imported_specifier_dependency.rs +++ b/crates/rspack_plugin_javascript/src/dependency/esm/esm_export_imported_specifier_dependency.rs @@ -718,7 +718,10 @@ impl ESMExportImportedSpecifierDependency { ids[0].clone(), ValueKey::UsedName(UsedName::Normal(ids)), ); - let is_async = ModuleGraph::is_async(compilation, &module_identifier); + let is_async = ModuleGraph::is_async( + &compilation.collect_build_module_graph_effects_artifact, + &module_identifier, + ); ctxt .init_fragments .push(Box::new(ConditionalInitFragment::new( @@ -806,7 +809,10 @@ impl ESMExportImportedSpecifierDependency { .module_by_identifier(&module.identifier()) .expect("should have module graph module"); let exports_name = module.get_exports_argument(); - let is_async = ModuleGraph::is_async(compilation, &module.identifier()); + let is_async = ModuleGraph::is_async( + &compilation.collect_build_module_graph_effects_artifact, + &module.identifier(), + ); ctxt.init_fragments.push( NormalInitFragment::new( format!( diff --git a/crates/rspack_plugin_javascript/src/dependency/esm/esm_import_dependency.rs b/crates/rspack_plugin_javascript/src/dependency/esm/esm_import_dependency.rs index 81eb82631067..3849cf14b8f8 100644 --- a/crates/rspack_plugin_javascript/src/dependency/esm/esm_import_dependency.rs +++ b/crates/rspack_plugin_javascript/src/dependency/esm/esm_import_dependency.rs @@ -230,7 +230,7 @@ pub fn esm_import_dependency_apply( emitted_modules.insert(target_module, merged_runtime_condition); } - let is_async_module = matches!(target_module, Some(target_module) if ModuleGraph::is_async(compilation, &target_module.identifier())); + let is_async_module = matches!(target_module, Some(target_module) if ModuleGraph::is_async(&compilation.collect_build_module_graph_effects_artifact, &target_module.identifier())); if is_async_module { init_fragments.push(Box::new(ConditionalInitFragment::new( content.0, diff --git a/crates/rspack_plugin_javascript/src/plugin/flag_dependency_exports_plugin.rs b/crates/rspack_plugin_javascript/src/plugin/flag_dependency_exports_plugin.rs index dbab93c82150..f27576277e8c 100644 --- a/crates/rspack_plugin_javascript/src/plugin/flag_dependency_exports_plugin.rs +++ b/crates/rspack_plugin_javascript/src/plugin/flag_dependency_exports_plugin.rs @@ -5,7 +5,9 @@ use rspack_core::{ EvaluatedInlinableValue, ExportInfo, ExportInfoData, ExportNameOrSpec, ExportProvided, ExportSpecExports, ExportsInfo, ExportsInfoData, ExportsOfExportsSpec, ExportsSpec, Logger, ModuleGraph, ModuleGraphCacheArtifact, ModuleGraphConnection, ModuleIdentifier, Nullable, Plugin, - PrefetchExportsInfoMode, get_target, + PrefetchExportsInfoMode, + collect_module_graph_effects::artifact::CollectModuleGraphEffectsArtifact, + get_target, incremental::{self, IncrementalPasses}, }; use rspack_error::Result; @@ -184,11 +186,16 @@ pub struct DefaultExportInfo<'a> { pub struct FlagDependencyExportsPlugin; #[plugin_hook(CompilationFinishModules for FlagDependencyExportsPlugin)] -async fn finish_modules(&self, compilation: &mut Compilation) -> Result<()> { - let modules: IdentifierSet = if let Some(mutations) = compilation +async fn finish_modules( + &self, + compilation: &mut Compilation, + artifact: &mut CollectModuleGraphEffectsArtifact, +) -> Result<()> { + let modules: IdentifierSet = if let Some(mutations) = artifact .incremental .mutations_read(IncrementalPasses::PROVIDED_EXPORTS) { + dbg!(&mutations); let modules = mutations.get_affected_modules_with_module_graph(&compilation.get_module_graph()); tracing::debug!(target: incremental::TRACING_TARGET, passes = %IncrementalPasses::PROVIDED_EXPORTS, %mutations, ?modules); let logger = compilation.get_logger("rspack.incremental.providedExports"); diff --git a/crates/rspack_plugin_javascript/src/plugin/infer_async_modules_plugin.rs b/crates/rspack_plugin_javascript/src/plugin/infer_async_modules_plugin.rs index 0bd5a5e90aad..f2d450543663 100644 --- a/crates/rspack_plugin_javascript/src/plugin/infer_async_modules_plugin.rs +++ b/crates/rspack_plugin_javascript/src/plugin/infer_async_modules_plugin.rs @@ -4,6 +4,7 @@ use rspack_collections::{IdentifierMap, IdentifierSet}; use rspack_core::{ Compilation, CompilationFinishModules, DependencyType, Logger, ModuleGraph, ModuleIdentifier, Plugin, + collect_module_graph_effects::artifact::CollectModuleGraphEffectsArtifact, incremental::{IncrementalPasses, Mutation, Mutations}, }; use rspack_error::Result; @@ -14,12 +15,16 @@ use rspack_hook::{plugin, plugin_hook}; pub struct InferAsyncModulesPlugin; #[plugin_hook(CompilationFinishModules for InferAsyncModulesPlugin)] -async fn finish_modules(&self, compilation: &mut Compilation) -> Result<()> { - if let Some(mutations) = compilation +async fn finish_modules( + &self, + compilation: &mut Compilation, + artifact: &mut CollectModuleGraphEffectsArtifact, +) -> Result<()> { + if let Some(read_mutations) = compilation .incremental .mutations_read(IncrementalPasses::INFER_ASYNC_MODULES) { - mutations + read_mutations .iter() .filter_map(|mutation| { if let Mutation::ModuleRemove { module } = mutation { @@ -29,7 +34,10 @@ async fn finish_modules(&self, compilation: &mut Compilation) -> Result<()> { } }) .for_each(|module| { - compilation.async_modules_artifact.remove(module); + compilation + .collect_build_module_graph_effects_artifact + .async_module_info + .remove(module); }); } @@ -46,39 +54,38 @@ async fn finish_modules(&self, compilation: &mut Compilation) -> Result<()> { } } - let mut mutations = compilation + let mut collect_mutations = artifact .incremental .mutations_writeable() .then(Mutations::default); - - set_sync_modules(compilation, sync_modules, &mut mutations); - set_async_modules(compilation, async_modules, &mut mutations); + set_sync_modules(compilation, sync_modules, artifact, &mut collect_mutations); + set_async_modules(compilation, async_modules, artifact, &mut collect_mutations); if compilation .incremental .mutations_readable(IncrementalPasses::INFER_ASYNC_MODULES) - && let Some(mutations) = &mutations + && let Some(collect_mutations) = &collect_mutations { let logger = compilation.get_logger("rspack.incremental.inferAsyncModules"); logger.log(format!( "{} modules are updated by set_async", - mutations.len() + collect_mutations.len() )); } - - if let Some(compilation_mutations) = compilation.incremental.mutations_write() - && let Some(mutations) = mutations + if let Some(artifact_mutations) = artifact.incremental.mutations_write() + && let Some(collect_mutations) = collect_mutations { - compilation_mutations.extend(mutations); + artifact_mutations.extend(collect_mutations); } - Ok(()) } - +// we need to calculate mutations for inferAsyncModules pass separately +// so make sure use collect_mutations to collect mutations other than artifact.mutations fn set_sync_modules( compilation: &mut Compilation, modules: LinkedHashSet, - mutations: &mut Option, + collect_module_graph_effects_artifact: &mut CollectModuleGraphEffectsArtifact, + collect_mutations: &mut Option, ) { let module_graph = compilation.get_module_graph(); let outgoing_connections = modules @@ -112,16 +119,20 @@ fn set_sync_modules( .collect::>() }) .iter() - .any(|out| ModuleGraph::is_async(compilation, out)) + .any(|out| ModuleGraph::is_async(collect_module_graph_effects_artifact, out)) { // We can't safely reset is_async to false if there are any outgoing module is async continue; } // The module is_async = false will also decide its parent module is_async, so if the module is_async = false // is not changed, this means its parent module will be not affected, so we stop the infer at here. - if ModuleGraph::set_async(compilation, module, false) { - if let Some(mutations) = mutations { - mutations.add(Mutation::ModuleSetAsync { module }); + if ModuleGraph::set_async( + &mut compilation.collect_build_module_graph_effects_artifact, + module, + false, + ) { + if let Some(collect_mutations) = collect_mutations { + collect_mutations.add(Mutation::ModuleSetAsync { module }); } let module_graph = compilation.get_module_graph(); module_graph @@ -149,16 +160,17 @@ fn set_sync_modules( fn set_async_modules( compilation: &mut Compilation, modules: LinkedHashSet, - mutations: &mut Option, + artifact: &mut CollectModuleGraphEffectsArtifact, + collect_mutations: &mut Option, ) { let mut queue = modules; let mut visited = IdentifierSet::from_iter(queue.iter().copied()); while let Some(module) = queue.pop_front() { - if ModuleGraph::set_async(compilation, module, true) - && let Some(mutations) = mutations + if ModuleGraph::set_async(artifact, module, true) + && let Some(collect_mutations) = collect_mutations { - mutations.add(Mutation::ModuleSetAsync { module }); + collect_mutations.add(Mutation::ModuleSetAsync { module }); } let module_graph = compilation.get_module_graph(); module_graph diff --git a/crates/rspack_plugin_javascript/src/plugin/module_concatenation_plugin.rs b/crates/rspack_plugin_javascript/src/plugin/module_concatenation_plugin.rs index 0a6db062eb81..0f8a9ed67be3 100644 --- a/crates/rspack_plugin_javascript/src/plugin/module_concatenation_plugin.rs +++ b/crates/rspack_plugin_javascript/src/plugin/module_concatenation_plugin.rs @@ -884,7 +884,10 @@ impl ModuleConcatenationPlugin { return (false, false, module_id, bailout_reason); } - if ModuleGraph::is_async(compilation, &module_id) { + if ModuleGraph::is_async( + &compilation.collect_build_module_graph_effects_artifact, + &module_id, + ) { bailout_reason.push("Module is async".into()); return (false, false, module_id, bailout_reason); } diff --git a/crates/rspack_plugin_library/src/assign_library_plugin.rs b/crates/rspack_plugin_library/src/assign_library_plugin.rs index bcb5891416fc..01a17bf733af 100644 --- a/crates/rspack_plugin_library/src/assign_library_plugin.rs +++ b/crates/rspack_plugin_library/src/assign_library_plugin.rs @@ -8,7 +8,9 @@ use rspack_core::{ CompilationAdditionalChunkRuntimeRequirements, CompilationFinishModules, CompilationParams, CompilerCompilation, EntryData, ExportProvided, Filename, LibraryExport, LibraryName, LibraryNonUmdObject, LibraryOptions, ModuleIdentifier, PathData, Plugin, PrefetchExportsInfoMode, - RuntimeGlobals, SourceType, UsageState, get_entry_runtime, property_access, + RuntimeGlobals, SourceType, UsageState, + collect_module_graph_effects::artifact::CollectModuleGraphEffectsArtifact, + get_entry_runtime, property_access, rspack_sources::{ConcatSource, RawStringSource, SourceExt}, to_identifier, }; @@ -429,7 +431,11 @@ async fn strict_runtime_bailout( } #[plugin_hook(CompilationFinishModules for AssignLibraryPlugin)] -async fn finish_modules(&self, compilation: &mut Compilation) -> Result<()> { +async fn finish_modules( + &self, + compilation: &mut Compilation, + _next_mutations: &mut CollectModuleGraphEffectsArtifact, +) -> Result<()> { let mut runtime_info = Vec::with_capacity(compilation.entries.len()); for (entry_name, entry) in compilation.entries.iter() { let EntryData { diff --git a/crates/rspack_plugin_library/src/export_property_library_plugin.rs b/crates/rspack_plugin_library/src/export_property_library_plugin.rs index 4b44a2b66e78..cf1990cb100c 100644 --- a/crates/rspack_plugin_library/src/export_property_library_plugin.rs +++ b/crates/rspack_plugin_library/src/export_property_library_plugin.rs @@ -4,6 +4,7 @@ use rspack_core::{ CanInlineUse, ChunkUkey, Compilation, CompilationAdditionalChunkRuntimeRequirements, CompilationFinishModules, CompilationParams, CompilerCompilation, EntryData, LibraryExport, LibraryOptions, LibraryType, ModuleIdentifier, Plugin, RuntimeGlobals, UsageState, + collect_module_graph_effects::artifact::CollectModuleGraphEffectsArtifact, get_entry_runtime, property_access, rspack_sources::{ConcatSource, RawStringSource, SourceExt}, }; @@ -110,7 +111,11 @@ async fn js_chunk_hash( } #[plugin_hook(CompilationFinishModules for ExportPropertyLibraryPlugin)] -async fn finish_modules(&self, compilation: &mut Compilation) -> Result<()> { +async fn finish_modules( + &self, + compilation: &mut Compilation, + _next_mutations: &mut CollectModuleGraphEffectsArtifact, +) -> Result<()> { let mut runtime_info = Vec::with_capacity(compilation.entries.len()); for (entry_name, entry) in compilation.entries.iter() { let EntryData { diff --git a/crates/rspack_plugin_library/src/module_library_plugin.rs b/crates/rspack_plugin_library/src/module_library_plugin.rs index c13388fa3105..d0c2c438440c 100644 --- a/crates/rspack_plugin_library/src/module_library_plugin.rs +++ b/crates/rspack_plugin_library/src/module_library_plugin.rs @@ -72,7 +72,10 @@ async fn render_startup( return Ok(()); }; let mut source = ConcatSource::default(); - let is_async = ModuleGraph::is_async(compilation, module); + let is_async = ModuleGraph::is_async( + &compilation.collect_build_module_graph_effects_artifact, + module, + ); let module_graph = compilation.get_module_graph(); source.add(render_source.source.clone()); // export { local as exported } diff --git a/crates/rspack_plugin_progress/src/lib.rs b/crates/rspack_plugin_progress/src/lib.rs index 2e51b32c075b..3064fa7ea207 100644 --- a/crates/rspack_plugin_progress/src/lib.rs +++ b/crates/rspack_plugin_progress/src/lib.rs @@ -19,6 +19,7 @@ use rspack_core::{ CompilationOptimizeTree, CompilationParams, CompilationProcessAssets, CompilationSeal, CompilationSucceedModule, CompilerAfterEmit, CompilerClose, CompilerCompilation, CompilerEmit, CompilerFinishMake, CompilerId, CompilerMake, CompilerThisCompilation, ModuleIdentifier, Plugin, + collect_module_graph_effects::artifact::CollectModuleGraphEffectsArtifact, }; use rspack_error::Result; use rspack_hook::{plugin, plugin_hook}; @@ -422,7 +423,11 @@ async fn finish_make(&self, _compilation: &mut Compilation) -> Result<()> { } #[plugin_hook(CompilationFinishModules for ProgressPlugin)] -async fn finish_modules(&self, _compilation: &mut Compilation) -> Result<()> { +async fn finish_modules( + &self, + _compilation: &mut Compilation, + _mutations: &mut CollectModuleGraphEffectsArtifact, +) -> Result<()> { self.sealing_hooks_report("finish modules", 0).await } diff --git a/crates/rspack_plugin_rstest/src/import_dependency.rs b/crates/rspack_plugin_rstest/src/import_dependency.rs index b0200ba192ae..b0aab369105a 100644 --- a/crates/rspack_plugin_rstest/src/import_dependency.rs +++ b/crates/rspack_plugin_rstest/src/import_dependency.rs @@ -163,7 +163,7 @@ fn module_namespace_promise_rstest( } runtime_requirements.insert(RuntimeGlobals::CREATE_FAKE_NAMESPACE_OBJECT); if ModuleGraph::is_async( - compilation, + &compilation.collect_build_module_graph_effects_artifact, compilation .get_module_graph() .module_identifier_by_dependency_id(dep_id) diff --git a/crates/rspack_plugin_wasm/src/parser_and_generator.rs b/crates/rspack_plugin_wasm/src/parser_and_generator.rs index 5ace9816fcb1..cf7806e21320 100644 --- a/crates/rspack_plugin_wasm/src/parser_and_generator.rs +++ b/crates/rspack_plugin_wasm/src/parser_and_generator.rs @@ -193,7 +193,10 @@ impl ParserAndGenerator for AsyncWasmParserAndGenerator { let mut len_buffer = itoa::Buffer::new(); let len_str = len_buffer.format(len); let import_var = format!("rspack_import_{}", len_str); - if ModuleGraph::is_async(compilation, &mgm.module_identifier) { + if ModuleGraph::is_async( + &compilation.collect_build_module_graph_effects_artifact, + &mgm.module_identifier, + ) { promises.push(import_var.clone()); } DepModule {