chore(internal): reland eszip changes (denoland#28294)

Co-authored-by: David Sherret <[email protected]>

Author: bartlomieju

Cargo.lock

@@ -66,6 +66,7 @@ deno_permissions = { version = "0.53.0", path = "./runtime/permissions" }
 deno_runtime = { version = "0.202.0", path = "./runtime" }
 deno_semver = "=0.7.1"
 deno_terminal = "0.2.0"
+eszip = "0.83.0"
 napi_sym = { version = "0.124.0", path = "./ext/napi/sym" }
 test_util = { package = "test_server", path = "./tests/util/server" }
 
@@ -149,7 +150,7 @@ dashmap = "5.5.3"
 data-encoding = "2.3.3"
 data-url = "=0.3.1"
 deno_cache_dir = "=0.18.0"
-deno_error = "=0.5.5"
+deno_error = "=0.5.6"
 deno_native_certs = "0.3.0"
 deno_package_json = { version = "=0.5.1", default-features = false }
 deno_task_shell = "=0.20.2"

Cargo.toml

@@ -89,6 +89,7 @@ deno_snapshots.workspace = true
 deno_task_shell.workspace = true
 deno_telemetry.workspace = true
 deno_terminal.workspace = true
+eszip.workspace = true
 libsui.workspace = true
 node_resolver.workspace = true
 

cli/Cargo.toml

@@ -127,6 +127,7 @@ pub struct CompileFlags {
   pub no_terminal: bool,
   pub icon: Option<String>,
   pub include: Vec<String>,
+  pub eszip: bool,
 }
 
 impl CompileFlags {
@@ -676,6 +677,7 @@ pub struct Flags {
   pub code_cache_enabled: bool,
   pub permissions: PermissionFlags,
   pub allow_scripts: PackagesAllowedScripts,
+  pub eszip: bool,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq, Default, Serialize, Deserialize)]
@@ -3838,6 +3840,14 @@ fn runtime_misc_args(app: Command) -> Command {
     .arg(seed_arg())
     .arg(enable_testing_features_arg())
     .arg(strace_ops_arg())
+    .arg(eszip_arg())
+}
+
+fn eszip_arg() -> Arg {
+  Arg::new("eszip-internal-do-not-use")
+    .hide(true)
+    .long("eszip-internal-do-not-use")
+    .action(ArgAction::SetTrue)
 }
 
 fn allow_import_arg() -> Arg {
@@ -4608,6 +4618,7 @@ fn compile_parse(
   let target = matches.remove_one::<String>("target");
   let icon = matches.remove_one::<String>("icon");
   let no_terminal = matches.get_flag("no-terminal");
+  let eszip = matches.get_flag("eszip-internal-do-not-use");
   let include = match matches.remove_many::<String>("include") {
     Some(f) => f.collect(),
     None => vec![],
@@ -4624,6 +4635,7 @@ fn compile_parse(
     no_terminal,
     icon,
     include,
+    eszip,
   });
 
   Ok(())
@@ -5721,9 +5733,16 @@ fn runtime_args_parse(
   enable_testing_features_arg_parse(flags, matches);
   env_file_arg_parse(flags, matches);
   strace_ops_parse(flags, matches);
+  eszip_arg_parse(flags, matches);
   Ok(())
 }
 
+fn eszip_arg_parse(flags: &mut Flags, matches: &mut ArgMatches) {
+  if matches.get_flag("eszip-internal-do-not-use") {
+    flags.eszip = true;
+  }
+}
+
 fn inspect_arg_parse(flags: &mut Flags, matches: &mut ArgMatches) {
   flags.inspect = matches.remove_one::<SocketAddr>("inspect");
   flags.inspect_brk = matches.remove_one::<SocketAddr>("inspect-brk");
@@ -10308,7 +10327,8 @@ mod tests {
           target: None,
           no_terminal: false,
           icon: None,
-          include: vec![]
+          include: vec![],
+          eszip: false,
         }),
         type_check_mode: TypeCheckMode::Local,
         code_cache_enabled: true,
@@ -10332,7 +10352,8 @@ mod tests {
           target: None,
           no_terminal: true,
           icon: Some(String::from("favicon.ico")),
-          include: vec![]
+          include: vec![],
+          eszip: false
         }),
         import_map_path: Some("import_map.json".to_string()),
         no_remote: true,

cli/args/flags.rs

@@ -599,6 +599,10 @@ impl CliOptions {
     }
   }
 
+  pub fn eszip(&self) -> bool {
+    self.flags.eszip
+  }
+
   pub fn otel_config(&self) -> OtelConfig {
     self.flags.otel_config()
   }

cli/args/mod.rs

@@ -78,6 +78,7 @@ use crate::graph_util::ModuleGraphBuilder;
 use crate::graph_util::ModuleGraphCreator;
 use crate::http_util::HttpClientProvider;
 use crate::module_loader::CliModuleLoaderFactory;
+use crate::module_loader::EszipModuleLoader;
 use crate::module_loader::ModuleLoadPreparer;
 use crate::node::CliCjsCodeAnalyzer;
 use crate::node::CliCjsModuleExportAnalyzer;
@@ -149,10 +150,36 @@ impl RootCertStoreProvider for CliRootCertStoreProvider {
   }
 }
 
+#[derive(Debug)]
+struct EszipModuleLoaderProvider {
+  cli_options: Arc<CliOptions>,
+  deferred: once_cell::sync::OnceCell<Arc<EszipModuleLoader>>,
+}
+
+impl EszipModuleLoaderProvider {
+  pub async fn get(&self) -> Result<Option<&Arc<EszipModuleLoader>>, AnyError> {
+    if self.cli_options.eszip() {
+      if let DenoSubcommand::Run(run_flags) = self.cli_options.sub_command() {
+        if self.deferred.get().is_none() {
+          let eszip_loader = EszipModuleLoader::create(
+            &run_flags.script,
+            self.cli_options.initial_cwd(),
+          )
+          .await?;
+          _ = self.deferred.set(Arc::new(eszip_loader));
+        }
+        return Ok(Some(self.deferred.get().unwrap()));
+      }
+    }
+    Ok(None)
+  }
+}
+
 #[derive(Debug)]
 struct CliSpecifiedImportMapProvider {
   cli_options: Arc<CliOptions>,
   file_fetcher: Arc<CliFileFetcher>,
+  eszip_module_loader_provider: Arc<EszipModuleLoaderProvider>,
   workspace_external_import_map_loader: Arc<WorkspaceExternalImportMapLoader>,
 }
 
@@ -182,14 +209,17 @@ impl SpecifiedImportMapProvider for CliSpecifiedImportMapProvider {
       self.cli_options.resolve_specified_import_map_specifier()?;
     match maybe_import_map_specifier {
       Some(specifier) => {
-        let value = resolve_import_map_value_from_specifier(
-          &specifier,
-          &self.file_fetcher,
-        )
-        .await
-        .with_context(|| {
-          format!("Unable to load '{}' import map", specifier)
-        })?;
+        let value = match self.eszip_module_loader_provider.get().await? {
+          Some(eszip) => eszip.load_import_map_value(&specifier)?,
+          None => resolve_import_map_value_from_specifier(
+            &specifier,
+            &self.file_fetcher,
+          )
+          .await
+          .with_context(|| {
+            format!("Unable to load '{}' import map", specifier)
+          })?,
+        };
         Ok(Some(deno_resolver::workspace::SpecifiedImportMap {
           base_url: specifier,
           value,
@@ -226,6 +256,12 @@ impl<T> Default for Deferred<T> {
   }
 }
 
+impl<T: std::fmt::Debug> std::fmt::Debug for Deferred<T> {
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    f.debug_tuple("Deferred").field(&self.0).finish()
+  }
+}
+
 impl<T> Deferred<T> {
   #[inline(always)]
   pub fn get_or_try_init(
@@ -270,6 +306,7 @@ struct CliFactoryServices {
   deno_dir_provider: Deferred<Arc<DenoDirProvider>>,
   emit_cache: Deferred<Arc<EmitCache>>,
   emitter: Deferred<Arc<Emitter>>,
+  eszip_module_loader_provider: Deferred<Arc<EszipModuleLoaderProvider>>,
   feature_checker: Deferred<Arc<FeatureChecker>>,
   file_fetcher: Deferred<Arc<CliFileFetcher>>,
   found_pkg_json_dep_flag: Arc<FoundPackageJsonDepFlag>,
@@ -455,6 +492,20 @@ impl CliFactory {
     })
   }
 
+  fn eszip_module_loader_provider(
+    &self,
+  ) -> Result<&Arc<EszipModuleLoaderProvider>, AnyError> {
+    self
+      .services
+      .eszip_module_loader_provider
+      .get_or_try_init(|| {
+        Ok(Arc::new(EszipModuleLoaderProvider {
+          cli_options: self.cli_options()?.clone(),
+          deferred: Default::default(),
+        }))
+      })
+  }
+
   pub fn file_fetcher(&self) -> Result<&Arc<CliFileFetcher>, AnyError> {
     self.services.file_fetcher.get_or_try_init(|| {
       let cli_options = self.cli_options()?;
@@ -651,6 +702,9 @@ impl CliFactory {
           npm_system_info: self.flags.subcommand.npm_system_info(),
           specified_import_map: Some(Box::new(CliSpecifiedImportMapProvider {
             cli_options: self.cli_options()?.clone(),
+            eszip_module_loader_provider: self
+              .eszip_module_loader_provider()?
+              .clone(),
             file_fetcher: self.file_fetcher()?.clone(),
             workspace_external_import_map_loader: self
               .workspace_external_import_map_loader()?
@@ -1120,6 +1174,8 @@ impl CliFactory {
       Arc::new(NpmRegistryReadPermissionChecker::new(self.sys(), mode))
     };
 
+    let maybe_eszip_loader =
+      self.eszip_module_loader_provider()?.get().await?.cloned();
     let module_loader_factory = CliModuleLoaderFactory::new(
       cli_options,
       cjs_tracker,
@@ -1145,6 +1201,7 @@ impl CliFactory {
       self.parsed_source_cache().clone(),
       self.resolver().await?.clone(),
       self.sys(),
+      maybe_eszip_loader,
     );
 
     let lib_main_worker_factory = LibMainWorkerFactory::new(

cli/factory.rs

@@ -116,7 +116,7 @@ async fn run_subcommand(flags: Arc<Flags>) -> Result<i32, AnyError> {
     }),
     DenoSubcommand::Bench(bench_flags) => spawn_subcommand(async {
       if bench_flags.watch.is_some() {
-        tools::bench::run_benchmarks_with_watch(flags, bench_flags).await
+        tools::bench::run_benchmarks_with_watch(flags, bench_flags).boxed_local().await
       } else {
         tools::bench::run_benchmarks(flags, bench_flags).await
       }
@@ -138,7 +138,11 @@ async fn run_subcommand(flags: Arc<Flags>) -> Result<i32, AnyError> {
       tools::clean::clean(flags)
     }),
     DenoSubcommand::Compile(compile_flags) => spawn_subcommand(async {
-      tools::compile::compile(flags, compile_flags).await
+      if compile_flags.eszip {
+        tools::compile::compile_eszip(flags, compile_flags).boxed_local().await
+      } else {
+        tools::compile::compile(flags, compile_flags).await
+      }
     }),
     DenoSubcommand::Coverage(coverage_flags) => spawn_subcommand(async {
       tools::coverage::cover_files(flags, coverage_flags)
@@ -202,7 +206,10 @@ async fn run_subcommand(flags: Arc<Flags>) -> Result<i32, AnyError> {
     }
     DenoSubcommand::Run(run_flags) => spawn_subcommand(async move {
       if run_flags.is_stdin() {
-        tools::run::run_from_stdin(flags.clone()).await
+        // these futures are boxed to prevent stack overflows on Windows
+        tools::run::run_from_stdin(flags.clone()).boxed_local().await
+      } else if flags.eszip {
+        tools::run::run_eszip(flags, run_flags).boxed_local().await
       } else {
         let result = tools::run::run_script(WorkerExecutionMode::Run, flags.clone(), run_flags.watch).await;
         match result {