feat(rstest_plugin): support hoist mock and resolve mocked module id

crates/rspack_core/src/dependency/dependency_type.rs

@@ -117,7 +117,9 @@ pub enum DependencyType {
   DllEntry,
   DelegatedSource,
   ExtractCSS,
-  Rstest,
+  RstestModulePath,
+  RstestMockModuleId,
+  RstestHoistMock,
 }
 
 impl DependencyType {
@@ -191,7 +193,9 @@ impl DependencyType {
       DependencyType::ModuleDecorator => "module decorator",
       DependencyType::DelegatedSource => "delegated source",
       DependencyType::ExtractCSS => "extract css",
-      DependencyType::Rstest => "rstest",
+      DependencyType::RstestModulePath => "rstest module path",
+      DependencyType::RstestMockModuleId => "rstest mock module id",
+      DependencyType::RstestHoistMock => "rstest hoist mock",
     }
   }
 }

crates/rspack_core/src/init_fragment.rs

@@ -40,7 +40,6 @@ pub enum InitFragmentKey {
   ModuleDecorator(String /* module_id */),
   ESMFakeNamespaceObjectFragment(String),
   Const(String),
-  // ModuleName(String),
 }
 
 impl InitFragmentKey {

crates/rspack_plugin_javascript/src/plugin/impl_plugin_for_js_plugin.rs

@@ -375,6 +375,11 @@ async fn compilation(
     RuntimeRequirementsDependencyTemplate::template_type(),
     Arc::new(RuntimeRequirementsDependencyTemplate::default()),
   );
+  // Rstest
+  compilation.set_dependency_factory(
+    DependencyType::RstestMockModuleId,
+    params.normal_module_factory.clone(),
+  );
   Ok(())
 }
 

crates/rspack_plugin_javascript/src/visitors/dependency/parser/mod.rs

@@ -254,7 +254,7 @@ pub struct JavascriptParser<'parser> {
   pub(crate) current_tag_info: Option<TagInfoId>,
   pub(crate) local_modules: Vec<LocalModule>,
   // ===== scope info =======
-  pub(crate) in_try: bool,
+  pub in_try: bool,
   pub(crate) in_short_hand: bool,
   pub(super) definitions: ScopeInfoId,
   pub(crate) top_level_scope: TopLevelScope,

crates/rspack_plugin_rstest/Cargo.toml

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

crates/rspack_plugin_rstest/src/lib.rs

@@ -1,4 +1,6 @@
 #![feature(let_chains)]
+mod mock_hoist_dependency;
+mod mock_module_id_dependency;
 mod module_path_name_dependency;
 mod parser_plugin;
 mod plugin;

crates/rspack_plugin_rstest/src/mock_hoist_dependency.rs

@@ -0,0 +1,93 @@
+use rspack_cacheable::{cacheable, cacheable_dyn, with::Skip};
+use rspack_core::{
+  AsContextDependency, AsModuleDependency, DependencyCodeGeneration, DependencyRange,
+  DependencyTemplate, DependencyTemplateType, DependencyType, InitFragmentExt, InitFragmentKey,
+  InitFragmentStage, NormalInitFragment, TemplateContext, TemplateReplaceSource,
+};
+use swc_core::common::Span;
+
+#[cacheable]
+#[derive(Debug, Clone)]
+pub struct MockHoistDependency {
+  #[cacheable(with=Skip)]
+  call_expr_span: Span,
+  #[cacheable(with=Skip)]
+  callee_span: Span,
+  request: String,
+}
+
+impl MockHoistDependency {
+  pub fn new(call_expr_span: Span, callee_span: Span, request: String) -> Self {
+    Self {
+      call_expr_span,
+      callee_span,
+      request,
+    }
+  }
+}
+
+#[cacheable_dyn]
+impl DependencyCodeGeneration for MockHoistDependency {
+  fn dependency_template(&self) -> Option<DependencyTemplateType> {
+    Some(MockHoistDependencyTemplate::template_type())
+  }
+}
+
+impl AsModuleDependency for MockHoistDependency {}
+impl AsContextDependency for MockHoistDependency {}
+
+#[cacheable]
+#[derive(Debug, Clone, Default)]
+pub struct MockHoistDependencyTemplate;
+
+impl MockHoistDependencyTemplate {
+  pub fn template_type() -> DependencyTemplateType {
+    DependencyTemplateType::Dependency(DependencyType::RstestHoistMock)
+  }
+}
+
+impl DependencyTemplate for MockHoistDependencyTemplate {
+  fn render(
+    &self,
+    dep: &dyn DependencyCodeGeneration,
+    source: &mut TemplateReplaceSource,
+    code_generatable_context: &mut TemplateContext,
+  ) {
+    let TemplateContext { init_fragments, .. } = code_generatable_context;
+
+    let dep = dep
+      .as_any()
+      .downcast_ref::<MockHoistDependency>()
+      .expect("ModulePathNameDependencyTemplate can only be applied to ModulePathNameDependency");
+    let request = &dep.request;
+
+    // Placeholder of hoist target.
+    let init = NormalInitFragment::new(
+      format!("/* RSTEST:MOCK_PLACEHOLDER:{request} */;"),
+      InitFragmentStage::StageConstants,
+      0,
+      InitFragmentKey::Const(format!("retest mock_hoist {request}")),
+      None,
+    );
+
+    // Start before hoist.
+    let callee_range: DependencyRange = dep.callee_span.into();
+    source.replace(
+      callee_range.start,
+      callee_range.end,
+      format!("/* RSTEST:MOCK_HOIST_START:{request} */__webpack_require__.set_mock").as_ref(),
+      None,
+    );
+
+    // End before hoist.
+    let range: DependencyRange = dep.call_expr_span.into();
+    source.replace(
+      range.end, // count the trailing semicolon
+      range.end,
+      format!("/* RSTEST:MOCK_HOIST_END:{request} */").as_ref(),
+      None,
+    );
+
+    init_fragments.push(init.boxed());
+  }
+}

crates/rspack_plugin_rstest/src/mock_module_id_dependency.rs

@@ -0,0 +1,147 @@
+use rspack_cacheable::{cacheable, cacheable_dyn};
+use rspack_core::{
+  module_id, AsContextDependency, Dependency, DependencyCategory, DependencyCodeGeneration,
+  DependencyId, DependencyRange, DependencyTemplate, DependencyTemplateType, DependencyType,
+  ExtendedReferencedExport, FactorizeInfo, ModuleDependency, ModuleGraph, RuntimeSpec,
+  TemplateContext, TemplateReplaceSource,
+};
+
+#[cacheable]
+#[derive(Debug, Clone)]
+pub struct MockModuleIdDependency {
+  pub id: DependencyId,
+  pub request: String,
+  pub weak: bool,
+  range: DependencyRange,
+  optional: bool,
+  factorize_info: FactorizeInfo,
+  category: DependencyCategory,
+}
+
+impl MockModuleIdDependency {
+  pub fn new(
+    request: String,
+    range: DependencyRange,
+    weak: bool,
+    optional: bool,
+    category: DependencyCategory,
+  ) -> Self {
+    Self {
+      range,
+      request,
+      weak,
+      optional,
+      id: DependencyId::new(),
+      factorize_info: Default::default(),
+      category,
+    }
+  }
+}
+
+#[cacheable_dyn]
+impl Dependency for MockModuleIdDependency {
+  fn id(&self) -> &DependencyId {
+    &self.id
+  }
+
+  fn category(&self) -> &DependencyCategory {
+    &self.category
+  }
+
+  fn dependency_type(&self) -> &DependencyType {
+    &DependencyType::RstestMockModuleId
+  }
+
+  fn range(&self) -> Option<&DependencyRange> {
+    Some(&self.range)
+  }
+
+  fn get_referenced_exports(
+    &self,
+    _module_graph: &ModuleGraph,
+    _runtime: Option<&RuntimeSpec>,
+  ) -> Vec<ExtendedReferencedExport> {
+    vec![]
+  }
+
+  fn could_affect_referencing_module(&self) -> rspack_core::AffectType {
+    rspack_core::AffectType::True
+  }
+}
+
+#[cacheable_dyn]
+impl ModuleDependency for MockModuleIdDependency {
+  fn request(&self) -> &str {
+    &self.request
+  }
+
+  fn user_request(&self) -> &str {
+    &self.request
+  }
+
+  fn weak(&self) -> bool {
+    self.weak
+  }
+
+  fn get_optional(&self) -> bool {
+    self.optional
+  }
+
+  fn set_request(&mut self, request: String) {
+    self.request = request;
+  }
+
+  fn factorize_info(&self) -> &FactorizeInfo {
+    &self.factorize_info
+  }
+
+  fn factorize_info_mut(&mut self) -> &mut FactorizeInfo {
+    &mut self.factorize_info
+  }
+}
+
+#[cacheable_dyn]
+impl DependencyCodeGeneration for MockModuleIdDependency {
+  fn dependency_template(&self) -> Option<DependencyTemplateType> {
+    Some(MockModuleIdDependencyTemplate::template_type())
+  }
+}
+
+impl AsContextDependency for MockModuleIdDependency {}
+
+#[cacheable]
+#[derive(Debug, Clone, Default)]
+pub struct MockModuleIdDependencyTemplate;
+
+impl MockModuleIdDependencyTemplate {
+  pub fn template_type() -> DependencyTemplateType {
+    DependencyTemplateType::Dependency(DependencyType::RstestMockModuleId)
+  }
+}
+
+impl DependencyTemplate for MockModuleIdDependencyTemplate {
+  fn render(
+    &self,
+    dep: &dyn DependencyCodeGeneration,
+    source: &mut TemplateReplaceSource,
+    code_generatable_context: &mut TemplateContext,
+  ) {
+    let dep = dep
+      .as_any()
+      .downcast_ref::<MockModuleIdDependency>()
+      .expect("MockModuleIdDependencyTemplate should only be used for MockModuleIdDependency");
+
+    source.replace(
+      dep.range.start,
+      dep.range.end,
+      module_id(
+        code_generatable_context.compilation,
+        &dep.id,
+        &dep.request,
+        dep.weak,
+      )
+      .as_str(),
+      None,
+    );
+  }
+}

crates/rspack_plugin_rstest/src/module_path_name_dependency.rs

@@ -40,7 +40,7 @@ pub struct ModulePathNameDependencyTemplate;
 
 impl ModulePathNameDependencyTemplate {
   pub fn template_type() -> DependencyTemplateType {
-    DependencyTemplateType::Dependency(DependencyType::Rstest)
+    DependencyTemplateType::Dependency(DependencyType::RstestModulePath)
   }
 }