CLI flag for disabling interrupts

src/cli.rs

@@ -49,6 +49,11 @@ pub struct Opts {
     /// Options to modify logging and error-handling behavior.
     #[command(flatten)]
     pub logging: LoggingOpts,
+
+    /// By default, ghciwatch will interrupt reloads if a file changes. If you want ghciwatch to
+    /// avoid interrupting reloads, set this flag.
+    #[arg(long = "no-interrupt-reloads")]
+    pub no_interrupt_reloads: bool,
 }
 
 /// Options for watching files.

src/ghci/manager.rs

@@ -56,6 +56,7 @@ pub async fn run_ghci(
     // This function is pretty tricky! We need to handle shutdowns at each stage, and the process
     // is a little different each time, so the `select!`s can't be consolidated.
 
+    let no_interrupt_reloads = opts.no_interrupt_reloads;
     let mut ghci = Ghci::new(handle.clone(), opts)
         .await
         .wrap_err("Failed to start `ghci`")?;
@@ -113,19 +114,21 @@ pub async fn run_ghci(
             }
             Some(new_event) = receiver.recv() => {
                 tracing::debug!(?new_event, "Received ghci event from watcher while reloading");
-                if should_interrupt(reload_receiver).await {
-                    // Merge the events together so we don't lose progress.
-                    // Then, the next iteration of the loop will pick up the `maybe_event` value
-                    // and respond immediately.
-                    event.merge(new_event);
-                    maybe_event = Some(event);
-
-                    // Cancel the in-progress reload. This releases the `ghci` lock to prevent a deadlock.
-                    task.abort();
-
-                    // Send a SIGINT to interrupt the reload.
-                    // NB: This may take a couple seconds to register.
-                    ghci.lock().await.send_sigint().await?;
+                if !no_interrupt_reloads {
+                    if should_interrupt(reload_receiver).await {
+                        // Merge the events together so we don't lose progress.
+                        // Then, the next iteration of the loop will pick up the `maybe_event` value
+                        // and respond immediately.
+                        event.merge(new_event);
+                        maybe_event = Some(event);
+
+                        // Cancel the in-progress reload. This releases the `ghci` lock to prevent a deadlock.
+                        task.abort();
+
+                        // Send a SIGINT to interrupt the reload.
+                        // NB: This may take a couple seconds to register.
+                        ghci.lock().await.send_sigint().await?;
+                    }
                 }
             }
             ret = &mut task => {

src/ghci/mod.rs

@@ -102,6 +102,8 @@ pub struct GhciOpts {
     pub restart_globs: GlobMatcher,
     /// Reload the `ghci` session when paths matching these globs are changed.
     pub reload_globs: GlobMatcher,
+    /// Determines whether we should interrupt a reload in progress or not.
+    pub no_interrupt_reloads: bool,
     /// Where to write what `ghci` emits to `stdout`. Inherits parent's `stdout` by default.
     pub stdout_writer: GhciWriter,
     /// Where to write what `ghci` emits to `stderr`. Inherits parent's `stderr` by default.
@@ -128,6 +130,7 @@ impl GhciOpts {
             hooks: opts.hooks.clone(),
             restart_globs: opts.watch.restart_globs()?,
             reload_globs: opts.watch.reload_globs()?,
+            no_interrupt_reloads: opts.no_interrupt_reloads,
             stdout_writer: GhciWriter::stdout(),
             stderr_writer: GhciWriter::stderr(),
         })