feat: support deep AST parsing in debug (#6919)

* feat: support deep AST parsing in debug

* fix

Cargo.toml

@@ -38,6 +38,7 @@ rustc-hash         = { version = "1.1.0" }
 schemars           = { version = "0.8.16" }
 serde              = { version = "1.0.197" }
 serde_json         = { version = "1.0.115" }
+stacker            = { version = "0.1.15" }
 sugar_path         = { version = "1.2.0", features = ["cached_current_dir"] }
 syn                = { version = "2.0.58" }
 tokio              = { version = "1.37.0" }

crates/rspack_loader_swc/Cargo.toml

@@ -31,6 +31,7 @@ rspack_swc_visitors      = { path = "../rspack_swc_visitors" }
 rspack_util              = { path = "../rspack_util" }
 serde                    = { workspace = true, features = ["derive"] }
 serde_json               = { workspace = true }
+stacker                  = { workspace = true }
 swc_config               = { workspace = true }
 swc_core                 = { workspace = true, features = ["base", "ecma_ast", "common"] }
 tokio                    = { workspace = true }

crates/rspack_loader_swc/src/lib.rs

@@ -42,13 +42,8 @@ impl SwcLoader {
     self.identifier = identifier;
     self
   }
-}
-
-pub const SWC_LOADER_IDENTIFIER: &str = "builtin:swc-loader";
 
-#[async_trait::async_trait]
-impl Loader<RunnerContext> for SwcLoader {
-  async fn run(&self, loader_context: &mut LoaderContext<RunnerContext>) -> Result<()> {
+  fn loader_impl(&self, loader_context: &mut LoaderContext<RunnerContext>) -> Result<()> {
     let resource_path = loader_context.resource_path().to_path_buf();
     let Some(content) = std::mem::take(&mut loader_context.content) else {
       return Ok(());
@@ -160,6 +155,26 @@ impl Loader<RunnerContext> for SwcLoader {
   }
 }
 
+pub const SWC_LOADER_IDENTIFIER: &str = "builtin:swc-loader";
+
+#[async_trait::async_trait]
+impl Loader<RunnerContext> for SwcLoader {
+  async fn run(&self, loader_context: &mut LoaderContext<RunnerContext>) -> Result<()> {
+    let inner = || self.loader_impl(loader_context);
+    #[cfg(debug_assertions)]
+    {
+      // Adjust stack to avoid stack overflow.
+      stacker::maybe_grow(
+        2 * 1024 * 1024, /* 2mb */
+        4 * 1024 * 1024, /* 4mb */
+        inner,
+      )
+    }
+    #[cfg(not(debug_assertions))]
+    inner()
+  }
+}
+
 impl Identifiable for SwcLoader {
   fn identifier(&self) -> Identifier {
     self.identifier

crates/rspack_plugin_javascript/Cargo.toml

@@ -31,6 +31,7 @@ rspack_regex = { path = "../rspack_regex" }
 rspack_util = { path = "../rspack_util" }
 rustc-hash = { workspace = true }
 serde_json = { workspace = true }
+stacker = { workspace = true }
 sugar_path = { workspace = true }
 swc_core = { workspace = true, features = [
   "__parser",

crates/rspack_plugin_javascript/src/ast/parse.rs

@@ -45,26 +45,40 @@ fn parse_with_lexer(
   lexer: Lexer,
   is_module: IsModule,
 ) -> Result<Program, Vec<parser::error::Error>> {
-  let mut parser = Parser::new_from(lexer);
-  let program_result = match is_module {
-    IsModule::Bool(true) => parser.parse_module().map(Program::Module),
-    IsModule::Bool(false) => parser.parse_script().map(Program::Script),
-    IsModule::Unknown => parser.parse_program(),
-  };
-  let mut errors = parser.take_errors();
-  // Using combinator will let rustc unhappy.
-  match program_result {
-    Ok(program) => {
-      if !errors.is_empty() {
-        return Err(errors);
+  let inner = || {
+    let mut parser = Parser::new_from(lexer);
+    let program_result = match is_module {
+      IsModule::Bool(true) => parser.parse_module().map(Program::Module),
+      IsModule::Bool(false) => parser.parse_script().map(Program::Script),
+      IsModule::Unknown => parser.parse_program(),
+    };
+    let mut errors = parser.take_errors();
+    // Using combinator will let rustc unhappy.
+    match program_result {
+      Ok(program) => {
+        if !errors.is_empty() {
+          return Err(errors);
+        }
+        Ok(program)
+      }
+      Err(err) => {
+        errors.push(err);
+        Err(errors)
       }
-      Ok(program)
-    }
-    Err(err) => {
-      errors.push(err);
-      Err(errors)
     }
+  };
+
+  #[cfg(debug_assertions)]
+  {
+    // Adjust stack to avoid stack overflow.
+    stacker::maybe_grow(
+      2 * 1024 * 1024, /* 2mb */
+      4 * 1024 * 1024, /* 4mb */
+      inner,
+    )
   }
+  #[cfg(not(debug_assertions))]
+  inner()
 }
 
 pub fn parse(