fix(cache): skip context module cache

Author: hardfist

crates/rspack_core/src/cache/codec.rs

@@ -9,18 +9,11 @@ use rspack_paths::Utf8PathBuf;
 
 /// Internal cacheable context for serialization
 #[derive(Debug, Clone)]
-pub(crate) struct CacheCodecContext {
+struct Context {
   portable_project_root: Option<Utf8PathBuf>,
-  omit_module_factory_state: bool,
 }
 
-impl CacheCodecContext {
-  pub(crate) fn omit_module_factory_state(&self) -> bool {
-    self.omit_module_factory_state
-  }
-}
-
-impl rspack_cacheable::CacheableContext for CacheCodecContext {
+impl rspack_cacheable::CacheableContext for Context {
   fn project_root(&self) -> Option<&Path> {
     self.portable_project_root.as_ref().map(|p| p.as_std_path())
   }
@@ -44,24 +37,14 @@ impl rspack_cacheable::CacheableContext for CacheCodecContext {
 /// ```
 #[derive(Debug, Clone)]
 pub struct CacheCodec {
-  context: CacheCodecContext,
+  context: Context,
 }
 
 impl CacheCodec {
   pub fn new(portable_project_root: Option<Utf8PathBuf>) -> Self {
     Self {
-      context: CacheCodecContext {
-        portable_project_root,
-        omit_module_factory_state: false,
-      },
-    }
-  }
-
-  pub(crate) fn new_for_module_cache(portable_project_root: Option<Utf8PathBuf>) -> Self {
-    Self {
-      context: CacheCodecContext {
+      context: Context {
         portable_project_root,
-        omit_module_factory_state: true,
       },
     }
   }

crates/rspack_core/src/cache/mod.rs

@@ -9,6 +9,5 @@ pub use cache_entry::{
   CachedExtractedComments, CachedMinimizeEntry, CachedSourceMapDevToolPluginEntry,
 };
 pub use codec::CacheCodec;
-pub(crate) use codec::CacheCodecContext;
 pub use options::{BuildDepsOptions, PersistentCacheOptions, StorageOptions};
 pub use snapshot::{PathMatcher, SnapshotOptions, SnapshotStrategyOptions};

crates/rspack_core/src/compilation/build_module_graph/graph_updater/repair/add.rs

@@ -114,12 +114,16 @@ impl Task<TaskContext> for AddTask {
       return Ok(vec![]);
     }
 
-    let module_build = match context.module_cache.restore(module_identifier)? {
-      Some(mut build_result) => {
-        build_result.module.update_cache_module(&mut module);
-        ModuleBuild::Cached(build_result)
+    let module_build = if module.as_normal_module().is_some() {
+      match context.module_cache.restore(module_identifier)? {
+        Some(mut build_result) => {
+          build_result.module.update_cache_module(&mut module);
+          ModuleBuild::Cached(build_result)
+        }
+        None => ModuleBuild::Fresh(module),
       }
-      None => ModuleBuild::Fresh(module),
+    } else {
+      ModuleBuild::Fresh(module)
     };
 
     context

crates/rspack_core/src/context_module.rs

@@ -7,15 +7,8 @@ use futures::future::BoxFuture;
 use indoc::formatdoc;
 use itertools::Itertools;
 use rspack_cacheable::{
-  __private::rkyv::{
-    Place,
-    de::Pooling,
-    rancor::Fallible,
-    ser::Sharing,
-    with::{ArchiveWith, DeserializeWith, SerializeWith},
-  },
-  ContextGuard, Error as CacheableError, cacheable, cacheable_dyn,
-  with::{AsCacheable, AsOption, AsPreset, AsVec},
+  cacheable, cacheable_dyn,
+  with::{AsCacheable, AsOption, AsPreset, AsVec, Unsupported},
 };
 use rspack_collections::{Identifiable, Identifier};
 use rspack_error::{Result, impl_empty_diagnosable_trait};
@@ -41,9 +34,8 @@ use crate::{
   LibIdentOptions, Module, ModuleArgument, ModuleCodeGenerationContext, ModuleCodeTemplate,
   ModuleGraph, ModuleId, ModuleIdsArtifact, ModuleLayer, ModuleType, NeedBuildContext,
   RealDependencyLocation, ReferencedSpecifier, Resolve, RuntimeGlobals, RuntimeGlobalsRenderMode,
-  RuntimeSpec, SnapshotValidationResult, SourceType, cache::CacheCodecContext, contextify,
-  get_exports_type_with_strict, get_outgoing_async_modules, impl_module_meta_info,
-  module_update_hash, property_access, to_path,
+  RuntimeSpec, SnapshotValidationResult, SourceType, contextify, get_exports_type_with_strict,
+  get_outgoing_async_modules, impl_module_meta_info, module_update_hash, property_access, to_path,
 };
 
 static CHUNK_NAME_INDEX_PLACEHOLDER: &str = "[index]";
@@ -282,65 +274,6 @@ pub type ResolveContextModuleDependencies = Arc<
     + Sync,
 >;
 
-/// Context dependency resolution is factory state and is restored from the
-/// fresh module by `update_cache_module`, just like webpack's
-/// `ContextModule.resolveDependencies`.
-struct SkipResolveContextModuleDependencies;
-
-impl ArchiveWith<ResolveContextModuleDependencies> for SkipResolveContextModuleDependencies {
-  type Archived = ();
-  type Resolver = ();
-
-  fn resolve_with(
-    _field: &ResolveContextModuleDependencies,
-    _resolver: Self::Resolver,
-    _out: Place<Self::Archived>,
-  ) {
-  }
-}
-
-impl<S> SerializeWith<ResolveContextModuleDependencies, S> for SkipResolveContextModuleDependencies
-where
-  S: Fallible<Error = CacheableError> + Sharing + ?Sized,
-{
-  fn serialize_with(
-    _field: &ResolveContextModuleDependencies,
-    serializer: &mut S,
-  ) -> std::result::Result<Self::Resolver, CacheableError> {
-    let context =
-      ContextGuard::sharing_guard(serializer)?.downcast_context::<CacheCodecContext>()?;
-    if context.omit_module_factory_state() {
-      Ok(())
-    } else {
-      Err(CacheableError::UnsupportedField)
-    }
-  }
-}
-
-impl<D> DeserializeWith<(), ResolveContextModuleDependencies, D>
-  for SkipResolveContextModuleDependencies
-where
-  D: Fallible<Error = CacheableError> + Pooling + ?Sized,
-{
-  fn deserialize_with(
-    _field: &(),
-    deserializer: &mut D,
-  ) -> std::result::Result<ResolveContextModuleDependencies, CacheableError> {
-    let context =
-      ContextGuard::pooling_guard(deserializer)?.downcast_context::<CacheCodecContext>()?;
-    if !context.omit_module_factory_state() {
-      return Err(CacheableError::UnsupportedField);
-    }
-    Ok(Arc::new(|_| {
-      Box::pin(async {
-        Err(rspack_error::error!(
-          "Context module resolver was not restored from the fresh module"
-        ))
-      })
-    }))
-  }
-}
-
 #[impl_source_map_config]
 #[cacheable]
 #[derive(Debug)]
@@ -353,7 +286,7 @@ pub struct ContextModule {
   build_info: BuildInfo,
   build_meta: BuildMeta,
   #[debug(skip)]
-  #[cacheable(with=SkipResolveContextModuleDependencies)]
+  #[cacheable(with=Unsupported)]
   resolve_dependencies: ResolveContextModuleDependencies,
   force_build: bool,
 }

crates/rspack_core/src/new_cache/module_cache.rs

@@ -7,13 +7,16 @@ use crate::{
   cache::{CacheCodec, SnapshotStrategyOptions},
 };
 
-/// Persistent cache for completed module builds.
+/// Persistent cache for completed normal module builds.
 ///
 /// Webpack caches the `Module` itself. Rspack keeps dependencies and blocks in
 /// `BuildResult` until they are inserted into the module graph, so caching the
 /// complete build result is the equivalent representation. The serialized form
 /// also gives each compilation an exclusively owned module while the generic
 /// cache continues to expose shared immutable values.
+///
+/// Context modules are intentionally built fresh until their factory state can
+/// be restored without serializing the process-local dependency resolver.
 #[derive(Debug, Clone)]
 pub(crate) struct ModuleCache {
   cache: CacheFacade,
@@ -31,7 +34,7 @@ impl ModuleCache {
     };
     Self {
       cache: cache.facade("Compilation/modules"),
-      codec: CacheCodec::new_for_module_cache(project_root),
+      codec: CacheCodec::new(project_root),
       // Incremental make reuses the previous module graph and owns its own
       // invalidation path. Keep that fast path unchanged.
       enabled: options.experiments.new_cache.module && !is_rebuild,
@@ -66,8 +69,11 @@ impl ModuleCache {
     }
 
     let module = &mut result.module;
-    if (module.as_normal_module().is_some() || module.as_context_module().is_some())
-      && module.build_info().cacheable
+    if module.as_normal_module().is_none() {
+      return Ok(());
+    }
+
+    if module.build_info().cacheable
       && !module
         .diagnostics()
         .iter()

tests/rspack-test/cacheCases/common/module-cache-new-cache/rspack.config.js

@@ -55,7 +55,6 @@ module.exports = {
           } else {
             expect(builtModules).toEqual(['changed.js']);
             expect(stillValidModules.sort()).toEqual([
-              'context',
               'index.js',
               'stable.js',
               'value.js',