chore: merge origin main

Author: SyMind

crates/rspack_core/src/cache/persistent/mod.rs

@@ -188,7 +188,7 @@ impl Cache for PersistentCache {
 
   async fn before_make(&mut self, make_artifact: &mut MakeArtifact) {
     // TODO When does not need to pass variables through make_artifact.state, use compilation.is_rebuild to check
-    if matches!(make_artifact.state, MakeArtifactState::Uninitialized(..)) {
+    if matches!(make_artifact.state, MakeArtifactState::Uninitialized) {
       match self.make_occasion.recovery().await {
         Ok(artifact) => *make_artifact = artifact,
         Err(err) => self.warnings.push(err.to_string()),

crates/rspack_core/src/cache/persistent/occasion/make/alternatives/dependency.rs

@@ -0,0 +1,35 @@
+use rspack_cacheable::{cacheable, cacheable_dyn, utils::OwnedOrRef};
+
+use crate::{
+  AffectType, AsContextDependency, AsDependencyCodeGeneration, AsModuleDependency, BoxDependency,
+  Dependency, DependencyId,
+};
+
+#[cacheable]
+#[derive(Debug, Clone, Default)]
+pub struct TempDependency {
+  id: DependencyId,
+}
+
+impl TempDependency {
+  pub fn transform_from(dep: OwnedOrRef<BoxDependency>) -> OwnedOrRef<BoxDependency> {
+    OwnedOrRef::Owned(Box::new(TempDependency {
+      id: *dep.as_ref().id(),
+    }))
+  }
+}
+
+#[cacheable_dyn]
+impl Dependency for TempDependency {
+  fn id(&self) -> &DependencyId {
+    &self.id
+  }
+
+  fn could_affect_referencing_module(&self) -> AffectType {
+    unreachable!()
+  }
+}
+
+impl AsModuleDependency for TempDependency {}
+impl AsDependencyCodeGeneration for TempDependency {}
+impl AsContextDependency for TempDependency {}

crates/rspack_core/src/cache/persistent/occasion/make/alternatives/mod.rs

@@ -0,0 +1,5 @@
+mod dependency;
+mod module;
+
+pub use dependency::TempDependency;
+pub use module::TempModule;

crates/rspack_core/src/cache/persistent/occasion/make/alternatives/module.rs

@@ -0,0 +1,150 @@
+use std::borrow::Cow;
+
+use rspack_cacheable::{cacheable, cacheable_dyn, utils::OwnedOrRef};
+use rspack_collections::Identifiable;
+use rspack_error::{Result, impl_empty_diagnosable_trait};
+use rspack_hash::RspackHashDigest;
+use rspack_paths::ArcPathSet;
+use rspack_sources::BoxSource;
+use rspack_util::source_map::{ModuleSourceMapConfig, SourceMapKind};
+
+use crate::{
+  AsyncDependenciesBlockIdentifier, BoxModule, BuildInfo, BuildMeta, CodeGenerationResult,
+  Compilation, ConcatenationScope, Context, DependenciesBlock, DependencyId, FactoryMeta, Module,
+  ModuleGraph, ModuleIdentifier, ModuleType, RuntimeSpec, SourceType, ValueCacheVersions,
+};
+
+#[cacheable]
+#[derive(Debug, Clone)]
+pub struct TempModule {
+  id: ModuleIdentifier,
+  build_info: BuildInfo,
+  build_meta: BuildMeta,
+  dependencies: Vec<DependencyId>,
+  blocks: Vec<AsyncDependenciesBlockIdentifier>,
+}
+
+impl TempModule {
+  pub fn transform_from(module: OwnedOrRef<BoxModule>) -> OwnedOrRef<BoxModule> {
+    let m = module.as_ref();
+    OwnedOrRef::Owned(Box::new(Self {
+      id: m.identifier(),
+      build_info: m.build_info().clone(),
+      build_meta: m.build_meta().clone(),
+      dependencies: m.get_dependencies().to_vec(),
+      // clean all of blocks
+      blocks: vec![],
+    }))
+  }
+}
+
+impl_empty_diagnosable_trait!(TempModule);
+
+impl ModuleSourceMapConfig for TempModule {
+  fn get_source_map_kind(&self) -> &SourceMapKind {
+    unreachable!()
+  }
+
+  fn set_source_map_kind(&mut self, _source_map: SourceMapKind) {
+    unreachable!()
+  }
+}
+
+#[cacheable_dyn]
+#[async_trait::async_trait]
+impl Module for TempModule {
+  fn factory_meta(&self) -> Option<&FactoryMeta> {
+    unreachable!()
+  }
+
+  fn set_factory_meta(&mut self, _factory_meta: FactoryMeta) {
+    unreachable!()
+  }
+
+  fn build_info(&self) -> &BuildInfo {
+    &self.build_info
+  }
+
+  fn build_info_mut(&mut self) -> &mut BuildInfo {
+    &mut self.build_info
+  }
+
+  fn build_meta(&self) -> &BuildMeta {
+    &self.build_meta
+  }
+
+  fn build_meta_mut(&mut self) -> &mut BuildMeta {
+    &mut self.build_meta
+  }
+
+  fn source_types(&self, _module_graph: &ModuleGraph) -> &[SourceType] {
+    unreachable!()
+  }
+
+  fn module_type(&self) -> &ModuleType {
+    unreachable!()
+  }
+
+  fn size(&self, _source_type: Option<&SourceType>, _compilation: Option<&Compilation>) -> f64 {
+    unreachable!()
+  }
+
+  fn source(&self) -> Option<&BoxSource> {
+    unreachable!()
+  }
+
+  fn readable_identifier(&self, _context: &Context) -> Cow<'_, str> {
+    unreachable!()
+  }
+
+  fn need_build(&self, _value_cache_versions: &ValueCacheVersions) -> bool {
+    // return true to make sure this module always rebuild
+    true
+  }
+
+  fn depends_on(&self, _modified_file: &ArcPathSet) -> bool {
+    // return true to make sure this module always rebuild
+    true
+  }
+
+  async fn code_generation(
+    &self,
+    _compilation: &Compilation,
+    _runtime: Option<&RuntimeSpec>,
+    _concatenation_scope: Option<ConcatenationScope>,
+  ) -> Result<CodeGenerationResult> {
+    unreachable!()
+  }
+
+  async fn get_runtime_hash(
+    &self,
+    _compilation: &Compilation,
+    _runtime: Option<&RuntimeSpec>,
+  ) -> Result<RspackHashDigest> {
+    unreachable!()
+  }
+}
+
+impl Identifiable for TempModule {
+  fn identifier(&self) -> rspack_collections::Identifier {
+    self.id
+  }
+}
+
+impl DependenciesBlock for TempModule {
+  fn add_block_id(&mut self, _block: AsyncDependenciesBlockIdentifier) {
+    unreachable!()
+  }
+  fn get_blocks(&self) -> &[AsyncDependenciesBlockIdentifier] {
+    &self.blocks
+  }
+  fn add_dependency_id(&mut self, _dependency: DependencyId) {
+    unreachable!()
+  }
+  fn remove_dependency_id(&mut self, _dependency: DependencyId) {
+    unreachable!()
+  }
+  fn get_dependencies(&self) -> &[DependencyId] {
+    &self.dependencies
+  }
+}

crates/rspack_core/src/cache/persistent/occasion/make/mod.rs

@@ -1,12 +1,14 @@
+mod alternatives;
 mod module_graph;
 
 use std::sync::Arc;
 
+use rspack_collections::IdentifierSet;
 use rspack_error::Result;
 
 use super::super::{Storage, cacheable_context::CacheableContext};
 use crate::{
-  FileCounter,
+  FileCounter, ModuleGraph,
   compilation::make::{MakeArtifact, MakeArtifactState},
 };
 
@@ -57,30 +59,27 @@ impl MakeOccasion {
 
   #[tracing::instrument(name = "Cache::Occasion::Make::recovery", skip_all)]
   pub async fn recovery(&self) -> Result<MakeArtifact> {
-    let mut artifact = MakeArtifact::default();
-
-    let (partial, module_to_lazy_make, force_build_dependencies, isolated_modules) =
+    let (partial, module_to_lazy_make, entry_dependencies) =
       module_graph::recovery_module_graph(&self.storage, &self.context).await?;
-    artifact.module_graph_partial = partial;
-    artifact.module_to_lazy_make = module_to_lazy_make;
-    artifact.state = MakeArtifactState::Uninitialized(force_build_dependencies, isolated_modules);
 
     // regenerate statistical data
-    // TODO set make_failed_module after module.diagnostic are cacheable
-    // make failed module include diagnostic that do not support cache, so recovery will not include failed module
-    artifact.make_failed_module = Default::default();
+    let mg = ModuleGraph::new([Some(&partial), None], None);
+    // recovery make_failed_module
+    let mut make_failed_module = IdentifierSet::default();
     // recovery *_dep
-    let mg = artifact.get_module_graph();
     let mut file_dep = FileCounter::default();
     let mut context_dep = FileCounter::default();
     let mut missing_dep = FileCounter::default();
     let mut build_dep = FileCounter::default();
-    for (_, module) in mg.modules() {
+    for (mid, module) in mg.modules() {
       let build_info = module.build_info();
       file_dep.add_batch_file(&build_info.file_dependencies);
       context_dep.add_batch_file(&build_info.context_dependencies);
       missing_dep.add_batch_file(&build_info.missing_dependencies);
       build_dep.add_batch_file(&build_info.build_dependencies);
+      if !module.diagnostics().is_empty() {
+        make_failed_module.insert(mid);
+      }
     }
 
     for (_, factorize_info) in mg.dependency_factorize_info_iter() {
@@ -89,11 +88,23 @@ impl MakeOccasion {
       missing_dep.add_batch_file(&factorize_info.missing_dependencies());
     }
 
-    artifact.file_dependencies = file_dep;
-    artifact.context_dependencies = context_dep;
-    artifact.missing_dependencies = missing_dep;
-    artifact.build_dependencies = build_dep;
+    Ok(MakeArtifact {
+      // write all of field here to avoid forget to update occasion when add new fields
+      // temporary data set to default
+      built_modules: Default::default(),
+      revoked_modules: Default::default(),
+      issuer_update_modules: Default::default(),
+
+      state: MakeArtifactState::Initialized,
+      module_graph_partial: partial,
+      module_to_lazy_make,
 
-    Ok(artifact)
+      make_failed_module,
+      entry_dependencies,
+      file_dependencies: file_dep,
+      context_dependencies: context_dep,
+      missing_dependencies: missing_dep,
+      build_dependencies: build_dep,
+    })
   }
 }