refactor(compile): remove usage of ProcState and CliOptions (#18855)

cli/args/flags.rs

@@ -2230,7 +2230,7 @@ fn check_arg(checks_local_by_default: bool) -> Arg {
 default, so adding --check is redundant.
 If the value of '--check=all' is supplied, diagnostic errors from remote modules
 will be included.
-  
+
 Alternatively, the 'deno check' subcommand can be used.",
     )
   } else {
@@ -2745,7 +2745,8 @@ fn run_parse(flags: &mut Flags, matches: &mut ArgMatches) {
 fn task_parse(flags: &mut Flags, matches: &mut ArgMatches) {
   flags.config_flag = matches
     .remove_one::<String>("config")
-    .map_or(ConfigFlag::Discover, ConfigFlag::Path);
+    .map(ConfigFlag::Path)
+    .unwrap_or(ConfigFlag::Discover);
 
   let mut task_flags = TaskFlags {
     cwd: matches.remove_one::<String>("cwd"),

cli/lsp/language_server.rs

@@ -430,8 +430,8 @@ fn create_lsp_structs(
 ) {
   let registry_url = CliNpmRegistryApi::default_url();
   let progress_bar = ProgressBar::new(ProgressBarStyle::TextOnly);
-  let npm_cache = Arc::new(NpmCache::from_deno_dir(
+  let npm_cache = Arc::new(NpmCache::new(
-    dir,
+    dir.npm_folder_path(),
     // Use an "only" cache setting in order to make the
     // user do an explicit "cache" command and prevent
     // the cache from being filled with lots of packages while

cli/npm/cache.rs

@@ -129,7 +129,7 @@ impl Default for ReadonlyNpmCache {
     // This only gets used when creating the tsc runtime and for testing, and so
     // it shouldn't ever actually access the DenoDir, so it doesn't support a
     // custom root.
-    Self::from_deno_dir(&DenoDir::new(None).unwrap())
+    Self::new(DenoDir::new(None).unwrap().npm_folder_path())
   }
 }
 
@@ -155,10 +155,6 @@ impl ReadonlyNpmCache {
     }
   }
 
-  pub fn from_deno_dir(dir: &DenoDir) -> Self {
-    Self::new(dir.npm_folder_path())
-  }
-
   pub fn root_dir_url(&self) -> &Url {
     &self.root_dir_url
   }
@@ -306,14 +302,14 @@ pub struct NpmCache {
 }
 
 impl NpmCache {
-  pub fn from_deno_dir(
+  pub fn new(
-    dir: &DenoDir,
+    cache_dir_path: PathBuf,
     cache_setting: CacheSetting,
     http_client: HttpClient,
     progress_bar: ProgressBar,
   ) -> Self {
     Self {
-      readonly: ReadonlyNpmCache::from_deno_dir(dir),
+      readonly: ReadonlyNpmCache::new(cache_dir_path),
       cache_setting,
       http_client,
       progress_bar,

cli/proc_state.rs

@@ -227,8 +227,8 @@ impl ProcState {
     let lockfile = cli_options.maybe_lock_file();
 
     let npm_registry_url = CliNpmRegistryApi::default_url().to_owned();
-    let npm_cache = Arc::new(NpmCache::from_deno_dir(
+    let npm_cache = Arc::new(NpmCache::new(
-      &dir,
+      dir.npm_folder_path(),
       cli_options.cache_setting(),
       http_client.clone(),
       progress_bar.clone(),
@@ -250,7 +250,7 @@ impl ProcState {
     let node_fs = Arc::new(deno_node::RealFs);
     let npm_fs_resolver = create_npm_fs_resolver(
       node_fs.clone(),
-      npm_cache,
+      npm_cache.clone(),
       &progress_bar,
       npm_registry_url,
       npm_resolution.clone(),
@@ -302,12 +302,6 @@ impl ProcState {
       parsed_source_cache.clone(),
       emit_options,
     ));
-    let npm_cache = Arc::new(NpmCache::from_deno_dir(
-      &dir,
-      cli_options.cache_setting(),
-      http_client.clone(),
-      progress_bar.clone(),
-    ));
     let file_fetcher = Arc::new(file_fetcher);
     let node_analysis_cache =
       NodeAnalysisCache::new(caches.node_analysis_db(&dir));

cli/standalone/mod.rs

@@ -1,11 +1,20 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 
+use crate::args::get_root_cert_store;
 use crate::args::CaData;
-use crate::args::Flags;
+use crate::args::CacheSetting;
+use crate::cache::DenoDir;
 use crate::colors;
 use crate::file_fetcher::get_source_from_data_url;
+use crate::http_util::HttpClient;
+use crate::npm::create_npm_fs_resolver;
+use crate::npm::CliNpmRegistryApi;
+use crate::npm::CliNpmResolver;
+use crate::npm::NpmCache;
+use crate::npm::NpmResolution;
 use crate::ops;
-use crate::proc_state::ProcState;
+use crate::util::progress_bar::ProgressBar;
+use crate::util::progress_bar::ProgressBarStyle;
 use crate::util::v8::construct_v8_flags;
 use crate::version;
 use crate::CliGraphResolver;
@@ -16,11 +25,17 @@ use deno_core::futures::task::LocalFutureObj;
 use deno_core::futures::FutureExt;
 use deno_core::located_script_name;
 use deno_core::v8_set_flags;
+use deno_core::CompiledWasmModuleStore;
 use deno_core::ModuleLoader;
 use deno_core::ModuleSpecifier;
 use deno_core::ModuleType;
 use deno_core::ResolutionKind;
+use deno_core::SharedArrayBufferStore;
 use deno_graph::source::Resolver;
+use deno_runtime::deno_broadcast_channel::InMemoryBroadcastChannel;
+use deno_runtime::deno_node;
+use deno_runtime::deno_tls::rustls::RootCertStore;
+use deno_runtime::deno_web::BlobStore;
 use deno_runtime::fmt_errors::format_js_error;
 use deno_runtime::ops::worker_host::CreateWebWorkerCb;
 use deno_runtime::ops::worker_host::WorkerEventCb;
@@ -122,28 +137,6 @@ impl ModuleLoader for EmbeddedModuleLoader {
   }
 }
 
-fn metadata_to_flags(metadata: &Metadata) -> Flags {
-  let permissions = metadata.permissions.clone();
-  Flags {
-    argv: metadata.argv.clone(),
-    unstable: metadata.unstable,
-    seed: metadata.seed,
-    location: metadata.location.clone(),
-    allow_env: permissions.allow_env,
-    allow_hrtime: permissions.allow_hrtime,
-    allow_net: permissions.allow_net,
-    allow_ffi: permissions.allow_ffi,
-    allow_read: permissions.allow_read,
-    allow_run: permissions.allow_run,
-    allow_write: permissions.allow_write,
-    v8_flags: metadata.v8_flags.clone(),
-    log_level: metadata.log_level,
-    ca_stores: metadata.ca_stores.clone(),
-    ca_data: metadata.ca_data.clone().map(CaData::Bytes),
-    ..Default::default()
-  }
-}
-
 fn web_worker_callback() -> Arc<WorkerEventCb> {
   Arc::new(|worker| {
     let fut = async move { Ok(worker) };
@@ -151,25 +144,41 @@ fn web_worker_callback() -> Arc<WorkerEventCb> {
   })
 }
 
+struct SharedWorkerState {
+  npm_resolver: Arc<CliNpmResolver>,
+  root_cert_store: RootCertStore,
+  node_fs: Arc<dyn deno_node::NodeFs>,
+  blob_store: BlobStore,
+  broadcast_channel: InMemoryBroadcastChannel,
+  shared_array_buffer_store: SharedArrayBufferStore,
+  compiled_wasm_module_store: CompiledWasmModuleStore,
+  // options
+  argv: Vec<String>,
+  seed: Option<u64>,
+  unsafely_ignore_certificate_errors: Option<Vec<String>>,
+  unstable: bool,
+}
+
 fn create_web_worker_callback(
-  ps: &ProcState,
+  shared: &Arc<SharedWorkerState>,
-  module_loader: &Rc<EmbeddedModuleLoader>,
+  module_loader: &EmbeddedModuleLoader,
 ) -> Arc<CreateWebWorkerCb> {
-  let ps = ps.clone();
+  let shared = shared.clone();
-  let module_loader = module_loader.as_ref().clone();
+  let module_loader = module_loader.clone();
   Arc::new(move |args| {
     let module_loader = Rc::new(module_loader.clone());
 
-    let create_web_worker_cb = create_web_worker_callback(&ps, &module_loader);
+    let create_web_worker_cb =
+      create_web_worker_callback(&shared, &module_loader);
     let web_worker_cb = web_worker_callback();
 
     let options = WebWorkerOptions {
       bootstrap: BootstrapOptions {
-        args: ps.options.argv().clone(),
+        args: shared.argv.clone(),
         cpu_count: std::thread::available_parallelism()
           .map(|p| p.get())
           .unwrap_or(1),
-        debug_flag: ps.options.log_level().map_or(false, |l| l == Level::Debug),
+        debug_flag: false,
         enable_testing_features: false,
         locale: deno_core::v8::icu::get_language_tag(),
         location: Some(args.main_module.clone()),
@@ -177,20 +186,19 @@ fn create_web_worker_callback(
         is_tty: colors::is_tty(),
         runtime_version: version::deno().to_string(),
         ts_version: version::TYPESCRIPT.to_string(),
-        unstable: ps.options.unstable(),
+        unstable: shared.unstable,
         user_agent: version::get_user_agent().to_string(),
-        inspect: ps.options.is_inspecting(),
+        inspect: false,
       },
-      extensions: ops::cli_exts(ps.npm_resolver.clone()),
+      extensions: ops::cli_exts(shared.npm_resolver.clone()),
       startup_snapshot: Some(crate::js::deno_isolate_init()),
-      unsafely_ignore_certificate_errors: ps
+      unsafely_ignore_certificate_errors: shared
-        .options
+        .unsafely_ignore_certificate_errors
-        .unsafely_ignore_certificate_errors()
         .clone(),
-      root_cert_store: Some(ps.root_cert_store.clone()),
+      root_cert_store: Some(shared.root_cert_store.clone()),
-      seed: ps.options.seed(),
+      seed: shared.seed,
       module_loader,
-      node_fs: Some(ps.node_fs.clone()),
+      node_fs: Some(shared.node_fs.clone()),
       npm_resolver: None, // not currently supported
       create_web_worker_cb,
       preload_module_cb: web_worker_cb.clone(),
@@ -200,10 +208,12 @@ fn create_web_worker_callback(
       worker_type: args.worker_type,
       maybe_inspector_server: None,
       get_error_class_fn: Some(&get_error_class_name),
-      blob_store: ps.blob_store.clone(),
+      blob_store: shared.blob_store.clone(),
-      broadcast_channel: ps.broadcast_channel.clone(),
+      broadcast_channel: shared.broadcast_channel.clone(),
-      shared_array_buffer_store: Some(ps.shared_array_buffer_store.clone()),
+      shared_array_buffer_store: Some(shared.shared_array_buffer_store.clone()),
-      compiled_wasm_module_store: Some(ps.compiled_wasm_module_store.clone()),
+      compiled_wasm_module_store: Some(
+        shared.compiled_wasm_module_store.clone(),
+      ),
       cache_storage_dir: None,
       stdio: Default::default(),
     };
@@ -222,13 +232,67 @@ pub async fn run(
   eszip: eszip::EszipV2,
   metadata: Metadata,
 ) -> Result<(), AnyError> {
-  let flags = metadata_to_flags(&metadata);
   let main_module = &metadata.entrypoint;
-  let ps = ProcState::from_flags(flags).await?;
+  let dir = DenoDir::new(None)?;
+  let root_cert_store = get_root_cert_store(
+    None,
+    metadata.ca_stores,
+    metadata.ca_data.map(CaData::Bytes),
+  )?;
+  let progress_bar = ProgressBar::new(ProgressBarStyle::TextOnly);
+  let http_client = HttpClient::new(
+    Some(root_cert_store.clone()),
+    metadata.unsafely_ignore_certificate_errors.clone(),
+  )?;
+  let npm_registry_url = CliNpmRegistryApi::default_url().to_owned();
+  let npm_cache = Arc::new(NpmCache::new(
+    dir.npm_folder_path(),
+    CacheSetting::Use,
+    http_client.clone(),
+    progress_bar.clone(),
+  ));
+  let npm_api = Arc::new(CliNpmRegistryApi::new(
+    npm_registry_url.clone(),
+    npm_cache.clone(),
+    http_client.clone(),
+    progress_bar.clone(),
+  ));
+  let node_fs = Arc::new(deno_node::RealFs);
+  let npm_resolution =
+    Arc::new(NpmResolution::from_serialized(npm_api.clone(), None, None));
+  let npm_fs_resolver = create_npm_fs_resolver(
+    node_fs.clone(),
+    npm_cache,
+    &progress_bar,
+    npm_registry_url,
+    npm_resolution.clone(),
+    None,
+  );
+  let npm_resolver = Arc::new(CliNpmResolver::new(
+    npm_resolution.clone(),
+    npm_fs_resolver,
+    None,
+  ));
+
+  let shared = Arc::new(SharedWorkerState {
+    npm_resolver,
+    root_cert_store,
+    node_fs,
+    blob_store: BlobStore::default(),
+    broadcast_channel: InMemoryBroadcastChannel::default(),
+    shared_array_buffer_store: SharedArrayBufferStore::default(),
+    compiled_wasm_module_store: CompiledWasmModuleStore::default(),
+    argv: metadata.argv,
+    seed: metadata.seed,
+    unsafely_ignore_certificate_errors: metadata
+      .unsafely_ignore_certificate_errors,
+    unstable: metadata.unstable,
+  });
+
   let permissions = PermissionsContainer::new(Permissions::from_options(
     &metadata.permissions,
   )?);
-  let module_loader = Rc::new(EmbeddedModuleLoader {
+  let module_loader = EmbeddedModuleLoader {
     eszip: Arc::new(eszip),
     maybe_import_map_resolver: metadata.maybe_import_map.map(
       |(base, source)| {
@@ -238,21 +302,22 @@ pub async fn run(
             parse_from_json(&base, &source).unwrap().import_map,
           )),
           false,
-          ps.npm_api.clone(),
+          npm_api.clone(),
-          ps.npm_resolution.clone(),
+          npm_resolution.clone(),
-          ps.package_json_deps_installer.clone(),
+          Default::default(),
         ))
       },
     ),
-  });
+  };
-  let create_web_worker_cb = create_web_worker_callback(&ps, &module_loader);
+  let create_web_worker_cb =
+    create_web_worker_callback(&shared, &module_loader);
   let web_worker_cb = web_worker_callback();
 
   v8_set_flags(construct_v8_flags(&metadata.v8_flags, vec![]));
 
   let options = WorkerOptions {
     bootstrap: BootstrapOptions {
-      args: metadata.argv,
+      args: shared.argv.clone(),
       cpu_count: std::thread::available_parallelism()
         .map(|p| p.get())
         .unwrap_or(1),
@@ -269,13 +334,14 @@ pub async fn run(
       ts_version: version::TYPESCRIPT.to_string(),
       unstable: metadata.unstable,
       user_agent: version::get_user_agent().to_string(),
-      inspect: ps.options.is_inspecting(),
+      inspect: false,
     },
-    extensions: ops::cli_exts(ps.npm_resolver.clone()),
+    extensions: ops::cli_exts(shared.npm_resolver.clone()),
     startup_snapshot: Some(crate::js::deno_isolate_init()),
-    unsafely_ignore_certificate_errors: metadata
+    unsafely_ignore_certificate_errors: shared
-      .unsafely_ignore_certificate_errors,
+      .unsafely_ignore_certificate_errors
-    root_cert_store: Some(ps.root_cert_store.clone()),
+      .clone(),
+    root_cert_store: Some(shared.root_cert_store.clone()),
     seed: metadata.seed,
     source_map_getter: None,
     format_js_error_fn: Some(Arc::new(format_js_error)),
@@ -285,16 +351,16 @@ pub async fn run(
     maybe_inspector_server: None,
     should_break_on_first_statement: false,
     should_wait_for_inspector_session: false,
-    module_loader,
+    module_loader: Rc::new(module_loader),
-    node_fs: Some(ps.node_fs.clone()),
+    node_fs: Some(shared.node_fs.clone()),
     npm_resolver: None, // not currently supported
     get_error_class_fn: Some(&get_error_class_name),
     cache_storage_dir: None,
     origin_storage_dir: None,
-    blob_store: ps.blob_store.clone(),
+    blob_store: shared.blob_store.clone(),
-    broadcast_channel: ps.broadcast_channel.clone(),
+    broadcast_channel: shared.broadcast_channel.clone(),
-    shared_array_buffer_store: Some(ps.shared_array_buffer_store.clone()),
+    shared_array_buffer_store: Some(shared.shared_array_buffer_store.clone()),
-    compiled_wasm_module_store: Some(ps.compiled_wasm_module_store.clone()),
+    compiled_wasm_module_store: Some(shared.compiled_wasm_module_store.clone()),
     stdio: Default::default(),
   };
   let mut worker = MainWorker::bootstrap_from_options(

cli/tools/bench.rs

@@ -931,7 +931,10 @@ mod mitata {
       sysctl.arg("-n");
       sysctl.arg("machdep.cpu.brand_string");
       return std::str::from_utf8(
-        &sysctl.output().map_or(Vec::from("unknown"), |x| x.stdout),
+        &sysctl
+          .output()
+          .map(|x| x.stdout)
+          .unwrap_or(Vec::from("unknown")),
       )
       .unwrap()
       .trim()