chore: fix check error

hardfist · hardfist · commit f5bce23961e6 · 2025-11-14T17:31:07.000+08:00
diff --git 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<bool> {
     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_core/src/compilation/collect_module_graph_effects/artifact.rs b/crates/rspack_core/src/compilation/collect_module_graph_effects/artifact.rs
@@ -5,7 +5,7 @@ use rspack_error::Diagnostic;
 pub struct CollectModuleGraphEffectsArtifact {
   pub(crate) diagnostics: Vec<Diagnostic>,
   pub(crate) dependencies_diagnostics: DependenciesDiagnostics,
-  pub(crate) async_module_info: IdentifierSet,
+  pub async_module_info: IdentifierSet,
 }
 
 pub type DependenciesDiagnostics = IdentifierMap<Vec<Diagnostic>>;
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
@@ -5,7 +5,7 @@ use rayon::iter::{IntoParallelRefIterator as _, ParallelIterator};
 use rspack_error::Result;
 
 use crate::{
-  Compilation, Logger as _, ModuleIdentifier,
+  Compilation, Logger as _,
   collect_module_graph_effects::artifact::{
     CollectModuleGraphEffectsArtifact, DependenciesDiagnostics,
   },
@@ -22,7 +22,7 @@ pub async fn collect_build_module_graph_effects(compilation: &mut Compilation) -
 // 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: &Compilation,
+  ctx: &mut Compilation,
   artifact: &mut CollectModuleGraphEffectsArtifact,
   incremental: &mut incremental::Incremental,
 ) -> Result<()> {
diff --git a/crates/rspack_core/src/compilation/mod.rs b/crates/rspack_core/src/compilation/mod.rs
@@ -40,20 +40,19 @@ use rustc_hash::{FxHashMap as HashMap, FxHashSet as HashSet, FxHasher};
 use tracing::instrument;
 
 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::{
@@ -75,7 +74,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<CodeGenerationResults>, execute_module_id: &ExecuteModuleId));
-define_hook!(CompilationFinishModules: Series(compilation: &Compilation));
+define_hook!(CompilationFinishModules: Series(compilation: &mut Compilation));
 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);
diff --git a/crates/rspack_core/src/compiler/rebuild.rs b/crates/rspack_core/src/compiler/rebuild.rs
@@ -99,6 +99,9 @@ impl Compiler {
       if new_compilation
         .incremental
         .mutations_readable(IncrementalPasses::DEPENDENCIES_DIAGNOSTICS)
+        || new_compilation
+          .incremental
+          .mutations_readable(IncrementalPasses::INFER_ASYNC_MODULES)
       {
         new_compilation.collect_build_module_graph_effects_artifact =
           std::mem::take(&mut self.compilation.collect_build_module_graph_effects_artifact);
diff --git a/crates/rspack_core/src/module_graph/mod.rs b/crates/rspack_core/src/module_graph/mod.rs
@@ -446,7 +446,7 @@ impl<'a> ModuleGraph<'a> {
     new_mgm.exports = assign_tuple.3;
 
     let is_async = ModuleGraph::is_async(
-      &mut compilation.collect_build_module_graph_effects_artifact,
+      &compilation.collect_build_module_graph_effects_artifact,
       source_module,
     );
     ModuleGraph::set_async(
diff --git a/crates/rspack_plugin_esm_library/src/dependency/dyn_import.rs b/crates/rspack_plugin_esm_library/src/dependency/dyn_import.rs
@@ -62,7 +62,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
@@ -109,7 +109,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
@@ -74,7 +74,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
@@ -719,7 +719,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(
@@ -798,7 +801,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
@@ -230,7 +230,7 @@ pub fn esm_import_dependency_apply<T: ModuleDependency>(
     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
@@ -5,8 +5,7 @@ use rspack_core::{
   EvaluatedInlinableValue, ExportInfo, ExportInfoData, ExportNameOrSpec, ExportProvided,
   ExportSpecExports, ExportsInfo, ExportsInfoData, ExportsOfExportsSpec, ExportsSpec, Logger,
   ModuleGraph, ModuleGraphCacheArtifact, ModuleGraphConnection, ModuleIdentifier, Nullable, Plugin,
-  PrefetchExportsInfoMode, get_target,
-  incremental::{self, IncrementalPasses},
+  PrefetchExportsInfoMode, get_target, incremental, incremental::IncrementalPasses,
 };
 use rspack_error::Result;
 use rspack_hook::{plugin, plugin_hook};
@@ -184,11 +183,7 @@ pub struct DefaultExportInfo<'a> {
 pub struct FlagDependencyExportsPlugin;
 
 #[plugin_hook(CompilationFinishModules for FlagDependencyExportsPlugin)]
-async fn finish_modules(
-  &self,
-  compilation: &Compilation,
-  module_graph: &mut ModuleGraph,
-) -> Result<()> {
+async fn finish_modules(&self, compilation: &mut Compilation) -> Result<()> {
   let modules: IdentifierSet = if let Some(mutations) = compilation
     .incremental
     .mutations_read(IncrementalPasses::PROVIDED_EXPORTS)
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
@@ -14,7 +14,7 @@ use rspack_hook::{plugin, plugin_hook};
 pub struct InferAsyncModulesPlugin;
 
 #[plugin_hook(CompilationFinishModules for InferAsyncModulesPlugin)]
-async fn finish_modules(&self, compilation: &Compilation) -> Result<()> {
+async fn finish_modules(&self, compilation: &mut Compilation) -> Result<()> {
   if let Some(mutations) = compilation
     .incremental
     .mutations_read(IncrementalPasses::INFER_ASYNC_MODULES)
@@ -29,7 +29,10 @@ async fn finish_modules(&self, compilation: &Compilation) -> Result<()> {
         }
       })
       .for_each(|module| {
-        compilation.async_modules_artifact.remove(module);
+        compilation
+          .collect_build_module_graph_effects_artifact
+          .async_module_info
+          .remove(module);
       });
   }
 
@@ -76,7 +79,7 @@ async fn finish_modules(&self, compilation: &Compilation) -> Result<()> {
 }
 
 fn set_sync_modules(
-  compilation: &Compilation,
+  compilation: &mut Compilation,
   modules: LinkedHashSet<ModuleIdentifier>,
   mutations: &mut Option<Mutations>,
 ) {
@@ -112,14 +115,23 @@ fn set_sync_modules(
           .collect::<Vec<_>>()
       })
       .iter()
-      .any(|out| ModuleGraph::is_async(compilation, out))
+      .any(|out| {
+        ModuleGraph::is_async(
+          &compilation.collect_build_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 ModuleGraph::set_async(
+      &mut compilation.collect_build_module_graph_effects_artifact,
+      module,
+      false,
+    ) {
       if let Some(mutations) = mutations {
         mutations.add(Mutation::ModuleSetAsync { module });
       }
@@ -147,16 +159,19 @@ fn set_sync_modules(
 }
 
 fn set_async_modules(
-  compilation: &Compilation,
+  compilation: &mut Compilation,
   modules: LinkedHashSet<ModuleIdentifier>,
   mutations: &mut Option<Mutations>,
 ) {
   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(
+      &mut compilation.collect_build_module_graph_effects_artifact,
+      module,
+      true,
+    ) && let Some(mutations) = mutations
     {
       mutations.add(Mutation::ModuleSetAsync { module });
     }
diff --git a/crates/rspack_plugin_javascript/src/plugin/module_concatenation_plugin.rs b/crates/rspack_plugin_javascript/src/plugin/module_concatenation_plugin.rs
@@ -883,7 +883,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/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
@@ -422,7 +422,7 @@ async fn finish_make(&self, _compilation: &mut Compilation) -> Result<()> {
 }
 
 #[plugin_hook(CompilationFinishModules for ProgressPlugin)]
-async fn finish_modules(&self, _compilation: &Compilation) -> Result<()> {
+async fn finish_modules(&self, _compilation: &mut Compilation) -> 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
@@ -161,7 +161,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)

Original file line number	Diff line number	Diff line change
`@@ -257,6 +257,9 @@ impl JsModuleGraph {`
`257`	`257`	`#[napi(ts_args_type = "module: Module")]`
`258`	`258`	`pub fn is_async(&self, module: ModuleObjectRef) -> napi::Result<bool> {`
`259`	`259`	`let (compilation, _) = self.as_ref()?;`
`260`		`- Ok(ModuleGraph::is_async(compilation, &module.identifier))`
	`260`	`+ Ok(ModuleGraph::is_async(`
	`261`	`+ &compilation.collect_build_module_graph_effects_artifact,`
	`262`	`+ &module.identifier,`
	`263`	`+ ))`
`261`	`264`	`}`
`262`	`265`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ use rspack_error::Diagnostic;`
`5`	`5`	`pub struct CollectModuleGraphEffectsArtifact {`
`6`	`6`	`pub(crate) diagnostics: Vec<Diagnostic>,`
`7`	`7`	`pub(crate) dependencies_diagnostics: DependenciesDiagnostics,`
`8`		`- pub(crate) async_module_info: IdentifierSet,`
	`8`	`+ pub async_module_info: IdentifierSet,`
`9`	`9`	`}`
`10`	`10`
`11`	`11`	`pub type DependenciesDiagnostics = IdentifierMap<Vec<Diagnostic>>;`
Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ fn then_expr(`
`62`	`62`	`}`
`63`	`63`	`runtime_requirements.insert(RuntimeGlobals::CREATE_FAKE_NAMESPACE_OBJECT);`
`64`	`64`	`if ModuleGraph::is_async(`
`65`		`- compilation,`
	`65`	`+ &compilation.collect_build_module_graph_effects_artifact,`
`66`	`66`	`compilation`
`67`	`67`	`.get_module_graph()`
`68`	`68`	`.module_identifier_by_dependency_id(dep_id)`