Upstream debugger changes from python-ui branch

Author: simonrw

debugger/src/debugger.rs

@@ -4,7 +4,6 @@ use std::{
 };
 
 use anyhow::Context;
-use spmc::Receiver;
 use transport::{
     requests::{self, Disconnect, Initialize, PathFormat},
     Client,
@@ -18,30 +17,44 @@ use crate::{
 
 pub struct Debugger {
     internals: Arc<Mutex<DebuggerInternals>>,
+    rx: spmc::Receiver<Event>,
 }
 
 impl Debugger {
-    #[tracing::instrument(skip(client, events, publisher))]
+    #[tracing::instrument(skip(client, events))]
     pub fn new(
         client: Client,
-        events: Receiver<transport::events::Event>,
-        mut publisher: spmc::Sender<Event>,
+        events: spmc::Receiver<transport::events::Event>,
     ) -> anyhow::Result<Self> {
         tracing::debug!("creating new client");
 
-        let _ = publisher.send(Event::Uninitialised);
+        let (mut tx, rx) = spmc::channel();
+        let _ = tx.send(Event::Uninitialised);
 
-        let internals = Arc::new(Mutex::new(DebuggerInternals::new(client, publisher)));
+        let internals_rx = rx.clone();
+        let internals = Arc::new(Mutex::new(DebuggerInternals::new(client, tx)));
 
         // background thread reading transport events, and handling the event with our internal state
         let background_internals = Arc::clone(&internals);
+        let background_events = events.clone();
         thread::spawn(move || loop {
-            let event = events.recv().unwrap();
+            let event = background_events.recv().unwrap();
             background_internals.lock().unwrap().on_event(event);
         });
-        Ok(Self { internals })
+        Ok(Self {
+            internals,
+            rx: internals_rx,
+        })
     }
 
+    pub fn events(&self) -> spmc::Receiver<Event> {
+        self.rx.clone()
+    }
+
+    // fn emit(&self, event: Event) {
+    //     self.internals.lock().unwrap().emit(event)
+    // }
+
     pub fn initialise(&self, launch_arguments: state::LaunchArguments) -> anyhow::Result<()> {
         // initialise
         let req = requests::RequestBody::Initialize(Initialize {
@@ -110,6 +123,27 @@ impl Debugger {
     fn execute(&self, body: requests::RequestBody) -> anyhow::Result<()> {
         self.internals.lock().unwrap().client.execute(body)
     }
+
+    pub fn wait_for_event<F>(&self, pred: F) -> Event
+    where
+        F: Fn(&Event) -> bool,
+    {
+        let mut n = 0;
+        loop {
+            let evt = self.rx.recv().unwrap();
+            if n >= 100 {
+                panic!("did not receive event");
+            }
+
+            if pred(&evt) {
+                tracing::debug!(event = ?evt, "received expected event");
+                return evt;
+            } else {
+                tracing::trace!(event = ?evt, "non-matching event");
+            }
+            n += 1;
+        }
+    }
 }
 
 impl Drop for Debugger {

debugger/src/internals.rs

@@ -19,7 +19,6 @@ pub struct FileSource {
 }
 
 pub(crate) struct DebuggerInternals {
-    pub(crate) _state: DebuggerState,
     pub(crate) client: Client,
     pub(crate) publisher: spmc::Sender<Event>,
 
@@ -36,6 +35,10 @@ impl DebuggerInternals {
         Self::with_breakpoints(client, publisher, HashMap::new())
     }
 
+    pub(crate) fn emit(&mut self, event: Event) {
+        let _ = self.publisher.send(event);
+    }
+
     pub(crate) fn with_breakpoints(
         client: Client,
         publisher: spmc::Sender<Event>,
@@ -45,7 +48,6 @@ impl DebuggerInternals {
         let current_breakpoint_id = *breakpoints.keys().max().unwrap_or(&0);
 
         Self {
-            _state: DebuggerState::Running,
             client,
             publisher,
             current_thread_id: None,
@@ -203,6 +205,6 @@ impl DebuggerInternals {
 
     pub(crate) fn set_state(&mut self, new_state: DebuggerState) {
         let event = Event::from(&new_state);
-        let _ = self.publisher.send(event);
+        self.emit(event);
     }
 }

debugger/tests/debugger.rs

@@ -26,9 +26,8 @@ fn test_debugger() -> anyhow::Result<()> {
             TcpStream::connect(format!("127.0.0.1:{port}")).context("connecting to server")?;
         let client = transport::Client::new(stream, tx).context("creating transport client")?;
 
-        let (dtx, drx) = spmc::channel();
-
-        let debugger = Debugger::new(client, rx, dtx).context("creating debugger")?;
+        let debugger = Debugger::new(client, rx).context("creating debugger")?;
+        let drx = debugger.events();
 
         let file_path = std::env::current_dir()
             .unwrap()