refactor: Rename ProgramState to ProcState (#12204)

Move Arc into struct

1 files changed, 136 insertions, 174 deletions

diff --git a/cli/main.rs b/cli/main.rs
index 8c27e34b7..a217d2cf4 100644
--- a/cli/main.rs
+++ b/cli/main.rs
@@ -24,7 +24,7 @@ mod lsp;
 mod module_graph;
 mod module_loader;
 mod ops;
-mod program_state;
+mod proc_state;
 mod source_maps;
 mod specifier_handler;
 mod standalone;
@@ -56,7 +56,7 @@ use crate::flags::TestFlags;
 use crate::flags::UpgradeFlags;
 use crate::fmt_errors::PrettyJsError;
 use crate::module_loader::CliModuleLoader;
-use crate::program_state::ProgramState;
+use crate::proc_state::ProcState;
 use crate::source_maps::apply_source_map;
 use crate::specifier_handler::FetchHandler;
 use crate::tools::installer::infer_name_from_url;
@@ -91,42 +91,36 @@ use std::pin::Pin;
 use std::rc::Rc;
 use std::sync::Arc;
 
-fn create_web_worker_callback(
-  program_state: Arc<ProgramState>,
-) -> Arc<CreateWebWorkerCb> {
+fn create_web_worker_callback(ps: ProcState) -> Arc<CreateWebWorkerCb> {
   Arc::new(move |args| {
-    let global_state_ = program_state.clone();
+    let global_state_ = ps.clone();
     let js_error_create_fn = Rc::new(move |core_js_error| {
       let source_mapped_error =
         apply_source_map(&core_js_error, global_state_.clone());
       PrettyJsError::create(source_mapped_error)
     });
 
-    let maybe_inspector_server = program_state.maybe_inspector_server.clone();
+    let maybe_inspector_server = ps.maybe_inspector_server.clone();
 
     let module_loader = CliModuleLoader::new_for_worker(
-      program_state.clone(),
+      ps.clone(),
       args.parent_permissions.clone(),
     );
-    let create_web_worker_cb =
-      create_web_worker_callback(program_state.clone());
+    let create_web_worker_cb = create_web_worker_callback(ps.clone());
 
     let options = WebWorkerOptions {
-      args: program_state.flags.argv.clone(),
+      args: ps.flags.argv.clone(),
       apply_source_maps: true,
-      debug_flag: program_state
-        .flags
-        .log_level
-        .map_or(false, |l| l == log::Level::Debug),
-      unstable: program_state.flags.unstable,
-      enable_testing_features: program_state.flags.enable_testing_features,
-      unsafely_ignore_certificate_errors: program_state
+      debug_flag: ps.flags.log_level.map_or(false, |l| l == log::Level::Debug),
+      unstable: ps.flags.unstable,
+      enable_testing_features: ps.flags.enable_testing_features,
+      unsafely_ignore_certificate_errors: ps
         .flags
         .unsafely_ignore_certificate_errors
         .clone(),
-      root_cert_store: program_state.root_cert_store.clone(),
+      root_cert_store: ps.root_cert_store.clone(),
       user_agent: version::get_user_agent(),
-      seed: program_state.flags.seed,
+      seed: ps.flags.seed,
       module_loader,
       create_web_worker_cb,
       js_error_create_fn: Some(js_error_create_fn),
@@ -137,11 +131,9 @@ fn create_web_worker_callback(
       ts_version: version::TYPESCRIPT.to_string(),
       no_color: !colors::use_color(),
       get_error_class_fn: Some(&crate::errors::get_error_class_name),
-      blob_store: program_state.blob_store.clone(),
-      broadcast_channel: program_state.broadcast_channel.clone(),
-      shared_array_buffer_store: Some(
-        program_state.shared_array_buffer_store.clone(),
-      ),
+      blob_store: ps.blob_store.clone(),
+      broadcast_channel: ps.broadcast_channel.clone(),
+      shared_array_buffer_store: Some(ps.shared_array_buffer_store.clone()),
       cpu_count: num_cpus::get(),
     };
 
@@ -160,7 +152,7 @@ fn create_web_worker_callback(
       js_runtime
         .op_state()
         .borrow_mut()
-        .put::<Arc<ProgramState>>(program_state.clone());
+        .put::<ProcState>(ps.clone());
       // Applies source maps - works in conjuction with `js_error_create_fn`
       // above
       ops::errors::init(js_runtime);
@@ -176,14 +168,14 @@ fn create_web_worker_callback(
 }
 
 pub fn create_main_worker(
-  program_state: &Arc<ProgramState>,
+  ps: &ProcState,
   main_module: ModuleSpecifier,
   permissions: Permissions,
   maybe_op_init: Option<&dyn Fn(&mut JsRuntime)>,
 ) -> MainWorker {
-  let module_loader = CliModuleLoader::new(program_state.clone());
+  let module_loader = CliModuleLoader::new(ps.clone());
 
-  let global_state_ = program_state.clone();
+  let global_state_ = ps.clone();
 
   let js_error_create_fn = Rc::new(move |core_js_error| {
     let source_mapped_error =
@@ -191,28 +183,24 @@ pub fn create_main_worker(
     PrettyJsError::create(source_mapped_error)
   });
 
-  let maybe_inspector_server = program_state.maybe_inspector_server.clone();
-  let should_break_on_first_statement =
-    program_state.flags.inspect_brk.is_some();
+  let maybe_inspector_server = ps.maybe_inspector_server.clone();
+  let should_break_on_first_statement = ps.flags.inspect_brk.is_some();
 
-  let create_web_worker_cb = create_web_worker_callback(program_state.clone());
+  let create_web_worker_cb = create_web_worker_callback(ps.clone());
 
   let options = WorkerOptions {
     apply_source_maps: true,
-    args: program_state.flags.argv.clone(),
-    debug_flag: program_state
-      .flags
-      .log_level
-      .map_or(false, |l| l == log::Level::Debug),
-    unstable: program_state.flags.unstable,
-    enable_testing_features: program_state.flags.enable_testing_features,
-    unsafely_ignore_certificate_errors: program_state
+    args: ps.flags.argv.clone(),
+    debug_flag: ps.flags.log_level.map_or(false, |l| l == log::Level::Debug),
+    unstable: ps.flags.unstable,
+    enable_testing_features: ps.flags.enable_testing_features,
+    unsafely_ignore_certificate_errors: ps
       .flags
       .unsafely_ignore_certificate_errors
       .clone(),
-    root_cert_store: program_state.root_cert_store.clone(),
+    root_cert_store: ps.root_cert_store.clone(),
     user_agent: version::get_user_agent(),
-    seed: program_state.flags.seed,
+    seed: ps.flags.seed,
     js_error_create_fn: Some(js_error_create_fn),
     create_web_worker_cb,
     maybe_inspector_server,
@@ -222,21 +210,18 @@ pub fn create_main_worker(
     ts_version: version::TYPESCRIPT.to_string(),
     no_color: !colors::use_color(),
     get_error_class_fn: Some(&crate::errors::get_error_class_name),
-    location: program_state.flags.location.clone(),
-    origin_storage_dir: program_state.flags.location.clone().map(|loc| {
-      program_state
-        .dir
+    location: ps.flags.location.clone(),
+    origin_storage_dir: ps.flags.location.clone().map(|loc| {
+      ps.dir
         .root
         .clone()
         // TODO(@crowlKats): change to origin_data for 2.0
         .join("location_data")
         .join(checksum::gen(&[loc.to_string().as_bytes()]))
     }),
-    blob_store: program_state.blob_store.clone(),
-    broadcast_channel: program_state.broadcast_channel.clone(),
-    shared_array_buffer_store: Some(
-      program_state.shared_array_buffer_store.clone(),
-    ),
+    blob_store: ps.blob_store.clone(),
+    broadcast_channel: ps.broadcast_channel.clone(),
+    shared_array_buffer_store: Some(ps.shared_array_buffer_store.clone()),
     cpu_count: num_cpus::get(),
   };
 
@@ -249,7 +234,7 @@ pub fn create_main_worker(
     js_runtime
       .op_state()
       .borrow_mut()
-      .put::<Arc<ProgramState>>(program_state.clone());
+      .put::<ProcState>(ps.clone());
     // Applies source maps - works in conjuction with `js_error_create_fn`
     // above
     ops::errors::init(js_runtime);
@@ -291,7 +276,7 @@ where
 }
 
 fn print_cache_info(
-  state: &Arc<ProgramState>,
+  state: &ProcState,
   json: bool,
   location: Option<deno_core::url::Url>,
 ) -> Result<(), AnyError> {
@@ -387,8 +372,8 @@ async fn compile_command(
   )?;
 
   let module_specifier = resolve_url_or_path(&compile_flags.source_file)?;
-  let program_state = ProgramState::build(flags.clone()).await?;
-  let deno_dir = &program_state.dir;
+  let ps = ProcState::build(flags.clone()).await?;
+  let deno_dir = &ps.dir;
 
   let output = compile_flags.output.or_else(|| {
     infer_name_from_url(&module_specifier).map(PathBuf::from)
@@ -398,7 +383,7 @@ async fn compile_command(
 
   let module_graph = create_module_graph_and_maybe_check(
     module_specifier.clone(),
-    program_state.clone(),
+    ps.clone(),
     debug,
   )
   .await?;
@@ -408,8 +393,7 @@ async fn compile_command(
     colors::green("Bundle"),
     module_specifier.to_string()
   );
-  let bundle_str =
-    bundle_module_graph(module_graph, program_state.clone(), flags, debug)?;
+  let bundle_str = bundle_module_graph(module_graph, ps.clone(), flags, debug)?;
 
   info!(
     "{} {}",
@@ -445,11 +429,11 @@ async fn info_command(
   info_flags: InfoFlags,
 ) -> Result<(), AnyError> {
   let location = flags.location.clone();
-  let program_state = ProgramState::build(flags).await?;
+  let ps = ProcState::build(flags).await?;
   if let Some(specifier) = info_flags.file {
     let specifier = resolve_url_or_path(&specifier)?;
     let handler = Arc::new(Mutex::new(specifier_handler::FetchHandler::new(
-      &program_state,
+      &ps,
       // info accesses dynamically imported modules just for their information
       // so we allow access to all of them.
       Permissions::allow_all(),
@@ -457,13 +441,11 @@ async fn info_command(
     )?));
     let mut builder = module_graph::GraphBuilder::new(
       handler,
-      program_state.maybe_import_map.clone(),
-      program_state.lockfile.clone(),
+      ps.maybe_import_map.clone(),
+      ps.lockfile.clone(),
     );
     builder.add(&specifier, false).await?;
-    builder
-      .analyze_config_file(&program_state.maybe_config_file)
-      .await?;
+    builder.analyze_config_file(&ps.maybe_config_file).await?;
     let graph = builder.get_graph();
     let info = graph.info()?;
 
@@ -475,7 +457,7 @@ async fn info_command(
     }
   } else {
     // If it was just "deno info" print location of caches and exit
-    print_cache_info(&program_state, info_flags.json, location)
+    print_cache_info(&ps, info_flags.json, location)
   }
 }
 
@@ -487,10 +469,10 @@ async fn install_command(
   preload_flags.inspect = None;
   preload_flags.inspect_brk = None;
   let permissions = Permissions::from_options(&preload_flags.clone().into());
-  let program_state = ProgramState::build(preload_flags).await?;
+  let ps = ProcState::build(preload_flags).await?;
   let main_module = resolve_url_or_path(&install_flags.module_url)?;
   let mut worker =
-    create_main_worker(&program_state, main_module.clone(), permissions, None);
+    create_main_worker(&ps, main_module.clone(), permissions, None);
   // First, fetch and compile the module; this step ensures that the module exists.
   worker.preload_module(&main_module, true).await?;
   tools::installer::install(
@@ -517,13 +499,12 @@ async fn lint_command(
     return Ok(());
   }
 
-  let program_state = ProgramState::build(flags.clone()).await?;
-  let maybe_lint_config =
-    if let Some(config_file) = &program_state.maybe_config_file {
-      config_file.to_lint_config()?
-    } else {
-      None
-    };
+  let ps = ProcState::build(flags.clone()).await?;
+  let maybe_lint_config = if let Some(config_file) = &ps.maybe_config_file {
+    config_file.to_lint_config()?
+  } else {
+    None
+  };
 
   tools::lint::lint_files(
     maybe_lint_config,
@@ -546,20 +527,19 @@ async fn cache_command(
   } else {
     module_graph::TypeLib::DenoWindow
   };
-  let program_state = ProgramState::build(flags).await?;
+  let ps = ProcState::build(flags).await?;
 
   for file in cache_flags.files {
     let specifier = resolve_url_or_path(&file)?;
-    program_state
-      .prepare_module_load(
-        specifier,
-        lib.clone(),
-        Permissions::allow_all(),
-        Permissions::allow_all(),
-        false,
-        program_state.maybe_import_map.clone(),
-      )
-      .await?;
+    ps.prepare_module_load(
+      specifier,
+      lib.clone(),
+      Permissions::allow_all(),
+      Permissions::allow_all(),
+      false,
+      ps.maybe_import_map.clone(),
+    )
+    .await?;
   }
 
   Ok(())
@@ -572,9 +552,9 @@ async fn eval_command(
   // Force TypeScript compile.
   let main_module = resolve_url_or_path("./$deno$eval.ts").unwrap();
   let permissions = Permissions::from_options(&flags.clone().into());
-  let program_state = ProgramState::build(flags).await?;
+  let ps = ProcState::build(flags).await?;
   let mut worker =
-    create_main_worker(&program_state, main_module.clone(), permissions, None);
+    create_main_worker(&ps, main_module.clone(), permissions, None);
   // Create a dummy source file.
   let source_code = if eval_flags.print {
     format!("console.log({})", eval_flags.code)
@@ -602,7 +582,7 @@ async fn eval_command(
 
   // Save our fake file into file fetcher cache
   // to allow module access by TS compiler.
-  program_state.file_fetcher.insert_cached(file);
+  ps.file_fetcher.insert_cached(file);
   debug!("main_module {}", &main_module);
   worker.execute_main_module(&main_module).await?;
   worker.execute_script(
@@ -619,11 +599,11 @@ async fn eval_command(
 
 async fn create_module_graph_and_maybe_check(
   module_specifier: ModuleSpecifier,
-  program_state: Arc<ProgramState>,
+  ps: ProcState,
   debug: bool,
 ) -> Result<module_graph::Graph, AnyError> {
   let handler = Arc::new(Mutex::new(FetchHandler::new(
-    &program_state,
+    &ps,
     // when bundling, dynamic imports are only access for their type safety,
     // therefore we will allow the graph to access any module.
     Permissions::allow_all(),
@@ -631,18 +611,16 @@ async fn create_module_graph_and_maybe_check(
   )?));
   let mut builder = module_graph::GraphBuilder::new(
     handler,
-    program_state.maybe_import_map.clone(),
-    program_state.lockfile.clone(),
+    ps.maybe_import_map.clone(),
+    ps.lockfile.clone(),
   );
   builder.add(&module_specifier, false).await?;
-  builder
-    .analyze_config_file(&program_state.maybe_config_file)
-    .await?;
+  builder.analyze_config_file(&ps.maybe_config_file).await?;
   let module_graph = builder.get_graph();
 
-  if !program_state.flags.no_check {
+  if !ps.flags.no_check {
     // TODO(@kitsonk) support bundling for workers
-    let lib = if program_state.flags.unstable {
+    let lib = if ps.flags.unstable {
       module_graph::TypeLib::UnstableDenoWindow
     } else {
       module_graph::TypeLib::DenoWindow
@@ -652,8 +630,8 @@ async fn create_module_graph_and_maybe_check(
         debug,
         emit: false,
         lib,
-        maybe_config_file: program_state.maybe_config_file.clone(),
-        reload: program_state.flags.reload,
+        maybe_config_file: ps.maybe_config_file.clone(),
+        reload: ps.flags.reload,
         ..Default::default()
       })?;
 
@@ -671,14 +649,14 @@ async fn create_module_graph_and_maybe_check(
 
 fn bundle_module_graph(
   module_graph: module_graph::Graph,
-  program_state: Arc<ProgramState>,
+  ps: ProcState,
   flags: Flags,
   debug: bool,
 ) -> Result<String, AnyError> {
   let (bundle, stats, maybe_ignored_options) =
     module_graph.bundle(module_graph::BundleOptions {
       debug,
-      maybe_config_file: program_state.maybe_config_file.clone(),
+      maybe_config_file: ps.maybe_config_file.clone(),
     })?;
   match maybe_ignored_options {
     Some(ignored_options) if flags.no_check => {
@@ -704,11 +682,11 @@ async fn bundle_command(
       let module_specifier = resolve_url_or_path(&source_file1)?;
 
       debug!(">>>>> bundle START");
-      let program_state = ProgramState::build(flags.clone()).await?;
+      let ps = ProcState::build(flags.clone()).await?;
 
       let module_graph = create_module_graph_and_maybe_check(
         module_specifier,
-        program_state.clone(),
+        ps.clone(),
         debug,
       )
       .await?;
@@ -719,20 +697,18 @@ async fn bundle_command(
         .filter_map(|specifier| specifier.to_file_path().ok())
         .collect();
 
-      if let Some(import_map) = program_state.flags.import_map_path.as_ref() {
+      if let Some(import_map) = ps.flags.import_map_path.as_ref() {
         paths_to_watch
           .push(fs_util::resolve_from_cwd(std::path::Path::new(import_map))?);
       }
 
-      Ok((paths_to_watch, module_graph, program_state))
+      Ok((paths_to_watch, module_graph, ps))
     }
     .map(move |result| match result {
-      Ok((paths_to_watch, module_graph, program_state)) => {
-        ResolutionResult::Restart {
-          paths_to_watch,
-          result: Ok((program_state, module_graph)),
-        }
-      }
+      Ok((paths_to_watch, module_graph, ps)) => ResolutionResult::Restart {
+        paths_to_watch,
+        result: Ok((ps, module_graph)),
+      },
       Err(e) => ResolutionResult::Restart {
         paths_to_watch: vec![PathBuf::from(source_file2)],
         result: Err(e),
@@ -740,17 +716,13 @@ async fn bundle_command(
     })
   };
 
-  let operation = |(program_state, module_graph): (
-    Arc<ProgramState>,
-    module_graph::Graph,
-  )| {
+  let operation = |(ps, module_graph): (ProcState, module_graph::Graph)| {
     let flags = flags.clone();
     let out_file = bundle_flags.out_file.clone();
     async move {
       info!("{} {}", colors::green("Bundle"), module_graph.info()?.root);
 
-      let output =
-        bundle_module_graph(module_graph, program_state, flags, debug)?;
+      let output = bundle_module_graph(module_graph, ps, flags, debug)?;
 
       debug!(">>>>> bundle END");
 
@@ -805,13 +777,12 @@ async fn format_command(
   flags: Flags,
   fmt_flags: FmtFlags,
 ) -> Result<(), AnyError> {
-  let program_state = ProgramState::build(flags.clone()).await?;
-  let maybe_fmt_config =
-    if let Some(config_file) = &program_state.maybe_config_file {
-      config_file.to_fmt_config()?
-    } else {
-      None
-    };
+  let ps = ProcState::build(flags.clone()).await?;
+  let maybe_fmt_config = if let Some(config_file) = &ps.maybe_config_file {
+    config_file.to_fmt_config()?
+  } else {
+    None
+  };
 
   if fmt_flags.files.len() == 1 && fmt_flags.files[0].to_string_lossy() == "-" {
     return tools::fmt::format_stdin(
@@ -827,24 +798,20 @@ async fn format_command(
 async fn run_repl(flags: Flags, repl_flags: ReplFlags) -> Result<(), AnyError> {
   let main_module = resolve_url_or_path("./$deno$repl.ts").unwrap();
   let permissions = Permissions::from_options(&flags.clone().into());
-  let program_state = ProgramState::build(flags).await?;
+  let ps = ProcState::build(flags).await?;
   let mut worker =
-    create_main_worker(&program_state, main_module.clone(), permissions, None);
+    create_main_worker(&ps, main_module.clone(), permissions, None);
   worker.run_event_loop(false).await?;
 
-  tools::repl::run(&program_state, worker, repl_flags.eval).await
+  tools::repl::run(&ps, worker, repl_flags.eval).await
 }
 
 async fn run_from_stdin(flags: Flags) -> Result<(), AnyError> {
-  let program_state = ProgramState::build(flags.clone()).await?;
+  let ps = ProcState::build(flags.clone()).await?;
   let permissions = Permissions::from_options(&flags.clone().into());
   let main_module = resolve_url_or_path("./$deno$stdin.ts").unwrap();
-  let mut worker = create_main_worker(
-    &program_state.clone(),
-    main_module.clone(),
-    permissions,
-    None,
-  );
+  let mut worker =
+    create_main_worker(&ps.clone(), main_module.clone(), permissions, None);
 
   let mut source = Vec::new();
   std::io::stdin().read_to_end(&mut source)?;
@@ -859,7 +826,7 @@ async fn run_from_stdin(flags: Flags) -> Result<(), AnyError> {
   };
   // Save our fake file into file fetcher cache
   // to allow module access by TS compiler
-  program_state.file_fetcher.insert_cached(source_file);
+  ps.file_fetcher.insert_cached(source_file);
 
   debug!("main_module {}", main_module);
   worker.execute_main_module(&main_module).await?;
@@ -882,21 +849,19 @@ async fn run_with_watch(flags: Flags, script: String) -> Result<(), AnyError> {
     let flags = flags.clone();
     async move {
       let main_module = resolve_url_or_path(&script1)?;
-      let program_state = ProgramState::build(flags).await?;
+      let ps = ProcState::build(flags).await?;
       let handler = Arc::new(Mutex::new(FetchHandler::new(
-        &program_state,
+        &ps,
         Permissions::allow_all(),
         Permissions::allow_all(),
       )?));
       let mut builder = module_graph::GraphBuilder::new(
         handler,
-        program_state.maybe_import_map.clone(),
-        program_state.lockfile.clone(),
+        ps.maybe_import_map.clone(),
+        ps.lockfile.clone(),
       );
       builder.add(&main_module, false).await?;
-      builder
-        .analyze_config_file(&program_state.maybe_config_file)
-        .await?;
+      builder.analyze_config_file(&ps.maybe_config_file).await?;
       let module_graph = builder.get_graph();
 
       // Find all local files in graph
@@ -906,20 +871,18 @@ async fn run_with_watch(flags: Flags, script: String) -> Result<(), AnyError> {
         .filter_map(|specifier| specifier.to_file_path().ok())
         .collect();
 
-      if let Some(import_map) = program_state.flags.import_map_path.as_ref() {
+      if let Some(import_map) = ps.flags.import_map_path.as_ref() {
         paths_to_watch
           .push(fs_util::resolve_from_cwd(std::path::Path::new(import_map))?);
       }
 
-      Ok((paths_to_watch, main_module, program_state))
+      Ok((paths_to_watch, main_module, ps))
     }
     .map(move |result| match result {
-      Ok((paths_to_watch, module_info, program_state)) => {
-        ResolutionResult::Restart {
-          paths_to_watch,
-          result: Ok((program_state, module_info)),
-        }
-      }
+      Ok((paths_to_watch, module_info, ps)) => ResolutionResult::Restart {
+        paths_to_watch,
+        result: Ok((ps, module_info)),
+      },
       Err(e) => ResolutionResult::Restart {
         paths_to_watch: vec![PathBuf::from(script2)],
         result: Err(e),
@@ -986,25 +949,24 @@ async fn run_with_watch(flags: Flags, script: String) -> Result<(), AnyError> {
     }
   }
 
-  let operation =
-    |(program_state, main_module): (Arc<ProgramState>, ModuleSpecifier)| {
-      let flags = flags.clone();
-      let permissions = Permissions::from_options(&flags.into());
-      async move {
-        // We make use an module executor guard to ensure that unload is always fired when an
-        // operation is called.
-        let mut executor = FileWatcherModuleExecutor::new(create_main_worker(
-          &program_state,
-          main_module.clone(),
-          permissions,
-          None,
-        ));
-
-        executor.execute(&main_module).await?;
-
-        Ok(())
-      }
-    };
+  let operation = |(ps, main_module): (ProcState, ModuleSpecifier)| {
+    let flags = flags.clone();
+    let permissions = Permissions::from_options(&flags.into());
+    async move {
+      // We make use an module executor guard to ensure that unload is always fired when an
+      // operation is called.
+      let mut executor = FileWatcherModuleExecutor::new(create_main_worker(
+        &ps,
+        main_module.clone(),
+        permissions,
+        None,
+      ));
+
+      executor.execute(&main_module).await?;
+
+      Ok(())
+    }
+  };
 
   file_watcher::watch_func(resolver, operation, "Process").await
 }
@@ -1023,13 +985,13 @@ async fn run_command(
   }
 
   let main_module = resolve_url_or_path(&run_flags.script)?;
-  let program_state = ProgramState::build(flags.clone()).await?;
+  let ps = ProcState::build(flags.clone()).await?;
   let permissions = Permissions::from_options(&flags.clone().into());
   let mut worker =
-    create_main_worker(&program_state, main_module.clone(), permissions, None);
+    create_main_worker(&ps, main_module.clone(), permissions, None);
 
   let mut maybe_coverage_collector =
-    if let Some(ref coverage_dir) = program_state.coverage_dir {
+    if let Some(ref coverage_dir) = ps.coverage_dir {
       let session = worker.create_inspector_session().await;
 
       let coverage_dir = PathBuf::from(coverage_dir);