refactor: continue with flow_preloader refactoring: a bit more left

Author: alehander92

src/db-backend/src/db.rs

@@ -784,14 +784,15 @@ pub struct BreakpointRecord {
 pub struct DbReplay {
     pub db: Box<Db>,
     pub step_id: StepId,
+    pub call_key: CallKey,
     pub breakpoint_list: Vec<HashMap<usize, BreakpointRecord>>,
 }
 
 impl DbReplay {
     pub fn new(db: Box<Db>) -> DbReplay {
         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 }
+        DbReplay { db, step_id: StepId(0), call_key: CallKey(0), breakpoint_list }
     }
 
     pub fn step_id_jump(&mut self, step_id: StepId) {
@@ -925,6 +926,7 @@ impl Replay for DbReplay {
     fn load_location(&mut self, expr_loader: &mut ExprLoader) -> Result<Location, Box<dyn Error>> {
         info!("load_location: db replay");
         let call_key = self.db.call_key_for_step(self.step_id);
+        self.call_key = call_key;
         Ok(self.db.load_location(self.step_id, call_key, expr_loader))
     }
 
@@ -999,6 +1001,27 @@ impl Replay for DbReplay {
         Ok(locals)
     }
 
+    fn load_value(&mut self, expression: &str) -> Result<ValueRecord, Box<dyn Error>> {
+        // TODO: a more optimal way: cache a hashmap? or change structure?
+        // or again start directly loading available values matching all expressions in the same time?:
+        //   taking a set of expressions: probably best(maybe add an additional load_values)
+        for variable in &self.db.variables[self.step_id] {
+            if self.db.variable_names[variable.variable_id] == expression {
+                return Ok(variable.value.clone())
+            }
+        }
+        return Err(format!("variable {expression} not found on this step").into())
+    }
+
+    fn load_return_value(&mut self) -> Result<ValueRecord, Box<dyn Error>> {
+        // assumes self.load_location() has been ran, and that we have the current call key
+        Ok(self.db.calls[self.call_key].return_value.clone())
+    }
+
+    fn load_step_events(&mut self, step_id: StepId, exact: bool) -> Vec<DbRecordEvent> {
+        self.db.load_step_events(step_id, exact)
+    }
+    
     fn jump_to(&mut self, step_id: StepId) -> Result<bool, Box<dyn Error>> {
         self.step_id = step_id;
         Ok(true)

src/db-backend/src/diff.rs

@@ -8,7 +8,7 @@ use num_derive::FromPrimitive;
 use runtime_tracing::FunctionId;
 use log::info;
 
-use crate::db::Db;
+use crate::db::{Db,DbReplay};
 use crate::trace_processor::{load_trace_data, load_trace_metadata, TraceProcessor};
 use crate::flow_preloader::FlowPreloader;
 
@@ -146,7 +146,8 @@ pub fn index_diff(diff: Diff, trace_folder: &Path, multitrace_folder: &Path) ->
 
     info!("diff_lines {diff_lines:?}");
     let mut flow_preloader = FlowPreloader::new();
-    let flow_update = flow_preloader.load_diff_flow(diff_lines, &db);
+    let mut replay = Box::new(DbReplay::new(db.clone()));
+    let flow_update = flow_preloader.load_diff_flow(diff_lines, &db, &mut replay);
 
     let raw = serde_json::to_string(&flow_update)?;
     std::fs::write(multitrace_folder.join("diff_index.json"), raw)?;

src/db-backend/src/expr_loader.rs

@@ -382,8 +382,7 @@ impl ExprLoader {
         Ok(())
     }
 
-    pub fn load_branch_for_step(&self, step: &DbStep, path: &PathBuf) -> HashMap<usize, BranchState> {
-        let position = Position(step.line.0);
+    pub fn load_branch_for_position(&self, position: Position, path: &PathBuf) -> HashMap<usize, BranchState> {
         let mut results: HashMap<usize, BranchState> = HashMap::default();
         if self.processed_files[path].position_branches.contains_key(&position) {
             let mut branch = self.processed_files[path].position_branches[&position].clone();
@@ -413,13 +412,13 @@ impl ExprLoader {
         results
     }
 
-    pub fn get_loop_shape(&self, step: &DbStep, path: &PathBuf) -> Option<LoopShape> {
+    pub fn get_loop_shape(&self, line: Position, path: &PathBuf) -> Option<LoopShape> {
         info!("path {}", path.display());
         info!(
             "get_loop_shape {} {:?}",
-            step.line.0, self.processed_files[path].position_loops
+            line.0, self.processed_files[path].position_loops
         );
-        if let Some(loop_shape_id) = self.processed_files[path].position_loops.get(&Position(step.line.0)) {
+        if let Some(loop_shape_id) = self.processed_files[path].position_loops.get(&line) {
             return Some(self.processed_files[path].loop_shapes[loop_shape_id.0 as usize].clone());
         }
         None