feat: tried to abstract stepping/loading locals for db and rr

alehander92 · alehander92 · commit 03b5d7e8b92f · 2025-10-13T21:23:59.000+03:00
loading locals still TODO in rr; overally not very tested in db
diff --git a/src/db-backend/src/db.rs b/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::{Call, CallArg, Location, ProgramEvent, RRTicks, NO_INDEX, NO_PATH, NO_POSITION};
+use crate::task::{Action, 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;
@@ -773,15 +773,25 @@ 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 breakpoint_list: Vec<HashMap<usize, BreakpointRecord>>,
 }
 
 impl DbReplay {
     pub fn new(db: Box<Db>) -> DbReplay {
-        DbReplay { db, step_id: StepId(0) }
+        let mut breakpoint_list: Vec<HashMap<usize, BreakpointRecord>> = Default::default();
+        breakpoint_list.resize_with(db.paths.len(), HashMap::new);
+        DbReplay { db, step_id: StepId(0), breakpoint_list }
     }
 
     pub fn step_id_jump(&mut self, step_id: StepId) {
@@ -850,6 +860,65 @@ impl DbReplay {
             step_index
         }
     }
+
+    fn step_in(&mut self, forward: bool) -> Result<bool, Box<dyn Error>> {
+        self.step_id = StepId(self.single_step_line(self.step_id.0 as usize, forward) as i64);
+        Ok(true)
+    }
+
+    fn step_out(&mut self, forward: bool) -> Result<bool, Box<dyn Error>> {
+        (self.step_id, _) = self.db.step_out_step_id_relative_to(self.step_id, forward);
+        Ok(true)
+    }
+
+    fn next(&mut self, forward: bool) -> Result<bool, Box<dyn Error>> {
+        let step_to_different_line = true; // which is better/should be let the user configure it?
+        (self.step_id, _) = self
+            .db
+            .next_step_id_relative_to(self.step_id, forward, step_to_different_line);
+        Ok(true)
+    }
+
+    // returns if it has hit any breakpoints
+    fn step_continue(&mut self, forward: bool) -> Result<bool, Box<dyn Error>> {
+        for step in self.db.step_from(self.step_id, forward) {
+            if !self.breakpoint_list.is_empty() {
+                if let Some(is_active) = self.breakpoint_list[step.path_id.0]
+                    .get(&step.line.into())
+                    .map(|bp| bp.is_active)
+                {
+                    if is_active {
+                        self.step_id_jump(step.step_id);
+                        // true: has hit a breakpoint
+                        return Ok(true);
+                    }
+                }
+            } else {
+                break;
+            }
+        }
+
+        // If the continue step doesn't find a valid breakpoint.
+        if forward {
+            self.step_id_jump(
+                self.db
+                    .steps
+                    .last()
+                    .expect("unexpected 0 steps in trace for step_continue")
+                    .step_id,
+            );
+        } else {
+            self.step_id_jump(
+                self.db
+                    .steps
+                    .first()
+                    .expect("unexpected 0 steps in trace for step_continue")
+                    .step_id,
+            )
+        }
+        // false: hasn't hit a breakpoint
+        Ok(false)
+    }
 }
 
 impl Replay for DbReplay {
@@ -886,12 +955,50 @@ impl Replay for DbReplay {
         })
     }
 
-    fn step_in(&mut self, forward: bool) -> Result<(), Box<dyn Error>> {
-        self.step_id = StepId(self.single_step_line(self.step_id.0 as usize, forward) as i64);
-        Ok(())
+    // for Ok cases:
+    //   continue returns if it has hit any breakpoints, others return always true
+    fn step(&mut self, action: Action, forward: bool) -> Result<bool, Box<dyn Error>> {
+        match action {
+            Action::StepIn => self.step_in(forward),
+            Action::StepOut => self.step_out(forward),
+            Action::Next => self.next(forward),
+            Action::Continue => self.step_continue(forward),
+            _ => todo!(),
+        }
     }
 
-    fn current_step_id(&self) -> StepId {
+    fn load_locals(&mut self, _arg: CtLoadLocalsArguments) -> Result<Vec<Variable>, Box<dyn Error>> {
+        let full_value_locals: Vec<Variable> = self.db.variables[self.step_id]
+            .iter()
+            .map(|v| Variable {
+                expression: self.db.variable_name(v.variable_id).to_string(),
+                value: self.db.to_ct_value(&v.value),
+            })
+            .collect();
+
+        // TODO: fix random order here as well: ensure order(or in final locals?)
+        let value_tracking_locals: Vec<Variable> = self.db.variable_cells[self.step_id]
+            .iter()
+            .map(|(variable_id, place)| {
+                let name = self.db.variable_name(*variable_id);
+                info!("log local {variable_id:?} {name} place: {place:?}");
+                let value = self.db.load_value_for_place(*place, self.step_id);
+                Variable {
+                    expression: self.db.variable_name(*variable_id).to_string(),
+                    value: self.db.to_ct_value(&value),
+                }
+            })
+            .collect();
+        // based on https://stackoverflow.com/a/56490417/438099
+        let mut locals: Vec<Variable> = full_value_locals.into_iter().chain(value_tracking_locals).collect();
+
+        locals.sort_by(|left, right| Ord::cmp(&left.expression, &right.expression));
+        // for now just removing duplicated variables/expressions: even if storing different values
+        locals.dedup_by(|a, b| a.expression == b.expression);
+
+        Ok(locals)
+    }
+    fn current_step_id(&mut self) -> StepId {
         self.step_id
     }
 }
diff --git a/src/db-backend/src/handler.rs b/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::{Db, DbCall, DbRecordEvent, DbReplay, DbStep};
+use crate::db::{BreakpointRecord, Db, DbCall, DbRecordEvent, DbReplay, DbStep};
 use crate::event_db::{EventDb, SingleTableId};
 use crate::expr_loader::ExprLoader;
 use crate::flow_preloader::FlowPreloader;
@@ -66,13 +66,6 @@ pub enum TraceKind {
     RR,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct BreakpointRecord {
-    pub is_active: bool,
-}
-
-type LineTraceMap = HashMap<usize, Vec<(usize, String)>>;
-
 // two choices:
 //   return results and potentially
 //   generate multiple events as a generator
@@ -338,44 +331,17 @@ impl Handler {
         Ok(())
     }
 
-    pub fn load_locals(&mut self, req: dap::Request, _args: task::CtLoadLocalsArguments) -> Result<(), Box<dyn Error>> {
-        if self.trace_kind == TraceKind::RR {
-            let locals: Vec<Variable> = vec![];
-            warn!("load_locals not implemented for rr yet");
+    pub fn load_locals(&mut self, req: dap::Request, args: task::CtLoadLocalsArguments) -> Result<(), Box<dyn Error>> {
+        // if self.trace_kind == TraceKind::RR {
+            // let locals: Vec<Variable> = vec![];
+            // warn!("load_locals not implemented for rr yet");
+            let locals = self.replay.load_locals(args)?;
             self.respond_dap(req, task::CtLoadLocalsResponseBody { locals })?;
-            return Ok(());
-        }
-
-        let full_value_locals: Vec<Variable> = self.db.variables[self.step_id]
-            .iter()
-            .map(|v| Variable {
-                expression: self.db.variable_name(v.variable_id).to_string(),
-                value: self.db.to_ct_value(&v.value),
-            })
-            .collect();
-
-        // TODO: fix random order here as well: ensure order(or in final locals?)
-        let value_tracking_locals: Vec<Variable> = self.db.variable_cells[self.step_id]
-            .iter()
-            .map(|(variable_id, place)| {
-                let name = self.db.variable_name(*variable_id);
-                info!("log local {variable_id:?} {name} place: {place:?}");
-                let value = self.db.load_value_for_place(*place, self.step_id);
-                Variable {
-                    expression: self.db.variable_name(*variable_id).to_string(),
-                    value: self.db.to_ct_value(&value),
-                }
-            })
-            .collect();
-        // based on https://stackoverflow.com/a/56490417/438099
-        let mut locals: Vec<Variable> = full_value_locals.into_iter().chain(value_tracking_locals).collect();
-
-        locals.sort_by(|left, right| Ord::cmp(&left.expression, &right.expression));
-        // for now just removing duplicated variables/expressions: even if storing different values
-        locals.dedup_by(|a, b| a.expression == b.expression);
+            Ok(())
+        // }
 
-        self.respond_dap(req, task::CtLoadLocalsResponseBody { locals })?;
-        Ok(())
+        // self.respond_dap(req, task::CtLoadLocalsResponseBody { locals })?;
+        // Ok(())
     }
 
     // pub fn load_callstack(&mut self, task: Task) -> Result<(), Box<dyn Error>> {
@@ -563,7 +529,7 @@ impl Handler {
     }
 
     pub fn step_in(&mut self, forward: bool) -> Result<(), Box<dyn Error>> {
-        self.replay.step_in(forward)?;
+        self.replay.step(Action::StepIn, forward)?;
         self.step_id = self.replay.current_step_id();
 
         Ok(())
@@ -596,57 +562,23 @@ impl Handler {
     }
 
     pub fn next(&mut self, forward: bool) -> Result<(), Box<dyn Error>> {
-        let step_to_different_line = true; // which is better/should be let the user configure it?
-        (self.step_id, _) = self
-            .db
-            .next_step_id_relative_to(self.step_id, forward, step_to_different_line);
+        self.replay.step(Action::Next, forward)?;
+        self.step_id = self.replay.current_step_id();
         Ok(())
     }
 
     pub fn step_out(&mut self, forward: bool) -> Result<(), Box<dyn Error>> {
-        (self.step_id, _) = self.db.step_out_step_id_relative_to(self.step_id, forward);
+        self.replay.step(Action::StepOut, forward)?;
+        self.step_id = self.replay.current_step_id();
         Ok(())
     }
 
     #[allow(clippy::expect_used)]
     pub fn step_continue(&mut self, forward: bool) -> Result<(), Box<dyn Error>> {
-        for step in self.db.step_from(self.step_id, forward) {
-            if !self.breakpoint_list.is_empty() {
-                if let Some(is_active) = self.breakpoint_list[step.path_id.0]
-                    .get(&step.line.into())
-                    .map(|bp| bp.is_active)
-                {
-                    if is_active {
-                        self.step_id_jump(step.step_id);
-                        self.complete_move(false)?;
-                        return Ok(());
-                    }
-                }
-            } else {
-                break;
-            }
+        if !self.replay.step(Action::Continue, forward)? {
+            self.send_notification(NotificationKind::Info, "No breakpoints were hit!", false)?;
         }
-
-        // If the continue step doesn't find a valid breakpoint.
-        if forward {
-            self.step_id_jump(
-                self.db
-                    .steps
-                    .last()
-                    .expect("unexpected 0 steps in trace for step_continue")
-                    .step_id,
-            );
-        } else {
-            self.step_id_jump(
-                self.db
-                    .steps
-                    .first()
-                    .expect("unexpected 0 steps in trace for step_continue")
-                    .step_id,
-            )
-        }
-        self.complete_move(false)?;
-        self.send_notification(NotificationKind::Info, "No breakpoints were hit!", false)?;
+        self.step_id = self.replay.current_step_id();
         Ok(())
     }
 
@@ -663,21 +595,23 @@ impl Handler {
             Action::Continue => self.step_continue(!arg.reverse)?,
             _ => error!("action {:?} not implemented", arg.action),
         }
-        if arg.complete && arg.action != Action::Continue {
+        if arg.complete { // && arg.action != Action::Continue {
             self.complete_move(false)?;
         }
 
-        if original_step_id == self.step_id {
-            let location = if self.step_id == StepId(0) { "beginning" } else { "end" };
-            self.send_notification(
-                NotificationKind::Warning,
-                &format!("Limit of record at the {location} already reached!"),
-                false,
-            )?;
-        } else if self.step_id == StepId(0) {
-            self.send_notification(NotificationKind::Info, "Beginning of record reached", false)?;
-        } else if self.step_id.0 as usize == self.db.steps.len() - 1 {
-            self.send_notification(NotificationKind::Info, "End of record reached", false)?;
+        if self.trace_kind == TraceKind::DB {
+            if original_step_id == self.step_id {
+                let location = if self.step_id == StepId(0) { "beginning" } else { "end" };
+                self.send_notification(
+                    NotificationKind::Warning,
+                    &format!("Limit of record at the {location} already reached!"),
+                    false,
+                )?;
+            } else if self.step_id == StepId(0) {
+                self.send_notification(NotificationKind::Info, "Beginning of record reached", false)?;
+            } else if self.step_id.0 as usize == self.db.steps.len() - 1 {
+                self.send_notification(NotificationKind::Info, "End of record reached", false)?;
+            }
         }
         // } else if arg.action == Action::Next {
         //     let new_step = self.db.steps[self.step_id];
diff --git a/src/db-backend/src/query.rs b/src/db-backend/src/query.rs
@@ -1,8 +1,12 @@
 use serde::{Deserialize, Serialize};
 
+use crate::task::{Action, CtLoadLocalsArguments};
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(tag = "kind")]
 pub enum CtRRQuery {
     RunToEntry,
     LoadLocation,
+    Step { action: Action, forward: bool },
+    LoadLocals { arg: CtLoadLocalsArguments },
 }
diff --git a/src/db-backend/src/replay.rs b/src/db-backend/src/replay.rs
@@ -2,7 +2,7 @@ use runtime_tracing::StepId;
 use std::error::Error;
 
 use crate::expr_loader::ExprLoader;
-use crate::task::{Location, ProgramEvent};
+use crate::task::{Action, Location, ProgramEvent, CtLoadLocalsArguments, Variable};
 
 #[derive(Debug, Clone)]
 pub struct Events {
@@ -15,6 +15,7 @@ pub trait Replay: std::fmt::Debug {
     fn load_location(&mut self, expr_loader: &mut ExprLoader) -> Result<Location, Box<dyn Error>>;
     fn run_to_entry(&mut self) -> Result<(), Box<dyn Error>>;
     fn load_events(&mut self) -> Result<Events, Box<dyn Error>>;
-    fn step_in(&mut self, forward: bool) -> Result<(), Box<dyn Error>>;
-    fn current_step_id(&self) -> StepId;
+    fn step(&mut self, action: Action, forward: bool) -> Result<bool, Box<dyn Error>>;
+    fn load_locals(&mut self, arg: CtLoadLocalsArguments) -> Result<Vec<Variable>, Box<dyn Error>>;
+    fn current_step_id(&mut self) -> StepId;
 }
diff --git a/src/db-backend/src/rr_dispatcher.rs b/src/db-backend/src/rr_dispatcher.rs
