refactor: remove normalModule.loaders

crates/rspack_binding_api/Cargo.toml

@@ -61,7 +61,6 @@ once_cell                              = { workspace = true }
 rayon                                  = { workspace = true }
 regex                                  = { workspace = true }
 rspack_browser                         = { workspace = true, optional = true }
-rspack_cacheable                       = { workspace = true }
 rspack_ids                             = { workspace = true }
 rspack_javascript_compiler             = { workspace = true }
 rspack_loader_lightningcss             = { workspace = true }

crates/rspack_binding_api/src/modules/normal_module.rs

@@ -39,16 +39,6 @@ impl NormalModule {
         ReadonlyResourceDataWrapper::from(resource_resolved_data.clone()),
       )?
     });
-    let loaders = Object::from_raw(env.raw(), unsafe {
-      ToNapiValue::to_napi_value(
-        env.raw(),
-        module
-          .loaders()
-          .iter()
-          .map(JsLoaderItem::from)
-          .collect::<Vec<_>>(),
-      )?
-    });
 
     #[js_function]
     pub fn match_resource_getter(ctx: CallContext<'_>) -> napi::Result<Either<&str, ()>> {
@@ -115,11 +105,6 @@ impl NormalModule {
           .with_utf8_name("resourceResolveData")?
           .with_value(&resource_resolve_data),
       );
-      properties.push(
-        napi::Property::new()
-          .with_utf8_name("loaders")?
-          .with_value(&loaders),
-      );
       properties.push(
         napi::Property::new()
           .with_utf8_name("matchResource")?

crates/rspack_binding_api/src/plugins/js_loader/resolver.rs

@@ -1,9 +1,5 @@
 use std::{borrow::Cow, sync::Arc};
 
-use rspack_cacheable::{
-  cacheable, cacheable_dyn,
-  with::{AsOption, AsRefStr},
-};
 use rspack_collections::Identifier;
 use rspack_core::{
   BoxLoader, Context, Loader, ModuleRuleUseLoader, NormalModuleFactoryResolveLoader, ResolveResult,
@@ -15,14 +11,12 @@ use rspack_paths::Utf8Path;
 
 use super::{JsLoaderRspackPlugin, JsLoaderRspackPluginInner};
 
-#[cacheable]
 #[derive(Debug)]
 pub struct JsLoader(
   pub Identifier,
-  /* LoaderType */ #[cacheable(with=AsOption<AsRefStr>)] pub Option<Cow<'static, str>>,
+  /* LoaderType */ pub Option<Cow<'static, str>>,
 );
 
-#[cacheable_dyn]
 impl Loader<RunnerContext> for JsLoader {
   fn identifier(&self) -> Identifier {
     self.0

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

@@ -1,8 +1,9 @@
+use derive_more::Debug;
 use rspack_error::Result;
 
 use super::{TaskContext, build::BuildTask, lazy::ProcessUnlazyDependenciesTask};
 use crate::{
-  BoxDependency, Module, ModuleIdentifier, ModuleProfile,
+  BoxDependency, BoxLoader, Module, ModuleIdentifier, ModuleProfile,
   compilation::make::ForwardedIdSet,
   module_graph::{ModuleGraph, ModuleGraphModule},
   utils::task_loop::{Task, TaskResult, TaskType},
@@ -12,6 +13,8 @@ use crate::{
 pub struct AddTask {
   pub original_module_identifier: Option<ModuleIdentifier>,
   pub module: Box<dyn Module>,
+  #[debug(skip)]
+  pub loaders: Vec<BoxLoader>,
   pub module_graph_module: Box<ModuleGraphModule>,
   pub dependencies: Vec<BoxDependency>,
   pub current_profile: Option<ModuleProfile>,
@@ -112,6 +115,7 @@ impl Task<TaskContext> for AddTask {
       compiler_id: context.compiler_id,
       compilation_id: context.compilation_id,
       module: self.module,
+      loaders: self.loaders,
       current_profile: self.current_profile,
       resolver_factory: context.resolver_factory.clone(),
       compiler_options: context.compiler_options.clone(),

crates/rspack_core/src/compilation/make/graph_updater/repair/build.rs

@@ -1,14 +1,16 @@
 use std::{collections::VecDeque, sync::Arc};
 
+use derive_more::Debug;
 use rspack_fs::ReadableFileSystem;
 use rustc_hash::FxHashSet;
 
 use super::{
   TaskContext, lazy::ProcessUnlazyDependenciesTask, process_dependencies::ProcessDependenciesTask,
 };
 use crate::{
-  AsyncDependenciesBlock, BoxDependency, BuildContext, BuildResult, CompilationId, CompilerId,
-  CompilerOptions, DependencyParents, Module, ModuleProfile, ResolverFactory, SharedPluginDriver,
+  AsyncDependenciesBlock, BoxDependency, BoxLoader, BuildContext, BuildResult, CompilationId,
+  CompilerId, CompilerOptions, DependencyParents, Module, ModuleProfile, ResolverFactory,
+  SharedPluginDriver,
   compilation::make::{ForwardedIdSet, HasLazyDependencies, LazyDependencies},
   utils::{
     ResourceId,
@@ -21,6 +23,8 @@ pub struct BuildTask {
   pub compiler_id: CompilerId,
   pub compilation_id: CompilationId,
   pub module: Box<dyn Module>,
+  #[debug(skip)]
+  pub loaders: Vec<BoxLoader>,
   pub current_profile: Option<ModuleProfile>,
   pub resolver_factory: Arc<ResolverFactory>,
   pub compiler_options: Arc<CompilerOptions>,
@@ -43,6 +47,7 @@ impl Task<TaskContext> for BuildTask {
       plugin_driver,
       mut current_profile,
       mut module,
+      loaders,
       fs,
       forwarded_ids,
     } = *self;
@@ -65,6 +70,7 @@ impl Task<TaskContext> for BuildTask {
           resolver_factory: resolver_factory.clone(),
           plugin_driver: plugin_driver.clone(),
           fs: fs.clone(),
+          loaders,
         },
         None,
       )

crates/rspack_core/src/compilation/make/graph_updater/repair/factorize.rs

@@ -229,6 +229,7 @@ impl Task<TaskContext> for FactorizeResultTask {
     Ok(vec![Box::new(AddTask {
       original_module_identifier,
       module,
+      loaders: factory_result.loaders,
       module_graph_module: Box::new(mgm),
       dependencies,
       current_profile,

crates/rspack_core/src/context_module_factory.rs

@@ -340,9 +340,7 @@ impl ContextModuleFactory {
     data.add_missing_dependencies(missing_dependencies);
     // data.add_context_dependencies(context_dependencies);
 
-    let module_factory_result = ModuleFactoryResult {
-      module: Some(module),
-    };
+    let module_factory_result = ModuleFactoryResult::new_with_module(module);
     Ok((module_factory_result, context_module_options))
   }
 

crates/rspack_core/src/module.rs

@@ -27,9 +27,9 @@ use rustc_hash::{FxHashMap as HashMap, FxHashSet as HashSet};
 use serde::Serialize;
 
 use crate::{
-  AsyncDependenciesBlock, BindingCell, BoxDependency, BoxDependencyTemplate, BoxModuleDependency,
-  ChunkGraph, ChunkUkey, CodeGenerationResult, CollectedTypeScriptInfo, Compilation,
-  CompilationAsset, CompilationId, CompilerId, CompilerOptions, ConcatenationScope,
+  AsyncDependenciesBlock, BindingCell, BoxDependency, BoxDependencyTemplate, BoxLoader,
+  BoxModuleDependency, ChunkGraph, ChunkUkey, CodeGenerationResult, CollectedTypeScriptInfo,
+  Compilation, CompilationAsset, CompilationId, CompilerId, CompilerOptions, ConcatenationScope,
   ConnectionState, Context, ContextModule, DependenciesBlock, DependencyId, ExportProvided,
   ExternalModule, ModuleGraph, ModuleGraphCacheArtifact, ModuleLayer, ModuleType, NormalModule,
   PrefetchExportsInfoMode, RawModule, Resolve, ResolverFactory, RuntimeSpec, SelfModule,
@@ -45,6 +45,7 @@ pub struct BuildContext {
   pub resolver_factory: Arc<ResolverFactory>,
   pub plugin_driver: SharedPluginDriver,
   pub fs: Arc<dyn ReadableFileSystem>,
+  pub loaders: Vec<BoxLoader>,
 }
 
 #[cacheable]

crates/rspack_core/src/module_factory.rs

@@ -1,11 +1,12 @@
-use std::{fmt::Debug, sync::Arc};
+use std::sync::Arc;
 
+use derive_more::Debug;
 use rspack_error::{Diagnostic, Result};
 use rspack_paths::{ArcPath, ArcPathSet};
 
 use crate::{
-  BoxDependency, BoxModule, CompilationId, CompilerId, CompilerOptions, Context, ModuleIdentifier,
-  ModuleLayer, Resolve, ResolverFactory,
+  BoxDependency, BoxLoader, BoxModule, CompilationId, CompilerId, CompilerOptions, Context,
+  ModuleIdentifier, ModuleLayer, Resolve, ResolverFactory,
 };
 
 #[derive(Debug, Clone)]
@@ -69,22 +70,20 @@ impl ModuleFactoryCreateData {
 #[derive(Debug, Default)]
 pub struct ModuleFactoryResult {
   pub module: Option<BoxModule>,
+  #[debug(skip)]
+  pub loaders: Vec<BoxLoader>,
 }
 
 impl ModuleFactoryResult {
   pub fn new_with_module(module: BoxModule) -> Self {
     Self {
       module: Some(module),
+      loaders: vec![],
     }
   }
-
-  pub fn module(mut self, module: Option<BoxModule>) -> Self {
-    self.module = module;
-    self
-  }
 }
 
 #[async_trait::async_trait]
-pub trait ModuleFactory: Debug + Sync + Send {
+pub trait ModuleFactory: std::fmt::Debug + Sync + Send {
   async fn create(&self, data: &mut ModuleFactoryCreateData) -> Result<ModuleFactoryResult>;
 }

crates/rspack_core/src/normal_module.rs

@@ -33,14 +33,14 @@ use serde_json::json;
 use tracing::{Instrument, info_span};
 
 use crate::{
-  AsyncDependenciesBlockIdentifier, BoxDependencyTemplate, BoxLoader, BoxModule,
-  BoxModuleDependency, BuildContext, BuildInfo, BuildMeta, BuildResult, ChunkGraph,
-  CodeGenerationResult, Compilation, ConcatenationScope, ConnectionState, Context,
-  DependenciesBlock, DependencyId, FactoryMeta, GenerateContext, GeneratorOptions, LibIdentOptions,
-  Module, ModuleGraph, ModuleGraphCacheArtifact, ModuleIdentifier, ModuleLayer, ModuleType,
-  OutputOptions, ParseContext, ParseResult, ParserAndGenerator, ParserOptions, Resolve,
-  RspackLoaderRunnerPlugin, RunnerContext, RuntimeGlobals, RuntimeSpec, SourceType, contextify,
-  diagnostics::ModuleBuildError, get_context, impl_module_meta_info, module_update_hash,
+  AsyncDependenciesBlockIdentifier, BoxDependencyTemplate, BoxModule, BoxModuleDependency,
+  BuildContext, BuildInfo, BuildMeta, BuildResult, ChunkGraph, CodeGenerationResult, Compilation,
+  ConcatenationScope, ConnectionState, Context, DependenciesBlock, DependencyId, FactoryMeta,
+  GenerateContext, GeneratorOptions, LibIdentOptions, Module, ModuleGraph,
+  ModuleGraphCacheArtifact, ModuleIdentifier, ModuleLayer, ModuleType, OutputOptions, ParseContext,
+  ParseResult, ParserAndGenerator, ParserOptions, Resolve, RspackLoaderRunnerPlugin, RunnerContext,
+  RuntimeGlobals, RuntimeSpec, SourceType, contextify, diagnostics::ModuleBuildError, get_context,
+  impl_module_meta_info, module_update_hash,
 };
 
 #[cacheable]
@@ -121,8 +121,6 @@ pub struct NormalModule {
   /// Resource data (path, query, fragment etc.)
   resource_data: Arc<ResourceData>,
   /// Loaders for the module
-  #[debug(skip)]
-  loaders: Vec<BoxLoader>,
 
   /// Built source of this module (passed with loaders)
   #[cacheable(with=AsOption<AsPreset>)]
@@ -180,7 +178,6 @@ impl NormalModule {
     match_resource: Option<ResourceData>,
     resource_data: Arc<ResourceData>,
     resolve_options: Option<Arc<Resolve>>,
-    loaders: Vec<BoxLoader>,
     context: Option<Context>,
   ) -> Self {
     let module_type = module_type.into();
@@ -201,7 +198,6 @@ impl NormalModule {
       match_resource,
       resource_data,
       resolve_options,
-      loaders,
       source: None,
       debug_id: DEBUG_ID.fetch_add(1, Ordering::Relaxed),
 
@@ -249,10 +245,6 @@ impl NormalModule {
     &self.raw_request
   }
 
-  pub fn loaders(&self) -> &[BoxLoader] {
-    &self.loaders
-  }
-
   pub fn parser_and_generator(&self) -> &dyn ParserAndGenerator {
     &*self.parser_and_generator
   }
@@ -373,7 +365,7 @@ impl Module for NormalModule {
     perfetto.process_name = format!("Rspack Build Detail"),
     module.resource = self.resource_resolved_data().resource(),
     module.identifier = self.identifier().as_str(),
-    module.loaders = ?self.loaders.iter().map(|l| l.identifier().as_str()).collect::<Vec<_>>())
+    loaders = ?build_context.loaders.iter().map(|l| l.identifier().as_str()).collect::<Vec<_>>())
   )]
   async fn build(
     &mut self,
@@ -402,7 +394,7 @@ impl Module for NormalModule {
     });
 
     let (mut loader_result, err) = run_loaders(
-      self.loaders.clone(),
+      build_context.loaders.clone(),
       self.resource_data.clone(),
       Some(plugin.clone()),
       RunnerContext {
@@ -538,7 +530,7 @@ impl Module for NormalModule {
         module_layer: self.layer.as_ref(),
         module_user_request: &self.user_request,
         module_source_map_kind: *self.get_source_map_kind(),
-        loaders: &self.loaders,
+        loaders: &build_context.loaders,
         resource_data: &self.resource_data,
         compiler_options: &build_context.compiler_options,
         additional_data: loader_result.additional_data,

crates/rspack_core/src/normal_module_factory.rs

@@ -571,7 +571,6 @@ impl NormalModuleFactory {
         match_resource_data,
         Arc::new(create_data.resource_resolve_data.clone()),
         resolved_resolve_options,
-        loaders,
         create_data.context.clone().map(|x| x.into()),
       )
       .boxed()
@@ -587,7 +586,10 @@ impl NormalModuleFactory {
     data.add_file_dependencies(file_dependencies);
     data.add_missing_dependencies(missing_dependencies);
 
-    Ok(Some(ModuleFactoryResult::new_with_module(module)))
+    Ok(Some(ModuleFactoryResult {
+      module: Some(module),
+      loaders,
+    }))
   }
 
   async fn calculate_module_rules<'a>(

crates/rspack_loader_lightningcss/src/lib.rs

@@ -12,7 +12,6 @@ use lightningcss::{
   targets::{Features, Targets},
   traits::IntoOwned,
 };
-use rspack_cacheable::{cacheable, cacheable_dyn, with::Skip};
 use rspack_core::{
   Loader, LoaderContext, RunnerContext,
   rspack_sources::{Mapping, OriginalLocation, SourceMap, encode_mappings},
@@ -30,12 +29,10 @@ pub const LIGHTNINGCSS_LOADER_IDENTIFIER: &str = "builtin:lightningcss-loader";
 
 pub type LightningcssLoaderVisitor = Box<dyn Send + Fn(&mut StyleSheet<'static, 'static>)>;
 
-#[cacheable]
 #[derive(Debug)]
 pub struct LightningCssLoader {
   id: Identifier,
   #[debug(skip)]
-  #[cacheable(with=Skip)]
   visitors: Option<Mutex<Vec<LightningcssLoaderVisitor>>>,
   config: Config,
 }
@@ -258,7 +255,6 @@ impl LightningCssLoader {
   }
 }
 
-#[cacheable_dyn]
 #[async_trait::async_trait]
 impl Loader<RunnerContext> for LightningCssLoader {
   fn identifier(&self) -> rspack_loader_runner::Identifier {

crates/rspack_loader_preact_refresh/Cargo.toml

@@ -9,7 +9,6 @@ version.workspace = true
 
 [dependencies]
 async-trait          = { workspace = true }
-rspack_cacheable     = { workspace = true }
 rspack_core          = { workspace = true }
 rspack_error         = { workspace = true }
 rspack_hook          = { workspace = true }