refactor(cli): extract out ProcState from CliMainWorker (#18867)

cli/tools/repl/mod.rs

@@ -1,10 +1,11 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 
+use crate::args::CliOptions;
 use crate::args::Flags;
 use crate::args::ReplFlags;
 use crate::colors;
+use crate::file_fetcher::FileFetcher;
 use crate::proc_state::ProcState;
-use crate::worker::create_main_worker;
 use deno_core::error::AnyError;
 use deno_runtime::permissions::Permissions;
 use deno_runtime::permissions::PermissionsContainer;
@@ -65,14 +66,14 @@ async fn read_line_and_poll(
 }
 
 async fn read_eval_file(
-  ps: &ProcState,
+  cli_options: &CliOptions,
+  file_fetcher: &FileFetcher,
   eval_file: &str,
 ) -> Result<String, AnyError> {
   let specifier =
-    deno_core::resolve_url_or_path(eval_file, ps.options.initial_cwd())?;
+    deno_core::resolve_url_or_path(eval_file, cli_options.initial_cwd())?;
 
-  let file = ps
-    .file_fetcher
+  let file = file_fetcher
     .fetch(&specifier, PermissionsContainer::allow_all())
     .await?;
 
@@ -82,17 +83,24 @@ async fn read_eval_file(
 pub async fn run(flags: Flags, repl_flags: ReplFlags) -> Result<i32, AnyError> {
   let ps = ProcState::from_flags(flags).await?;
   let main_module = ps.options.resolve_main_module()?;
-  let mut worker = create_main_worker(
-    &ps,
-    main_module,
-    PermissionsContainer::new(Permissions::from_options(
-      &ps.options.permissions_options(),
-    )?),
-  )
-  .await?;
+  let permissions = PermissionsContainer::new(Permissions::from_options(
+    &ps.options.permissions_options(),
+  )?);
+  let cli_options = ps.options.clone();
+  let npm_resolver = ps.npm_resolver.clone();
+  let resolver = ps.resolver.clone();
+  let dir = ps.dir.clone();
+  let file_fetcher = ps.file_fetcher.clone();
+  let worker_factory = ps.into_cli_main_worker_factory();
+
+  let mut worker = worker_factory
+    .create_main_worker(main_module, permissions)
+    .await?;
   worker.setup_repl().await?;
   let worker = worker.into_main_worker();
-  let mut repl_session = ReplSession::initialize(ps.clone(), worker).await?;
+  let mut repl_session =
+    ReplSession::initialize(&cli_options, npm_resolver, resolver, worker)
+      .await?;
   let mut rustyline_channel = rustyline_channel();
 
   let helper = EditorHelper {
@@ -100,12 +108,12 @@ pub async fn run(flags: Flags, repl_flags: ReplFlags) -> Result<i32, AnyError> {
     sync_sender: rustyline_channel.0,
   };
 
-  let history_file_path = ps.dir.repl_history_file_path();
+  let history_file_path = dir.repl_history_file_path();
   let editor = ReplEditor::new(helper, history_file_path)?;
 
   if let Some(eval_files) = repl_flags.eval_files {
     for eval_file in eval_files {
-      match read_eval_file(&ps, &eval_file).await {
+      match read_eval_file(&cli_options, &file_fetcher, &eval_file).await {
         Ok(eval_source) => {
           let output = repl_session
             .evaluate_line_and_get_output(&eval_source)
@@ -132,7 +140,7 @@ pub async fn run(flags: Flags, repl_flags: ReplFlags) -> Result<i32, AnyError> {
 
   // Doing this manually, instead of using `log::info!` because these messages
   // are supposed to go to stdout, not stderr.
-  if !ps.options.is_quiet() {
+  if !cli_options.is_quiet() {
     println!("Deno {}", crate::version::deno());
     println!("exit using ctrl+d, ctrl+c, or close()");
     if repl_flags.is_default_command {

cli/tools/repl/session.rs

@@ -1,8 +1,12 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 
+use std::sync::Arc;
+
+use crate::args::CliOptions;
 use crate::colors;
 use crate::lsp::ReplLanguageServer;
-use crate::ProcState;
+use crate::npm::CliNpmResolver;
+use crate::resolver::CliGraphResolver;
 
 use deno_ast::swc::ast as swc_ast;
 use deno_ast::swc::visit::noop_visit_type;
@@ -117,7 +121,9 @@ struct TsEvaluateResponse {
 }
 
 pub struct ReplSession {
-  proc_state: ProcState,
+  has_node_modules_dir: bool,
+  npm_resolver: Arc<CliNpmResolver>,
+  resolver: Arc<CliGraphResolver>,
   pub worker: MainWorker,
   session: LocalInspectorSession,
   pub context_id: u64,
@@ -132,7 +138,9 @@ pub struct ReplSession {
 
 impl ReplSession {
   pub async fn initialize(
-    proc_state: ProcState,
+    cli_options: &CliOptions,
+    npm_resolver: Arc<CliNpmResolver>,
+    resolver: Arc<CliGraphResolver>,
     mut worker: MainWorker,
   ) -> Result<Self, AnyError> {
     let language_server = ReplLanguageServer::new_initialized().await?;
@@ -171,14 +179,14 @@ impl ReplSession {
     }
     assert_ne!(context_id, 0);
 
-    let referrer = deno_core::resolve_path(
-      "./$deno$repl.ts",
-      proc_state.options.initial_cwd(),
-    )
-    .unwrap();
+    let referrer =
+      deno_core::resolve_path("./$deno$repl.ts", cli_options.initial_cwd())
+        .unwrap();
 
     let mut repl_session = ReplSession {
-      proc_state,
+      has_node_modules_dir: cli_options.has_node_modules_dir(),
+      npm_resolver,
+      resolver,
       worker,
       session,
       context_id,
@@ -487,7 +495,6 @@ impl ReplSession {
       .iter()
       .flat_map(|i| {
         self
-          .proc_state
           .resolver
           .resolve(i, &self.referrer)
           .ok()
@@ -506,22 +513,17 @@ impl ReplSession {
       if !self.has_initialized_node_runtime {
         deno_node::initialize_runtime(
           &mut self.worker.js_runtime,
-          self.proc_state.options.has_node_modules_dir(),
+          self.has_node_modules_dir,
           None,
         )?;
         self.has_initialized_node_runtime = true;
       }
 
-      self
-        .proc_state
-        .npm_resolver
-        .add_package_reqs(npm_imports)
-        .await?;
+      self.npm_resolver.add_package_reqs(npm_imports).await?;
 
       // prevent messages in the repl about @types/node not being cached
       if has_node_specifier {
         self
-          .proc_state
           .npm_resolver
           .inject_synthetic_types_node_package()
           .await?;