feat: support option resolveLoader (#4008)

* feat: support option `resolveLoader`

* fix: fix resolve issue

* fix: test

* chore: lint

* chore: skip test

Author: h-a-n-a

crates/node_binding/binding.d.ts

@@ -814,6 +814,7 @@ export interface RawOptions {
   context: string
   output: RawOutputOptions
   resolve: RawResolveOptions
+  resolveLoader: RawResolveOptions
   module: RawModuleOptions
   builtins: RawBuiltins
   externals?: Array<RawExternalItem>

crates/node_binding/src/plugins/loader.rs

@@ -80,6 +80,7 @@ impl Plugin for JsLoaderResolver {
 
     match resolve_result {
       ResolveResult::Resource(resource) => {
+        // TODO: Should move this logic to `resolver`, since `resolve.alias` may contain query or fragment too. @Boshen
         let resource = resource.path.to_string_lossy().to_string() + rest.unwrap_or_default();
         Ok(Some(Arc::new(JsLoaderAdapter {
           identifier: resource.into(),

crates/rspack_binding_options/src/options/mod.rs

@@ -67,6 +67,7 @@ pub struct RawOptions {
   pub context: RawContext,
   pub output: RawOutputOptions,
   pub resolve: RawResolveOptions,
+  pub resolve_loader: RawResolveOptions,
   pub module: RawModuleOptions,
   pub builtins: RawBuiltins,
   pub externals: Option<Vec<RawExternalItem>>,
@@ -115,6 +116,7 @@ impl RawOptionsApply for RawOptions {
     }
     let output: OutputOptions = self.output.apply(plugins)?;
     let resolve = self.resolve.try_into()?;
+    let resolve_loader = self.resolve_loader.try_into()?;
     let devtool: Devtool = self.devtool.into();
     let mode = self.mode.unwrap_or_default().into();
     let module: ModuleOptions = self.module.apply(plugins)?;
@@ -253,6 +255,7 @@ impl RawOptionsApply for RawOptions {
       target,
       output,
       resolve,
+      resolve_loader,
       devtool,
       experiments,
       stats,

crates/rspack_core/src/compiler/compilation.rs

@@ -76,6 +76,7 @@ pub struct Compilation {
   logging: CompilationLogging,
   pub plugin_driver: SharedPluginDriver,
   pub resolver_factory: Arc<ResolverFactory>,
+  pub loader_resolver_factory: Arc<ResolverFactory>,
   pub named_chunks: HashMap<String, ChunkUkey>,
   pub(crate) named_chunk_groups: HashMap<String, ChunkGroupUkey>,
   pub entry_module_identifiers: IdentifierSet,
@@ -110,6 +111,7 @@ impl Compilation {
     module_graph: ModuleGraph,
     plugin_driver: SharedPluginDriver,
     resolver_factory: Arc<ResolverFactory>,
+    loader_resolver_factory: Arc<ResolverFactory>,
     cache: Arc<Cache>,
   ) -> Self {
     Self {
@@ -133,6 +135,7 @@ impl Compilation {
       logging: Default::default(),
       plugin_driver,
       resolver_factory,
+      loader_resolver_factory,
       named_chunks: Default::default(),
       named_chunk_groups: Default::default(),
       entry_module_identifiers: IdentifierSet::default(),
@@ -875,6 +878,7 @@ impl Compilation {
       resolve_options,
       lazy_visit_modules,
       resolver_factory: self.resolver_factory.clone(),
+      loader_resolver_factory: self.loader_resolver_factory.clone(),
       options: self.options.clone(),
       plugin_driver: self.plugin_driver.clone(),
       cache: self.cache.clone(),

crates/rspack_core/src/compiler/hmr.rs

@@ -134,6 +134,7 @@ where
         Default::default(),
         self.plugin_driver.clone(),
         self.resolver_factory.clone(),
+        self.loader_resolver_factory.clone(),
         self.cache.clone(),
       );
 

crates/rspack_core/src/compiler/mod.rs

@@ -37,6 +37,7 @@ where
   pub compilation: Compilation,
   pub plugin_driver: SharedPluginDriver,
   pub resolver_factory: Arc<ResolverFactory>,
+  pub loader_resolver_factory: Arc<ResolverFactory>,
   pub cache: Arc<Cache>,
   /// emitted asset versions
   /// the key of HashMap is filename, the value of HashMap is version
@@ -56,6 +57,7 @@ where
     let options = Arc::new(options);
 
     let resolver_factory = Arc::new(ResolverFactory::new(options.resolve.clone()));
+    let loader_resolver_factory = Arc::new(ResolverFactory::new(options.resolve_loader.clone()));
     let plugin_driver = Arc::new(PluginDriver::new(
       options.clone(),
       plugins,
@@ -70,11 +72,13 @@ where
         Default::default(),
         plugin_driver.clone(),
         resolver_factory.clone(),
+        loader_resolver_factory.clone(),
         cache.clone(),
       ),
       output_filesystem,
       plugin_driver,
       resolver_factory,
+      loader_resolver_factory,
       cache,
       emitted_asset_versions: Default::default(),
     }
@@ -99,6 +103,7 @@ where
         Default::default(),
         self.plugin_driver.clone(),
         self.resolver_factory.clone(),
+        self.loader_resolver_factory.clone(),
         self.cache.clone(),
       ),
     );

crates/rspack_core/src/compiler/queue.rs

@@ -33,6 +33,7 @@ pub struct FactorizeTask {
   pub side_effects: Option<bool>,
   pub resolve_options: Option<Resolve>,
   pub resolver_factory: Arc<ResolverFactory>,
+  pub loader_resolver_factory: Arc<ResolverFactory>,
   pub options: Arc<CompilerOptions>,
   pub lazy_visit_modules: std::collections::HashSet<String>,
   pub plugin_driver: SharedPluginDriver,
@@ -92,7 +93,7 @@ impl WorkerTask for FactorizeTask {
             lazy_visit_modules: self.lazy_visit_modules,
             issuer: self.issuer,
           },
-          self.resolver_factory,
+          self.loader_resolver_factory,
           self.plugin_driver,
           self.cache,
         );

crates/rspack_core/src/normal_module_factory.rs

@@ -6,16 +6,16 @@ use rspack_error::{
   internal_error, Diagnostic, IntoTWithDiagnosticArray, Result, TWithDiagnosticArray,
 };
 use rspack_identifier::Identifiable;
-use rspack_loader_runner::{get_scheme, DescriptionData, Scheme};
+use rspack_loader_runner::{get_scheme, DescriptionData, Loader, Scheme};
 use sugar_path::{AsPath, SugarPath};
 use swc_core::common::Span;
 
 use crate::{
   cache::Cache,
   module_rules_matcher, parse_resource, resolve, stringify_loaders_and_resource,
   tree_shaking::visitor::{get_side_effects_from_package_json, SideEffects},
-  BoxLoader, CompilerOptions, DependencyCategory, DependencyType, FactorizeArgs, FactoryMeta,
-  FuncUseCtx, GeneratorOptions, MissingModule, ModuleArgs, ModuleExt, ModuleFactory,
+  BoxLoader, CompilerContext, CompilerOptions, DependencyCategory, DependencyType, FactorizeArgs,
+  FactoryMeta, FuncUseCtx, GeneratorOptions, MissingModule, ModuleArgs, ModuleExt, ModuleFactory,
   ModuleFactoryCreateData, ModuleFactoryResult, ModuleIdentifier, ModuleRule, ModuleRuleEnforce,
   ModuleRuleUse, ModuleRuleUseLoader, ModuleType, NormalModule, NormalModuleAfterResolveArgs,
   NormalModuleBeforeResolveArgs, ParserOptions, RawModule, Resolve, ResolveArgs, ResolveError,
@@ -26,7 +26,7 @@ use crate::{
 #[derive(Debug)]
 pub struct NormalModuleFactory {
   context: NormalModuleFactoryContext,
-  resolver_factory: Arc<ResolverFactory>,
+  loader_resolver_factory: Arc<ResolverFactory>,
   plugin_driver: SharedPluginDriver,
   cache: Arc<Cache>,
 }
@@ -55,13 +55,13 @@ static MATCH_RESOURCE_REGEX: Lazy<Regex> =
 impl NormalModuleFactory {
   pub fn new(
     context: NormalModuleFactoryContext,
-    resolver_factory: Arc<ResolverFactory>,
+    loader_resolver_factory: Arc<ResolverFactory>,
     plugin_driver: SharedPluginDriver,
     cache: Arc<Cache>,
   ) -> Self {
     Self {
       context,
-      resolver_factory,
+      loader_resolver_factory,
       plugin_driver,
       cache,
     }
@@ -145,13 +145,15 @@ impl NormalModuleFactory {
     Ok(None)
   }
 
-  fn get_loader_resolver(&self, loader_resolve_options: Option<Resolve>) -> Arc<Resolver> {
-    self.resolver_factory.get(ResolveOptionsWithDependencyType {
-      resolve_options: loader_resolve_options,
-      resolve_to_context: false,
-      dependency_type: DependencyType::CjsRequire,
-      dependency_category: DependencyCategory::CommonJS,
-    })
+  fn get_loader_resolver(&self) -> Arc<Resolver> {
+    self
+      .loader_resolver_factory
+      .get(ResolveOptionsWithDependencyType {
+        resolve_options: None,
+        resolve_to_context: false,
+        dependency_type: DependencyType::CjsRequire,
+        dependency_category: DependencyCategory::CommonJS,
+      })
   }
 
   pub async fn factorize_normal_module(
@@ -172,7 +174,7 @@ impl NormalModuleFactory {
     let context_scheme = get_scheme(data.context.as_ref());
     let context = data.context.as_path();
     let plugin_driver = &self.plugin_driver;
-    let loader_resolver = self.get_loader_resolver(data.resolve_options.clone());
+    let loader_resolver = self.get_loader_resolver();
 
     let mut match_resource_data: Option<ResourceData> = None;
     let mut inline_loaders: Vec<ModuleRuleUseLoader> = vec![];
@@ -476,32 +478,94 @@ impl NormalModuleFactory {
         pre_loaders.len() + post_loaders.len() + normal_loaders.len() + inline_loaders.len(),
       );
 
-      all_loaders.extend(post_loaders);
+      for l in post_loaders {
+        all_loaders.push(
+          resolve_each(
+            plugin_driver,
+            &self.context.options,
+            self.context.options.context.as_ref(),
+            &loader_resolver,
+            &l.loader,
+            l.options.as_deref(),
+          )
+          .await?,
+        )
+      }
+
+      let mut resolved_inline_loaders = vec![];
+      let mut resolved_normal_loaders = vec![];
+
+      for l in inline_loaders {
+        resolved_inline_loaders.push(
+          resolve_each(
+            plugin_driver,
+            &self.context.options,
+            context,
+            &loader_resolver,
+            &l.loader,
+            l.options.as_deref(),
+          )
+          .await?,
+        )
+      }
+
+      for l in normal_loaders {
+        resolved_normal_loaders.push(
+          resolve_each(
+            plugin_driver,
+            &self.context.options,
+            self.context.options.context.as_ref(),
+            &loader_resolver,
+            &l.loader,
+            l.options.as_deref(),
+          )
+          .await?,
+        )
+      }
+
       if match_resource_data.is_some() {
-        all_loaders.extend(normal_loaders);
-        all_loaders.extend(inline_loaders);
+        all_loaders.extend(resolved_normal_loaders);
+        all_loaders.extend(resolved_inline_loaders);
       } else {
-        all_loaders.extend(inline_loaders);
-        all_loaders.extend(normal_loaders);
+        all_loaders.extend(resolved_inline_loaders);
+        all_loaders.extend(resolved_normal_loaders);
+      }
+
+      for l in pre_loaders {
+        all_loaders.push(
+          resolve_each(
+            plugin_driver,
+            &self.context.options,
+            self.context.options.context.as_ref(),
+            &loader_resolver,
+            &l.loader,
+            l.options.as_deref(),
+          )
+          .await?,
+        )
       }
-      all_loaders.extend(pre_loaders);
-
-      let mut loader = Vec::with_capacity(all_loaders.len());
-      for l in all_loaders {
-        loader.push(
-          plugin_driver
-            .resolve_loader(
-              &self.context.options,
-              context,
-              &loader_resolver,
-              &l.loader,
-              l.options.as_deref(),
-            )
-            .await?
-            .ok_or_else(|| internal_error!("Unable to resolve loader {}", &l.loader))?,
-        );
+
+      async fn resolve_each(
+        plugin_driver: &SharedPluginDriver,
+        compiler_options: &CompilerOptions,
+        context: &Path,
+        loader_resolver: &Resolver,
+        loader_request: &str,
+        loader_options: Option<&str>,
+      ) -> Result<Arc<dyn Loader<CompilerContext>>> {
+        plugin_driver
+          .resolve_loader(
+            compiler_options,
+            context,
+            loader_resolver,
+            loader_request,
+            loader_options,
+          )
+          .await?
+          .ok_or_else(|| internal_error!("Unable to resolve loader {}", loader_request))
       }
-      loader
+
+      all_loaders
     };
 
     let request = if !loaders.is_empty() {

crates/rspack_core/src/options/compiler_options.rs

@@ -13,6 +13,7 @@ pub struct CompilerOptions {
   pub target: Target,
   pub mode: Mode,
   pub resolve: Resolve,
+  pub resolve_loader: Resolve,
   pub builtins: Builtins,
   pub module: ModuleOptions,
   pub devtool: Devtool,

crates/rspack_loader_sass/tests/fixtures.rs

@@ -75,6 +75,7 @@ async fn loader_test(actual: impl AsRef<Path>, expected: impl AsRef<Path>) {
         },
         target: rspack_core::Target::new(&vec![String::from("web")]).expect("TODO:"),
         resolve: rspack_core::Resolve::default(),
+        resolve_loader: rspack_core::Resolve::default(),
         builtins: Default::default(),
         module: Default::default(),
         stats: Default::default(),