chore: add effects artifact

Author: hardfist

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<Vec<Diagnostic>>;
+
 pub type ModuleIdsArtifact = IdentifierMap<ModuleId>;
 pub type ChunkIdsArtifact = UkeyMap<ChunkUkey, ChunkId>;
 pub type CgcRuntimeRequirementsArtifact = UkeyMap<ChunkUkey, RuntimeGlobals>;

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();

crates/rspack_core/src/compilation/collect_module_graph_effects/artifact.rs

@@ -0,0 +1,11 @@
+use rspack_collections::{IdentifierMap, IdentifierSet};
+use rspack_error::Diagnostic;
+
+#[derive(Debug, Default)]
+pub struct CollectModuleGraphEffectsArtifact {
+  pub(crate) diagnostics: Vec<Diagnostic>,
+  pub(crate) dependencies_diagnostics: DependenciesDiagnostics,
+  pub(crate) async_module_info: IdentifierSet,
+}
+
+pub type DependenciesDiagnostics = IdentifierMap<Vec<Diagnostic>>;

crates/rspack_core/src/compilation/collect_module_graph_effects/mod.rs

@@ -0,0 +1,164 @@
+pub mod artifact;
+use std::mem;
+
+use rayon::iter::{IntoParallelRefIterator as _, ParallelIterator};
+use rspack_error::Result;
+
+use crate::{
+  Compilation, Logger as _, ModuleIdentifier,
+  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);
+  let mut incremental = mem::take(&mut compilation.incremental);
+  collect_build_module_graph_effects_inner(compilation, &mut artifact, &mut incremental).await?;
+  compilation.collect_build_module_graph_effects_artifact = artifact;
+  compilation.incremental = incremental;
+  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: &Compilation,
+  artifact: &mut CollectModuleGraphEffectsArtifact,
+  incremental: &mut incremental::Incremental,
+) -> Result<()> {
+  let logger = ctx.get_logger("rspack.Compilation");
+  if let Some(mutations) = 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)
+    .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();
+
+  // take make diagnostics
+  let diagnostics = ctx.build_module_graph_artifact.diagnostics();
+  artifact.diagnostics.extend(diagnostics);
+  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::<Vec<_>>();
+      (*module_identifier, diagnostics)
+    })
+    .collect();
+  let all_modules_diagnostics = if mutations.is_some() {
+    artifact
+      .dependencies_diagnostics
+      .extend(dependencies_diagnostics);
+    artifact.dependencies_diagnostics.clone()
+  } else {
+    dependencies_diagnostics
+  };
+  artifact
+    .diagnostics
+    .extend(all_modules_diagnostics.into_values().flatten());
+}