fix(runtime): Box the main future to avoid blowing up the stack (#19155)

This fixes `Unhandled exception at [...] Stack overflow` on Windows,
caused by the large size of the main future.

1 files changed, 114 insertions, 93 deletions

diff --git a/cli/main.rs b/cli/main.rs
index 023d5a208..031ab07e0 100644
--- a/cli/main.rs
+++ b/cli/main.rs
@@ -44,39 +44,72 @@ use args::CliOptions;
 use deno_core::anyhow::Context;
 use deno_core::error::AnyError;
 use deno_core::error::JsError;
+use deno_core::futures::FutureExt;
+use deno_core::task::JoinHandle;
 use deno_runtime::colors;
 use deno_runtime::fmt_errors::format_js_error;
 use deno_runtime::tokio_util::create_and_run_current_thread;
 use factory::CliFactory;
 use std::env;
 use std::env::current_exe;
+use std::future::Future;
 use std::path::PathBuf;
 
+/// Ensures that all subcommands return an i32 exit code and an [`AnyError`] error type.
+trait SubcommandOutput {
+  fn output(self) -> Result<i32, AnyError>;
+}
+
+impl SubcommandOutput for Result<i32, AnyError> {
+  fn output(self) -> Result<i32, AnyError> {
+    self
+  }
+}
+
+impl SubcommandOutput for Result<(), AnyError> {
+  fn output(self) -> Result<i32, AnyError> {
+    self.map(|_| 0)
+  }
+}
+
+impl SubcommandOutput for Result<(), std::io::Error> {
+  fn output(self) -> Result<i32, AnyError> {
+    self.map(|_| 0).map_err(|e| e.into())
+  }
+}
+
+/// Ensure that the subcommand runs in a task, rather than being directly executed. Since some of these
+/// futures are very large, this prevents the stack from getting blown out from passing them by value up
+/// the callchain (especially in debug mode when Rust doesn't have a chance to elide copies!).
+#[inline(always)]
+fn spawn_subcommand<F: Future<Output = T> + 'static, T: SubcommandOutput>(
+  f: F,
+) -> JoinHandle<Result<i32, AnyError>> {
+  deno_core::task::spawn(f.map(|r| r.output()))
+}
+
 async fn run_subcommand(flags: Flags) -> Result<i32, AnyError> {
-  match flags.subcommand.clone() {
-    DenoSubcommand::Bench(bench_flags) => {
+  let handle = match flags.subcommand.clone() {
+    DenoSubcommand::Bench(bench_flags) => spawn_subcommand(async {
       let cli_options = CliOptions::from_flags(flags)?;
       let bench_options = cli_options.resolve_bench_options(bench_flags)?;
       if cli_options.watch_paths().is_some() {
         tools::bench::run_benchmarks_with_watch(cli_options, bench_options)
-          .await?;
+          .await
       } else {
-        tools::bench::run_benchmarks(cli_options, bench_options).await?;
+        tools::bench::run_benchmarks(cli_options, bench_options).await
       }
-      Ok(0)
-    }
-    DenoSubcommand::Bundle(bundle_flags) => {
-      tools::bundle::bundle(flags, bundle_flags).await?;
-      Ok(0)
-    }
+    }),
+    DenoSubcommand::Bundle(bundle_flags) => spawn_subcommand(async {
+      tools::bundle::bundle(flags, bundle_flags).await
+    }),
     DenoSubcommand::Doc(doc_flags) => {
-      tools::doc::print_docs(flags, doc_flags).await?;
-      Ok(0)
+      spawn_subcommand(async { tools::doc::print_docs(flags, doc_flags).await })
     }
-    DenoSubcommand::Eval(eval_flags) => {
+    DenoSubcommand::Eval(eval_flags) => spawn_subcommand(async {
       tools::run::eval_command(flags, eval_flags).await
-    }
-    DenoSubcommand::Cache(cache_flags) => {
+    }),
+    DenoSubcommand::Cache(cache_flags) => spawn_subcommand(async move {
       let factory = CliFactory::from_flags(flags).await?;
       let module_load_preparer = factory.module_load_preparer().await?;
       let emitter = factory.emitter()?;
@@ -84,114 +117,102 @@ async fn run_subcommand(flags: Flags) -> Result<i32, AnyError> {
       module_load_preparer
         .load_and_type_check_files(&cache_flags.files)
         .await?;
-      emitter.cache_module_emits(&graph_container.graph())?;
-      Ok(0)
-    }
-    DenoSubcommand::Check(check_flags) => {
+      emitter.cache_module_emits(&graph_container.graph())
+    }),
+    DenoSubcommand::Check(check_flags) => spawn_subcommand(async move {
       let factory = CliFactory::from_flags(flags).await?;
       let module_load_preparer = factory.module_load_preparer().await?;
       module_load_preparer
         .load_and_type_check_files(&check_flags.files)
-        .await?;
-      Ok(0)
-    }
-    DenoSubcommand::Compile(compile_flags) => {
-      tools::compile::compile(flags, compile_flags).await?;
-      Ok(0)
-    }
-    DenoSubcommand::Coverage(coverage_flags) => {
-      tools::coverage::cover_files(flags, coverage_flags).await?;
-      Ok(0)
-    }
-    DenoSubcommand::Fmt(fmt_flags) => {
+        .await
+    }),
+    DenoSubcommand::Compile(compile_flags) => spawn_subcommand(async {
+      tools::compile::compile(flags, compile_flags).await
+    }),
+    DenoSubcommand::Coverage(coverage_flags) => spawn_subcommand(async {
+      tools::coverage::cover_files(flags, coverage_flags).await
+    }),
+    DenoSubcommand::Fmt(fmt_flags) => spawn_subcommand(async move {
       let cli_options = CliOptions::from_flags(flags.clone())?;
       let fmt_options = cli_options.resolve_fmt_options(fmt_flags)?;
-      tools::fmt::format(cli_options, fmt_options).await?;
-      Ok(0)
-    }
+      tools::fmt::format(cli_options, fmt_options).await
+    }),
     DenoSubcommand::Init(init_flags) => {
-      tools::init::init_project(init_flags).await?;
-      Ok(0)
+      spawn_subcommand(async { tools::init::init_project(init_flags).await })
     }
     DenoSubcommand::Info(info_flags) => {
-      tools::info::info(flags, info_flags).await?;
-      Ok(0)
-    }
-    DenoSubcommand::Install(install_flags) => {
-      tools::installer::install_command(flags, install_flags).await?;
-      Ok(0)
+      spawn_subcommand(async { tools::info::info(flags, info_flags).await })
     }
-    DenoSubcommand::Uninstall(uninstall_flags) => {
-      tools::installer::uninstall(uninstall_flags.name, uninstall_flags.root)?;
-      Ok(0)
-    }
-    DenoSubcommand::Lsp => {
-      lsp::start().await?;
-      Ok(0)
-    }
-    DenoSubcommand::Lint(lint_flags) => {
+    DenoSubcommand::Install(install_flags) => spawn_subcommand(async {
+      tools::installer::install_command(flags, install_flags).await
+    }),
+    DenoSubcommand::Uninstall(uninstall_flags) => spawn_subcommand(async {
+      tools::installer::uninstall(uninstall_flags.name, uninstall_flags.root)
+    }),
+    DenoSubcommand::Lsp => spawn_subcommand(async { lsp::start().await }),
+    DenoSubcommand::Lint(lint_flags) => spawn_subcommand(async {
       if lint_flags.rules {
         tools::lint::print_rules_list(lint_flags.json);
+        Ok(())
       } else {
         let cli_options = CliOptions::from_flags(flags)?;
         let lint_options = cli_options.resolve_lint_options(lint_flags)?;
-        tools::lint::lint(cli_options, lint_options).await?;
+        tools::lint::lint(cli_options, lint_options).await
       }
-      Ok(0)
-    }
+    }),
     DenoSubcommand::Repl(repl_flags) => {
-      tools::repl::run(flags, repl_flags).await
+      spawn_subcommand(async move { tools::repl::run(flags, repl_flags).await })
     }
-    DenoSubcommand::Run(run_flags) => {
+    DenoSubcommand::Run(run_flags) => spawn_subcommand(async move {
       if run_flags.is_stdin() {
         tools::run::run_from_stdin(flags).await
       } else {
         tools::run::run_script(flags).await
       }
-    }
-    DenoSubcommand::Task(task_flags) => {
+    }),
+    DenoSubcommand::Task(task_flags) => spawn_subcommand(async {
       tools::task::execute_script(flags, task_flags).await
-    }
+    }),
     DenoSubcommand::Test(test_flags) => {
-      if let Some(ref coverage_dir) = flags.coverage_dir {
-        std::fs::create_dir_all(coverage_dir)
-          .with_context(|| format!("Failed creating: {coverage_dir}"))?;
-        // this is set in order to ensure spawned processes use the same
-        // coverage directory
-        env::set_var(
-          "DENO_UNSTABLE_COVERAGE_DIR",
-          PathBuf::from(coverage_dir).canonicalize()?,
-        );
-      }
-      let cli_options = CliOptions::from_flags(flags)?;
-      let test_options = cli_options.resolve_test_options(test_flags)?;
-
-      if cli_options.watch_paths().is_some() {
-        tools::test::run_tests_with_watch(cli_options, test_options).await?;
-      } else {
-        tools::test::run_tests(cli_options, test_options).await?;
-      }
+      spawn_subcommand(async {
+        if let Some(ref coverage_dir) = flags.coverage_dir {
+          std::fs::create_dir_all(coverage_dir)
+            .with_context(|| format!("Failed creating: {coverage_dir}"))?;
+          // this is set in order to ensure spawned processes use the same
+          // coverage directory
+          env::set_var(
+            "DENO_UNSTABLE_COVERAGE_DIR",
+            PathBuf::from(coverage_dir).canonicalize()?,
+          );
+        }
+        let cli_options = CliOptions::from_flags(flags)?;
+        let test_options = cli_options.resolve_test_options(test_flags)?;
 
-      Ok(0)
+        if cli_options.watch_paths().is_some() {
+          tools::test::run_tests_with_watch(cli_options, test_options).await
+        } else {
+          tools::test::run_tests(cli_options, test_options).await
+        }
+      })
     }
     DenoSubcommand::Completions(completions_flags) => {
-      display::write_to_stdout_ignore_sigpipe(&completions_flags.buf)?;
-      Ok(0)
+      spawn_subcommand(async move {
+        display::write_to_stdout_ignore_sigpipe(&completions_flags.buf)
+      })
     }
-    DenoSubcommand::Types => {
+    DenoSubcommand::Types => spawn_subcommand(async move {
       let types = tsc::get_types_declaration_file_text(flags.unstable);
-      display::write_to_stdout_ignore_sigpipe(types.as_bytes())?;
-      Ok(0)
-    }
-    DenoSubcommand::Upgrade(upgrade_flags) => {
-      tools::upgrade::upgrade(flags, upgrade_flags).await?;
-      Ok(0)
-    }
-    DenoSubcommand::Vendor(vendor_flags) => {
-      tools::vendor::vendor(flags, vendor_flags).await?;
-      Ok(0)
-    }
-  }
+      display::write_to_stdout_ignore_sigpipe(types.as_bytes())
+    }),
+    DenoSubcommand::Upgrade(upgrade_flags) => spawn_subcommand(async {
+      tools::upgrade::upgrade(flags, upgrade_flags).await
+    }),
+    DenoSubcommand::Vendor(vendor_flags) => spawn_subcommand(async {
+      tools::vendor::vendor(flags, vendor_flags).await
+    }),
+  };
+
+  handle.await?
 }
 
 fn setup_panic_hook() {