fix(watch): preserve ProcState::file_fetcher between restarts

cli/cache/mod.rs

@@ -50,12 +50,10 @@ pub struct FetchCacher {
 impl FetchCacher {
   pub fn new(
     emit_cache: EmitCache,
-    file_fetcher: FileFetcher,
+    file_fetcher: Arc<FileFetcher>,
     root_permissions: Permissions,
     dynamic_permissions: Permissions,
   ) -> Self {
-    let file_fetcher = Arc::new(file_fetcher);
-
     Self {
       emit_cache,
       dynamic_permissions,

cli/cache/node.rs

@@ -24,6 +24,7 @@ struct CjsAnalysisData {
   pub reexports: Vec<String>,
 }
 
+#[derive(Clone)]
 pub struct NodeAnalysisCache {
   db_file_path: Option<PathBuf>,
   inner: Arc<Mutex<Option<Option<NodeAnalysisCacheInner>>>>,

cli/cache/parsed_source.rs

@@ -65,6 +65,14 @@ impl ParsedSourceCache {
     }
   }
 
+  pub fn reset_for_file_watcher(&self) -> Self {
+    Self {
+      db_cache_path: self.db_cache_path.clone(),
+      cli_version: self.cli_version.clone(),
+      sources: Default::default(),
+    }
+  }
+
   pub fn get_parsed_source_from_module(
     &self,
     module: &deno_graph::Module,

cli/graph_util.rs

@@ -72,7 +72,7 @@ pub struct GraphData {
 
 impl GraphData {
   /// Store data from `graph` into `self`.
-  pub fn add_graph(&mut self, graph: &ModuleGraph, reload: bool) {
+  pub fn add_graph(&mut self, graph: &ModuleGraph) {
     for graph_import in &graph.imports {
       for dep in graph_import.dependencies.values() {
         for resolved in [&dep.maybe_code, &dep.maybe_type] {
@@ -96,7 +96,7 @@ impl GraphData {
         continue;
       }
 
-      if !reload && self.modules.contains_key(specifier) {
+      if self.modules.contains_key(specifier) {
         continue;
       }
 
@@ -470,7 +470,7 @@ impl GraphData {
 impl From<&ModuleGraph> for GraphData {
   fn from(graph: &ModuleGraph) -> Self {
     let mut graph_data = GraphData::default();
-    graph_data.add_graph(graph, false);
+    graph_data.add_graph(graph);
     graph_data
   }
 }
@@ -542,7 +542,7 @@ pub async fn create_graph_and_maybe_check(
 
   let check_js = ps.options.check_js();
   let mut graph_data = GraphData::default();
-  graph_data.add_graph(&graph, false);
+  graph_data.add_graph(&graph);
   graph_data
     .check(
       &graph.roots,

cli/module_loader.rs

@@ -252,7 +252,6 @@ impl ModuleLoader for CliModuleLoader {
         lib,
         root_permissions,
         dynamic_permissions,
-        false,
       )
       .await
     }

cli/proc_state.rs

@@ -77,7 +77,7 @@ pub struct ProcState(Arc<Inner>);
 
 pub struct Inner {
   pub dir: DenoDir,
-  pub file_fetcher: FileFetcher,
+  pub file_fetcher: Arc<FileFetcher>,
   pub http_client: HttpClient,
   pub options: Arc<CliOptions>,
   pub emit_cache: EmitCache,
@@ -147,6 +147,38 @@ impl ProcState {
     Ok(ps)
   }
 
+  /// Return a cloned `self` with all runtime state reset to its default. This
+  /// should be used on file watcher restarts.
+  pub fn reset_for_file_watcher(&self) -> Self {
+    ProcState(Arc::new(Inner {
+      dir: self.dir.clone(),
+      options: self.options.clone(),
+      emit_cache: self.emit_cache.clone(),
+      emit_options_hash: self.emit_options_hash,
+      emit_options: self.emit_options.clone(),
+      file_fetcher: self.file_fetcher.clone(),
+      http_client: self.http_client.clone(),
+      graph_data: Default::default(),
+      lockfile: self.lockfile.clone(),
+      maybe_import_map: self.maybe_import_map.clone(),
+      maybe_inspector_server: self.maybe_inspector_server.clone(),
+      root_cert_store: self.root_cert_store.clone(),
+      blob_store: Default::default(),
+      broadcast_channel: Default::default(),
+      shared_array_buffer_store: Default::default(),
+      compiled_wasm_module_store: Default::default(),
+      parsed_source_cache: self.parsed_source_cache.reset_for_file_watcher(),
+      maybe_resolver: self.maybe_resolver.clone(),
+      maybe_file_watcher_reporter: self.maybe_file_watcher_reporter.clone(),
+      node_analysis_cache: self.node_analysis_cache.clone(),
+      npm_cache: self.npm_cache.clone(),
+      npm_resolver: self.npm_resolver.clone(),
+      cjs_resolutions: Default::default(),
+      progress_bar: self.progress_bar.clone(),
+      node_std_graph_prepared: AtomicBool::new(false),
+    }))
+  }
+
   async fn build_with_sender(
     cli_options: Arc<CliOptions>,
     maybe_sender: Option<tokio::sync::mpsc::UnboundedSender<Vec<PathBuf>>>,
@@ -256,7 +288,7 @@ impl ProcState {
         .write_hashable(&emit_options)
         .finish(),
       emit_options,
-      file_fetcher,
+      file_fetcher: Arc::new(file_fetcher),
       http_client,
       graph_data: Default::default(),
       lockfile,
@@ -291,7 +323,6 @@ impl ProcState {
     lib: TsTypeLib,
     root_permissions: Permissions,
     dynamic_permissions: Permissions,
-    reload_on_watch: bool,
   ) -> Result<(), AnyError> {
     log::debug!("Preparing module load.");
     let _pb_clear_guard = self.progress_bar.clear_guard();
@@ -304,7 +335,7 @@ impl ProcState {
       .map(|s| (s, ModuleKind::Esm))
       .collect::<Vec<_>>();
 
-    if !reload_on_watch && !has_root_npm_specifier {
+    if !has_root_npm_specifier {
       let graph_data = self.graph_data.read();
       if self.options.type_check_mode() == TypeCheckMode::None
         || graph_data.is_type_checked(&roots, &lib)
@@ -338,7 +369,6 @@ impl ProcState {
     struct ProcStateLoader<'a> {
       inner: &'a mut cache::FetchCacher,
       graph_data: Arc<RwLock<GraphData>>,
-      reload: bool,
     }
     impl Loader for ProcStateLoader<'_> {
       fn get_cache_info(
@@ -355,17 +385,14 @@ impl ProcState {
         let graph_data = self.graph_data.read();
         let found_specifier = graph_data.follow_redirect(specifier);
         match graph_data.get(&found_specifier) {
-          Some(_) if !self.reload => {
-            Box::pin(futures::future::ready(Err(anyhow!(""))))
-          }
+          Some(_) => Box::pin(futures::future::ready(Err(anyhow!("")))),
           _ => self.inner.load(specifier, is_dynamic),
         }
       }
     }
     let mut loader = ProcStateLoader {
       inner: &mut cache,
       graph_data: self.graph_data.clone(),
-      reload: reload_on_watch,
     };
 
     let maybe_file_watcher_reporter: Option<&dyn deno_graph::source::Reporter> =
@@ -404,7 +431,7 @@ impl ProcState {
 
     let npm_package_reqs = {
       let mut graph_data = self.graph_data.write();
-      graph_data.add_graph(&graph, reload_on_watch);
+      graph_data.add_graph(&graph);
       let check_js = self.options.check_js();
       graph_data
         .check(
@@ -492,7 +519,6 @@ impl ProcState {
         lib,
         Permissions::allow_all(),
         Permissions::allow_all(),
-        false,
       )
       .await
   }
@@ -506,7 +532,7 @@ impl ProcState {
     let node_std_graph = self
       .create_graph(vec![(node::MODULE_ALL_URL.clone(), ModuleKind::Esm)])
       .await?;
-    self.graph_data.write().add_graph(&node_std_graph, false);
+    self.graph_data.write().add_graph(&node_std_graph);
     self.node_std_graph_prepared.store(true, Ordering::Relaxed);
     Ok(())
   }
@@ -743,7 +769,7 @@ pub fn import_map_from_text(
   Ok(result.import_map)
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 struct FileWatcherReporter {
   sender: tokio::sync::mpsc::UnboundedSender<Vec<PathBuf>>,
   file_paths: Arc<Mutex<Vec<PathBuf>>>,

cli/tests/watcher_tests.rs

@@ -1088,6 +1088,44 @@ mod watcher {
     check_alive_then_kill(child);
   }
 
+  // Regression test for https://github.com/denoland/deno/issues/15465.
+  #[test]
+  fn run_watch_reload_once() {
+    let _g = util::http_server();
+    let t = TempDir::new();
+    let file_to_watch = t.path().join("file_to_watch.js");
+    let file_content = r#"
+      import { time } from "http://localhost:4545/dynamic_module.ts";
+      console.log(time);
+    "#;
+    write(&file_to_watch, file_content).unwrap();
+
+    let mut child = util::deno_cmd()
+      .current_dir(util::testdata_path())
+      .arg("run")
+      .arg("--watch")
+      .arg("--reload")
+      .arg(&file_to_watch)
+      .env("NO_COLOR", "1")
+      .stdout(std::process::Stdio::piped())
+      .stderr(std::process::Stdio::piped())
+      .spawn()
+      .unwrap();
+    let (mut stdout_lines, mut stderr_lines) = child_lines(&mut child);
+
+    wait_contains("finished", &mut stderr_lines);
+    let first_output = stdout_lines.next().unwrap();
+
+    write(&file_to_watch, file_content).unwrap();
+    // The remote dynamic module should not have been reloaded again.
+
+    wait_contains("finished", &mut stderr_lines);
+    let second_output = stdout_lines.next().unwrap();
+    assert_eq!(second_output, first_output);
+
+    check_alive_then_kill(child);
+  }
+
   #[test]
   fn run_watch_dynamic_imports() {
     let t = TempDir::new();
@@ -1149,11 +1187,11 @@ mod watcher {
       &mut stdout_lines,
     );
 
-    wait_contains("finished", &mut stderr_lines);
     wait_for(
       |m| m.contains("Watching paths") && m.contains("imported2.js"),
       &mut stderr_lines,
     );
+    wait_contains("finished", &mut stderr_lines);
 
     write(
     &file_to_watch3,

cli/tools/bench.rs

@@ -339,7 +339,6 @@ async fn check_specifiers(
     lib,
     Permissions::allow_all(),
     permissions,
-    true,
   )
   .await?;
 
@@ -661,7 +660,7 @@ pub async fn run_benchmarks_with_watch(
     let include = selection.include.clone();
     let ignore = selection.ignore.clone();
     let permissions = permissions.clone();
-    let ps = ps.clone();
+    let ps = ps.reset_for_file_watcher();
 
     async move {
       let specifiers =

cli/tools/run.rs

@@ -1,7 +1,6 @@
 // Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
 
 use std::io::Read;
-use std::path::PathBuf;
 use std::sync::Arc;
 
 use deno_ast::MediaType;
@@ -100,16 +99,12 @@ async fn run_with_watch(flags: Flags, script: String) -> Result<i32, AnyError> {
   let flags = Arc::new(flags);
   let main_module = resolve_url_or_path(&script)?;
   let (sender, receiver) = tokio::sync::mpsc::unbounded_channel();
+  let ps =
+    ProcState::build_for_file_watcher((*flags).clone(), sender.clone()).await?;
 
-  let operation = |(sender, main_module): (
-    tokio::sync::mpsc::UnboundedSender<Vec<PathBuf>>,
-    ModuleSpecifier,
-  )| {
-    let flags = flags.clone();
+  let operation = |main_module: ModuleSpecifier| {
+    let ps = ps.reset_for_file_watcher();
     Ok(async move {
-      let ps =
-        ProcState::build_for_file_watcher((*flags).clone(), sender.clone())
-          .await?;
       let permissions =
         Permissions::from_options(&ps.options.permissions_options())?;
       let worker =
@@ -123,7 +118,7 @@ async fn run_with_watch(flags: Flags, script: String) -> Result<i32, AnyError> {
   util::file_watcher::watch_func2(
     receiver,
     operation,
-    (sender, main_module),
+    main_module,
     util::file_watcher::PrintConfig {
       job_name: "Process".to_string(),
       clear_screen: !flags.no_clear_screen,

cli/tools/test.rs

@@ -959,7 +959,6 @@ pub async fn check_specifiers(
       lib,
       Permissions::allow_all(),
       permissions.clone(),
-      false,
     )
     .await?;
   }
@@ -981,7 +980,6 @@ pub async fn check_specifiers(
     lib,
     Permissions::allow_all(),
     permissions,
-    true,
   )
   .await?;
 
@@ -1519,7 +1517,7 @@ pub async fn run_tests_with_watch(
     let include = include.clone();
     let ignore = ignore.clone();
     let permissions = permissions.clone();
-    let ps = ps.clone();
+    let ps = ps.reset_for_file_watcher();
 
     async move {
       let specifiers_with_mode = fetch_specifiers_with_test_mode(

cli/util/file_watcher.rs

@@ -314,13 +314,13 @@ where
         continue;
       },
       _ = operation_future => {
+        consume_paths_to_watch(&mut watcher, &mut paths_to_watch_receiver);
         // TODO(bartlomieju): print exit code here?
         info!(
           "{} {} finished. Restarting on file change...",
           colors::intense_blue("Watcher"),
           job_name,
         );
-        consume_paths_to_watch(&mut watcher, &mut paths_to_watch_receiver);
       },
     };
 

test_util/src/lib.rs

@@ -971,6 +971,17 @@ async fn main_server(
       );
       Ok(res)
     }
+    (_, "/dynamic_module.ts") => {
+      let mut res = Response::new(Body::from(format!(
+        r#"export const time = {};"#,
+        std::time::SystemTime::now().elapsed().unwrap().as_nanos()
+      )));
+      res.headers_mut().insert(
+        "Content-type",
+        HeaderValue::from_static("application/typescript"),
+      );
+      Ok(res)
+    }
     (_, "/echo_accept") => {
       let accept = req.headers().get("accept").map(|v| v.to_str().unwrap());
       let res = Response::new(Body::from(