feat: start generalizing breakpoint/source line jump logic; not finished

also TODO: add rr logic for the new primitives

Author: alehander92

src/db-backend/src/dap.rs

@@ -400,7 +400,7 @@ pub fn read_dap_message_from_reader<R: std::io::BufRead>(reader: &mut R) -> DapR
         .read_exact(&mut buf)
         .map_err(|e| serde_json::Error::custom(e.to_string()))?;
     let json_text = std::str::from_utf8(&buf).map_err(|e| serde_json::Error::custom(e.to_string()))?;
-    info!("DAP raw <- {json_text}");
+    // info!("DAP raw <- {json_text}");
     from_json(json_text)
 }
 

src/db-backend/src/dap_server.rs

@@ -282,6 +282,10 @@ pub fn handle_message<T: DapTransport>(
     ctx: &mut Ctx,
 ) -> Result<(), Box<dyn Error>> {
     info!("Handling message: {:?}", msg);
+    if let DapMessage::Request(req) = msg {
+        info!("  request {}", req.command);
+    }
+
     match msg {
         DapMessage::Request(req) if req.command == "initialize" => {
             let capabilities = Capabilities {

src/db-backend/src/db.rs

@@ -15,7 +15,7 @@ use crate::distinct_vec::DistinctVec;
 use crate::expr_loader::ExprLoader;
 use crate::lang::Lang;
 use crate::replay::{Events, Replay};
-use crate::task::{Action, Call, CallArg, Location, ProgramEvent, RRTicks, NO_INDEX, NO_PATH, NO_POSITION, CtLoadLocalsArguments, Variable};
+use crate::task::{Action, Breakpoint, Call, CallArg, Location, ProgramEvent, RRTicks, NO_INDEX, NO_PATH, NO_POSITION, CtLoadLocalsArguments, Variable};
 use crate::value::{Type, Value};
 
 const NEXT_INTERNAL_STEP_OVERS_LIMIT: usize = 1_000;
@@ -777,24 +777,19 @@ pub enum EndOfProgram {
 //     pub place: Place,
 // }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct BreakpointRecord {
-    pub is_active: bool,
-}
-
 // type LineTraceMap = HashMap<usize, Vec<(usize, String)>>;
 
 #[derive(Debug)]
 pub struct DbReplay {
     pub db: Box<Db>,
     pub step_id: StepId,
     pub call_key: CallKey,
-    pub breakpoint_list: Vec<HashMap<usize, BreakpointRecord>>,
+    pub breakpoint_list: Vec<HashMap<usize, Breakpoint>>,
 }
 
 impl DbReplay {
     pub fn new(db: Box<Db>) -> DbReplay {
-        let mut breakpoint_list: Vec<HashMap<usize, BreakpointRecord>> = Default::default();
+        let mut breakpoint_list: Vec<HashMap<usize, Breakpoint>> = Default::default();
         breakpoint_list.resize_with(db.paths.len(), HashMap::new);
         DbReplay { db, step_id: StepId(0), call_key: CallKey(0), breakpoint_list }
     }
@@ -924,6 +919,10 @@ impl DbReplay {
         // false: hasn't hit a breakpoint
         Ok(false)
     }
+
+    fn load_path_id(&self, path: &str) -> Option<PathId> {
+        self.db.path_map.get(path).copied()
+    }
 }
 
 impl Replay for DbReplay {
@@ -1031,6 +1030,16 @@ impl Replay for DbReplay {
         Ok(true)
     }
 
+    fn add_breakpoint(&mut self, path: &str, line: i64) -> Result<Breakpoint, Box<dyn Error>> {
+        let path_id_res: Result<PathId, Box<dyn Error>> = self
+            .load_path_id(&loc.path)
+            .ok_or(format!("can't add a breakpoint: can't find path `{}`` in trace", loc.path).into());
+        let path_id = path_id_res?;
+        let inner_map = &mut self.breakpoint_list[path_id.0];
+        let breakpoint = Breakpoint { enabled: true, id: self.breakpoint_next_id };
+        self.breakpoint_next_i
+        inner_map.insert(loc.line, Breakpoint { is_active: true });
+    }
     fn current_step_id(&mut self) -> StepId {
         self.step_id
     }

src/db-backend/src/handler.rs

@@ -10,7 +10,7 @@ use runtime_tracing::{CallKey, EventLogKind, Line, PathId, StepId, VariableId, N
 
 use crate::calltrace::Calltrace;
 use crate::dap::{self, DapClient, DapMessage};
-use crate::db::{BreakpointRecord, Db, DbCall, DbRecordEvent, DbReplay, DbStep};
+use crate::db::{Db, DbCall, DbRecordEvent, DbReplay, DbStep};
 use crate::event_db::{EventDb, SingleTableId};
 use crate::expr_loader::ExprLoader;
 use crate::flow_preloader::FlowPreloader;
@@ -57,8 +57,6 @@ pub struct Handler {
     pub replay: Box<dyn Replay>,
     pub ct_rr_args: CtRRArgs,
     pub load_flow_index: usize,
-
-    pub breakpoint_list: Vec<HashMap<usize, BreakpointRecord>>,
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -94,8 +92,6 @@ impl Handler {
         let calltrace = Calltrace::new(&db);
         let trace = CoreTrace::default();
         let mut expr_loader = ExprLoader::new(trace.clone());
-        let mut breakpoint_list: Vec<HashMap<usize, BreakpointRecord>> = Default::default();
-        breakpoint_list.resize_with(db.paths.len(), HashMap::new);
         let step_lines_loader = StepLinesLoader::new(&db, &mut expr_loader);
         let replay: Box<dyn Replay> = if trace_kind == TraceKind::DB {
             Box::new(DbReplay::new(db.clone()))
@@ -110,7 +106,6 @@ impl Handler {
             last_call_key: CallKey(0),
             indirect_send,
             // sender,
-            breakpoint_list,
             event_db: EventDb::new(),
             flow_preloader: FlowPreloader::new(),
             expr_loader,
@@ -809,14 +804,31 @@ impl Handler {
         _req: dap::Request,
         source_location: SourceLocation,
     ) -> Result<(), Box<dyn Error>> {
-        if let Some(step_id) = self.get_closest_step_id(&source_location) {
-            self.replay.jump_to(step_id)?;
-            self.step_id = self.replay.current_step_id();
-            self.complete_move(false)?;
-            Ok(())
+        if self.trace_kind == TraceKind::DB {
+            if let Some(step_id) = self.get_closest_step_id(&source_location) {
+                self.replay.jump_to(step_id)?;
+                self.step_id = self.replay.current_step_id();
+                self.complete_move(false)?;
+                Ok(())
+            } else {
+                let err: String = format!("unknown location: {}", &source_location);
+                Err(err.into())
+            }
         } else {
-            let err: String = format!("unknown location: {}", &source_location);
-            Err(err.into())
+            let b = self.replay.add_breakpoint(&source_location.path, source_location.line as i64)?;
+            match self.replay.step(Action::Continue, true) {
+                Ok(_) => {
+                    self.replay.delete_breakpoint(&b)?; // make sure we do it before potential `?` fail in next functions
+                    let _location = self.replay.load_location(&mut self.expr_loader)?;
+                    self.step_id = self.replay.current_step_id();
+                    self.complete_move(false)?;
+                    Ok(())
+                }
+                Err(e) => {
+                    self.replay.delete_breakpoint(&b)?;
+                    Err(e)
+                }
+            }
         }
     }
 
@@ -882,13 +894,8 @@ impl Handler {
     }
 
     pub fn add_breakpoint(&mut self, loc: SourceLocation, _task: Task) -> Result<(), Box<dyn Error>> {
-        let path_id_res: Result<PathId, Box<dyn Error>> = self
-            .load_path_id(&loc.path)
-            .ok_or(format!("can't add a breakpoint: can't find path `{}`` in trace", loc.path).into());
-        let path_id = path_id_res?;
-        let inner_map = &mut self.breakpoint_list[path_id.0];
-        inner_map.insert(loc.line, BreakpointRecord { is_active: true });
-        Ok(())
+       self.replay.add_breakpoint(&loc.path, loc.line as i64)?;
+       Ok(())
     }
 
     pub fn delete_breakpoint(&mut self, loc: SourceLocation, _task: Task) -> Result<(), Box<dyn Error>> {

src/db-backend/src/replay.rs

@@ -3,7 +3,7 @@ use std::error::Error;
 
 use crate::db::DbRecordEvent;
 use crate::expr_loader::ExprLoader;
-use crate::task::{Action, Location, ProgramEvent, CtLoadLocalsArguments, Variable};
+use crate::task::{Action, Breakpoint, Location, ProgramEvent, CtLoadLocalsArguments, Variable};
 
 #[derive(Debug, Clone)]
 pub struct Events {
@@ -23,5 +23,7 @@ pub trait Replay: std::fmt::Debug {
     fn load_return_value(&mut self) -> Result<ValueRecord, Box<dyn Error>>;
     fn load_step_events(&mut self, step_id: StepId, exact: bool) -> Vec<DbRecordEvent>;
     fn jump_to(&mut self, step_id: StepId) -> Result<bool, Box<dyn Error>>;
+    fn add_breakpoint(&mut self, path: &str, line: i64) -> Result<Breakpoint, Box<dyn Error>>;
+    fn delete_breakpoint(&mut self, breakpoint: &Breakpoint) -> Result<bool, Box<dyn Error>>;
     fn current_step_id(&mut self) -> StepId;
 }

src/db-backend/src/task.rs

@@ -1640,6 +1640,10 @@ pub struct TracepointResults {
     pub first_update: bool,
 }
 
+pub struct Breakpoint {
+    pub id: i64,
+    pub enabled: bool,
+}
 pub static mut TASK_ID_MAP: &mut [usize] = &mut [0; 100];
 pub static mut EVENT_ID_MAP: &mut [usize] = &mut [0; 100];