Fix edge cases for breakpoints, add continue

Author: dzfranklin

samples/hello_world/src/main.rs

@@ -6,10 +6,16 @@ struct HelloMsg {
     msg: String,
 }
 
+impl HelloMsg {
+    fn say(&self) {
+        println!("{}", self.msg);
+    }
+}
+
 fn main() {
     let msg = HelloMsg {
         msg: "Hello world!".into(),
     };
     thread::sleep(Duration::from_secs(1));
-    println!("{}", msg.msg);
+    msg.say();
 }

src/breakpoint.rs

@@ -40,24 +40,51 @@ impl LineSpec {
     }
 }
 
+// TODO: This doesn't include all the potential outputs of gdb.
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct Breakpoint {
     pub number: u32,
-    pub addr: u64,
-    pub file: Utf8PathBuf,
-    pub line: u32,
+    pub addr: BreakpointAddr,
+    pub file: Option<Utf8PathBuf>,
+    pub line: Option<u32>,
     pub thread_groups: Vec<String>,
     pub times: u32,
 }
 
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum BreakpointAddr {
+    Addr(u64),
+    Pending,
+    Multiple,
+    Unknown,
+}
+
 impl Breakpoint {
     pub fn from_raw(mut raw: raw::Dict) -> Result<Self, Error> {
         let number = raw.remove_expect("number")?.expect_number()?;
-        let addr = raw.remove_expect("addr")?.expect_hex()?;
-        let file = raw.remove_expect("fullname")?.expect_path()?;
-        let line = raw.remove_expect("line")?.expect_number()?;
         let times = raw.remove_expect("times")?.expect_number()?;
 
+        let line = raw
+            .remove("line")
+            .map(raw::Value::expect_number)
+            .transpose()?;
+
+        let file = raw
+            .remove("fullname")
+            .map(raw::Value::expect_path)
+            .transpose()?;
+
+        let addr = if let Some(addr) = raw.as_map_mut().remove("addr") {
+            let addr = addr.expect_string()?;
+            match addr.as_str() {
+                "<PENDING>" => BreakpointAddr::Pending,
+                "<MULTIPLE>" => BreakpointAddr::Multiple,
+                addr => BreakpointAddr::Addr(raw::parse_hex(addr)?),
+            }
+        } else {
+            BreakpointAddr::Unknown
+        };
+
         let thread_groups = raw
             .remove_expect("thread-groups")?
             .expect_list()?

src/lib.rs

@@ -49,10 +49,10 @@ pub enum Error {
 }
 
 #[derive(Debug, Clone, thiserror::Error, displaydoc::Display, Eq, PartialEq)]
-/// Received error {code} from gdb: {msg}
+/// Received error from gdb. Code: {code:?}, msg: {msg:?}
 pub struct GdbError {
-    code: String,
-    msg: String,
+    code: Option<String>,
+    msg: Option<String>,
 }
 
 #[derive(Debug, Clone, thiserror::Error, Eq, PartialEq)]
@@ -104,13 +104,27 @@ impl Gdb {
         Ok(Self { inner, timeout })
     }
 
-    pub async fn run(&self) -> Result<(), Error> {
+    pub async fn exec_run(&self) -> Result<(), Error> {
         self.execute_raw("-exec-run")
             .await?
             .expect_result()?
             .expect_msg_is("running")
     }
 
+    pub async fn exec_continue(&self) -> Result<(), Error> {
+        self.execute_raw("-exec-continue")
+            .await?
+            .expect_result()?
+            .expect_msg_is("running")
+    }
+
+    pub async fn exec_continue_reverse(&self) -> Result<(), Error> {
+        self.execute_raw("-exec-continue --reverse")
+            .await?
+            .expect_result()?
+            .expect_msg_is("running")
+    }
+
     pub async fn break_insert(&self, at: LineSpec) -> Result<Breakpoint, Error> {
         let raw = self
             .execute_raw(format!("-break-insert {}", at.serialize()))
@@ -190,6 +204,7 @@ impl fmt::Debug for Gdb {
     }
 }
 
+// TODO: Move to inner
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
 pub struct Token(pub u32);
 
@@ -209,6 +224,7 @@ mod tests {
 
     use super::*;
     use insta::assert_debug_snapshot;
+    use pretty_assertions::assert_eq;
     use test_common::{build_hello_world, init, Result, TIMEOUT};
 
     fn fixture() -> eyre::Result<Gdb> {
@@ -225,8 +241,12 @@ mod tests {
             .break_insert(LineSpec::line("samples/hello_world/src/main.rs", 13))
             .await?;
         assert_eq!(1, bp.number);
-        assert!(bp.file.ends_with("samples/hello_world/src/main.rs"));
-        assert_eq!(13, bp.line);
+        assert!(bp
+            .file
+            .as_ref()
+            .unwrap()
+            .ends_with("samples/hello_world/src/main.rs"));
+        assert_eq!(17, bp.line.unwrap());
         assert_eq!(0, bp.times);
 
         subject.break_disable(iter::once(&bp)).await?;
@@ -236,9 +256,29 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn test_run() -> Result {
+    async fn test_exec_continue() -> Result {
+        let subject = fixture()?;
+        subject.break_insert(LineSpec::function("main")).await?;
+        subject.exec_run().await?;
+        subject.exec_continue().await?;
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_exec_continue_not_running() -> Result {
+        let subject = fixture()?;
+        let error = match subject.exec_continue().await {
+            Err(Error::Gdb(error)) => error,
+            got => panic!("Expected Error::Gdb, got {:?}", got),
+        };
+        assert_eq!(error.msg.unwrap(), "The program is not being run.");
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_exec_run() -> Result {
         let subject = fixture()?;
-        subject.run().await?;
+        subject.exec_run().await?;
         Ok(())
     }
 
@@ -275,8 +315,8 @@ mod tests {
 
         assert_eq!(
             Error::Gdb(GdbError {
-                code: "undefined-command".into(),
-                msg: "Undefined MI command: invalid-command".into(),
+                code: Some("undefined-command".into()),
+                msg: Some("Undefined MI command: invalid-command".into()),
             }),
             err
         );

src/raw.rs

@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 
 use camino::Utf8PathBuf;
-use tracing::error;
+use tracing::{error, warn};
 
 use crate::{parser, Error, GdbError, ParseHexError};
 
@@ -89,8 +89,14 @@ impl Response {
             return Err(Error::ExpectedPayload);
         };
 
-        let code = payload.remove_expect("code")?.expect_string()?;
-        let msg = payload.remove_expect("msg")?.expect_string()?;
+        let code = payload
+            .remove("code")
+            .map(Value::expect_string)
+            .transpose()?;
+        let msg = payload
+            .remove("msg")
+            .map(Value::expect_string)
+            .transpose()?;
 
         Ok(GdbError { code, msg })
     }
@@ -126,10 +132,18 @@ impl Dict {
         &mut self.0
     }
 
-    pub fn remove_expect(&mut self, key: &str) -> std::result::Result<Value, Error> {
-        self.0
-            .remove(key)
-            .map_or(Err(Error::ExpectedDifferentPayload), Ok)
+    pub fn remove_expect(&mut self, key: &str) -> Result<Value, Error> {
+        self.0.remove(key).map_or_else(
+            || {
+                warn!("Expected key {} to be present in {:?}", key, self);
+                Err(Error::ExpectedDifferentPayload)
+            },
+            Ok,
+        )
+    }
+
+    pub fn remove(&mut self, key: &str) -> Option<Value> {
+        self.0.remove(key)
     }
 }
 
@@ -202,12 +216,15 @@ impl Value {
     }
 
     pub fn expect_hex(self) -> Result<u64, Error> {
-        let hex = self.expect_string()?;
-        if let Some(hex) = hex.strip_prefix("0x") {
-            let num = u64::from_str_radix(hex, 16)?;
-            Ok(num)
-        } else {
-            Err(ParseHexError::InvalidPrefix.into())
-        }
+        parse_hex(&self.expect_string()?)
+    }
+}
+
+pub fn parse_hex(s: &str) -> Result<u64, Error> {
+    if let Some(hex) = s.strip_prefix("0x") {
+        let num = u64::from_str_radix(hex, 16)?;
+        Ok(num)
+    } else {
+        Err(ParseHexError::InvalidPrefix.into())
     }
 }

src/snapshots/gdbmi__tests__symbol_info_function.snap

@@ -2418,7 +2418,13 @@ expression: symbols
     ],
     "src/main.rs": [
         Symbol {
-            line: 9,
+            line: 10,
+            name: "hello_world::HelloMsg::say",
+            symbol_type: "fn (*mut hello_world::HelloMsg)",
+            description: "static fn hello_world::HelloMsg::say(*mut hello_world::HelloMsg);",
+        },
+        Symbol {
+            line: 15,
             name: "hello_world::main",
             symbol_type: "fn ()",
             description: "static fn hello_world::main();",