refactor: finish initial flow preloader generalization for rr+db; fix for location

for now working in simple cases for db-backend, and at least not crashing for
some for rr; but not yet a good example of working for rr;

a small fix that tries to repeat the function first/last info for each of the
lines in range in expr_loader; maybe we can instead check the region but for now
hopefully an ok fix

IMPORTANT: some problems overally: jumps and some flow in db-backend seem to be
broken

Author: alehander92

src/db-backend/src/dap.rs

@@ -371,7 +371,7 @@ pub fn to_json(message: &DapMessage) -> DapResult<String> {
 pub fn read_dap_message_from_reader<R: std::io::BufRead>(reader: &mut R) -> DapResult<DapMessage> {
     use log::info;
 
-    info!("from_reader");
+    info!("read_dap_message_from_reader");
     let mut header = String::new();
     reader.read_line(&mut header).map_err(|e| {
         use log::error;

src/db-backend/src/db.rs

@@ -261,6 +261,10 @@ impl Db {
     }
 
     fn to_ct_type(&self, type_id: &TypeId) -> Type {
+        if self.types.len() == 0 { // probably rr trace case
+            warn!("to_ct_type: for now returning just a placeholder type: assuming rr trace!");
+            return Type::new(TypeKind::None, "<None>");
+        }
         let type_record = &self.types[*type_id];
         match self.types[*type_id].kind {
             TypeKind::Struct => {

src/db-backend/src/diff.rs

@@ -146,7 +146,7 @@ pub fn index_diff(diff: Diff, trace_folder: &Path, multitrace_folder: &Path) ->
 
     info!("diff_lines {diff_lines:?}");
     let mut flow_preloader = FlowPreloader::new();
-    let mut replay = Box::new(DbReplay::new(db.clone()));
+    let mut replay = DbReplay::new(Box::new(db.clone()));
     let flow_update = flow_preloader.load_diff_flow(diff_lines, &db, &mut replay);
 
     let raw = serde_json::to_string(&flow_update)?;

src/db-backend/src/expr_loader.rs

@@ -1,5 +1,4 @@
 use crate::{
-    db::DbStep,
     lang::Lang,
     task::{
         Branch, BranchId, BranchState, CoreTrace, Location, LoopShape, LoopShapeId, Position, NO_BRANCH_ID, NO_POSITION,
@@ -276,13 +275,15 @@ impl ExprLoader {
         // extract function names and positions
         } else if NODE_NAMES[&lang].functions.contains(&node.kind().to_string()) {
             if let Some(name) = self.get_method_name(node, path, row) {
-                self.processed_files
-                    .get_mut(path)
-                    .unwrap()
-                    .functions
-                    .entry(start)
-                    .or_default()
-                    .push((name.to_string(), start, end));
+                for i in start.0 .. end.0 {
+                    self.processed_files
+                        .get_mut(path)
+                        .unwrap()
+                        .functions
+                        .entry(Position(i))
+                        .or_default()
+                        .push((name.to_string(), start, end));
+                };
                 self.loop_index = 1;
             }
         } else if NODE_NAMES[&lang].loops.contains(&node.kind().to_string()) && start != end {
@@ -384,7 +385,7 @@ impl ExprLoader {
 
     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) {
+        if self.processed_files.contains_key(path) && self.processed_files[path].position_branches.contains_key(&position) {
             let mut branch = self.processed_files[path].position_branches[&position].clone();
             branch.status = BranchState::Taken;
             results.insert(branch.header_line.0 as usize, branch.status);
@@ -404,9 +405,11 @@ impl ExprLoader {
         check_list: &HashMap<usize, BranchState>,
     ) -> HashMap<usize, BranchState> {
         let mut results: HashMap<usize, BranchState> = HashMap::default();
-        for branch in &self.processed_files[path].branch {
-            if !check_list.contains_key(&(branch.header_line.0 as usize)) && branch.status == BranchState::Unknown {
-                results.insert(branch.header_line.0 as usize, BranchState::NotTaken);
+        if self.processed_files.contains_key(path) {
+            for branch in &self.processed_files[path].branch {
+                if !check_list.contains_key(&(branch.header_line.0 as usize)) && branch.status == BranchState::Unknown {
+                    results.insert(branch.header_line.0 as usize, BranchState::NotTaken);
+                }
             }
         }
         results
@@ -416,10 +419,10 @@ impl ExprLoader {
         info!("path {}", path.display());
         info!(
             "get_loop_shape {} {:?}",
-            line.0, self.processed_files[path].position_loops
+            line.0, self.processed_files.get(path)?.position_loops
         );
-        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());
+        if let Some(loop_shape_id) = self.processed_files.get(path)?.position_loops.get(&line) {
+            return Some(self.processed_files.get(path)?.loop_shapes[loop_shape_id.0 as usize].clone());
         }
         None
     }
@@ -486,6 +489,8 @@ impl ExprLoader {
     }
 
     pub fn get_first_last_fn_lines(&self, location: &Location, line: &Line) -> (i64, i64) {
+        info!("functions {:?}", self.processed_files);
+        info!("get_first_last_fn_lines {:?}:{}", location.path, line.0);
         let (_, mut start, mut end): (String, Position, Position) =
             (String::default(), Position(NO_POSITION), Position(NO_POSITION));
         let path_buf = &PathBuf::from(&location.path);
@@ -517,15 +522,15 @@ impl ExprLoader {
         updated_location
     }
 
-    pub fn get_expr_list(&self, line: Line, location: &Location) -> Option<Vec<String>> {
+    pub fn get_expr_list(&self, line: Position, location: &Location) -> Option<Vec<String>> {
         self.processed_files
             .get(&PathBuf::from(&location.path))
-            .and_then(|file| file.variables.get(&Position(line.0)).cloned())
+            .and_then(|file| file.variables.get(&line).cloned())
     }
     // pub fn load_loops(&mut self, )
 
     pub fn get_comment_positions(&self, path: &PathBuf) -> Vec<Position> {
-        self.processed_files.get(path).unwrap().comment_lines.clone()
+        self.processed_files.get(path).unwrap_or(&FileInfo::new("")).comment_lines.clone()
     }
 }
 

src/db-backend/src/flow_preloader.rs

@@ -1,16 +1,15 @@
 use crate::{
-    db::{Db, DbRecordEvent, DbStep},
+    db::{Db, DbRecordEvent},
     expr_loader::ExprLoader,
     task::{
-        self,
         Action, BranchesTaken, CoreTrace, FlowEvent, FlowStep, FlowUpdate, FlowUpdateState, FlowUpdateStateKind,
         FlowMode, FlowViewUpdate, Iteration, Location, Loop, LoopId, LoopIterationSteps, Position, RRTicks, StepCount
     },
     replay::Replay,
     value::Value,
 };
 use log::{info, warn, error};
-use runtime_tracing::{CallKey, FullValueRecord, Line, StepId};
+use runtime_tracing::{CallKey, Line, StepId, ValueRecord, TypeId};
 use std::collections::{HashMap, HashSet};
 use std::path::PathBuf;
 use std::error::Error;
@@ -34,7 +33,7 @@ impl FlowPreloader {
         match self.expr_loader.load_file(&path_buf) {
             Ok(_) => {
                 info!("Expression loader complete!");
-                let mut call_flow_preloader: CallFlowPreloader = CallFlowPreloader::new(self, location, HashSet::new(), HashSet::new(), mode);
+                let mut call_flow_preloader: CallFlowPreloader = CallFlowPreloader::new(self, location.clone(), HashSet::new(), HashSet::new(), mode);
                 call_flow_preloader.load_flow(location, replay)
             }
             Err(e) => {
@@ -71,15 +70,15 @@ impl FlowPreloader {
         }
 
         let mut call_flow_preloader = CallFlowPreloader::new(self, Location::default(), diff_lines, diff_call_keys, FlowMode::Diff);
-        let location = Location { line: Line(1), ..Location::default() };
+        let location = Location { line: 1, ..Location::default() };
         call_flow_preloader.load_flow(location, replay)
     }
 
     // fn load_file(&mut self, path: &str) {
     // self.expr_loader.load_file(&PathBuf::from(path.to_string())).unwrap();
     // }
 
-    pub fn get_var_list(&self, line: Line, location: &Location) -> Option<Vec<String>> {
+    pub fn get_var_list(&self, line: Position, location: &Location) -> Option<Vec<String>> {
         self.expr_loader.get_expr_list(line, location)
     }
 
@@ -163,18 +162,21 @@ impl<'a> CallFlowPreloader<'a> {
         }
     }
 
-    fn add_return_value(&mut self, mut flow_view_update: FlowViewUpdate, replay: &mut dyn Replay, call_key: CallKey) -> FlowViewUpdate {
+    fn add_return_value(&mut self, mut flow_view_update: FlowViewUpdate, replay: &mut dyn Replay) -> FlowViewUpdate {
+        // assumes that replay is stopped on the place where return value is available
+
+        let return_string = "return".to_string();
+
         // The if condition ensures, that the Options on which .unwrap() is called
         // are never None, so it is safe to unwrap them.
-        let return_string = "return".to_string();
         if !flow_view_update.steps.is_empty() {
 
-            let db = Db::new(PathBuf::from("")); // we don't need its state for to_ct_value
+            let db = Db::new(&PathBuf::from("")); // we don't need its state for to_ct_value
             let return_value_record = replay.load_return_value().unwrap_or(ValueRecord::Error { 
                 msg: "<return value error>".to_string(),
                 type_id: TypeId(0),
             });
-            let return_value = db.to_ct_value(return_value_record);
+            let return_value = db.to_ct_value(&return_value_record);
 
             #[allow(clippy::unwrap_used)]
             flow_view_update.steps.last_mut().unwrap().before_values.insert(
@@ -207,7 +209,7 @@ impl<'a> CallFlowPreloader<'a> {
         flow_view_update
     }
 
-    fn next_diff_flow_step(&self, from_step_id: StepId, including_from: bool, replay: &mut dyn Replay) -> (StepId, bool) {
+    fn next_diff_flow_step(&self, _from_step_id: StepId, _including_from: bool, _replay: &mut dyn Replay) -> (StepId, bool) {
         // TODO: maybe combination of replay.next, diff_call_keys check, different for cases?s
         //
         // if from_step_id.0 >= db.steps.len() as i64 {
@@ -233,12 +235,12 @@ impl<'a> CallFlowPreloader<'a> {
         todo!()
     }
 
-    fn move_to_first_step(&self, from_step_id: StepId, replay: &mut dyn Replay) -> (StepId, bool) {
+    fn move_to_first_step(&self, from_step_id: StepId, replay: &mut dyn Replay) -> Result<(StepId, bool), Box<dyn Error>> {
         let (step_id, progressing) = match self.mode {
             FlowMode::Call => (from_step_id, true),
             FlowMode::Diff => self.next_diff_flow_step(StepId(0), true, replay),
         };
-        replay.jump_to(step_id);
+        replay.jump_to(step_id)?;
         Ok((step_id, progressing))
     }
 
@@ -248,7 +250,8 @@ impl<'a> CallFlowPreloader<'a> {
                 // let step_to_different_line = true; // for flow for now makes sense to try to always reach a new line
                 // db.next_step_id_relative_to(from_step_id, true, step_to_different_line),
                 replay.step(Action::Next, true).unwrap(); // TODO: handle error
-                let location = replay.load_location(&mut self.flow_preloader.expr_loader).unwrap(); // TODO: handle error
+                let mut expr_loader = ExprLoader::new(CoreTrace::default());
+                let location = replay.load_location(&mut expr_loader).unwrap(); // TODO: handle error
                 let new_step_id = StepId(location.rr_ticks.0);
                 let progressing = new_step_id != from_step_id;
                 (new_step_id, progressing)
@@ -257,23 +260,23 @@ impl<'a> CallFlowPreloader<'a> {
         }
     }
 
-    fn call_key_from(&self, location: Location) -> Result<CallKey, Box<dyn Error>> {
+    fn call_key_from(&self, location: &Location) -> Result<CallKey, Box<dyn Error>> {
         Ok(CallKey(location.key.parse::<i64>()?)) // for now still assume it's an integer
     }
 
     fn load_view_update(&mut self, replay: &mut dyn Replay) -> Result<FlowViewUpdate, Box<dyn Error>> {
         // let start_step_id = StepId(self.location.rr_ticks.0);
         // db.calls[call_key].step_id;
         // let mut path_buf = &PathBuf::from(&self.location.path);
-        let mut iter_step_id = StepId(self.location.rrTicks.0);
+        let mut iter_step_id = StepId(self.location.rr_ticks.0);
         let mut flow_view_update = FlowViewUpdate::new(self.location.clone());
         let mut step_count = 0;
         let mut first = true;
-        let last_call_key_result = self.call_key_from(self.location);
-        let mut last_call_key = CallKey(0);
-        match last_call_key_result {
+        let tracked_call_key_result = self.call_key_from(&self.location);
+        let tracked_call_key; // = CallKey(0);
+        match tracked_call_key_result {
             Ok(call_key) => {
-                last_call_key = call_key;
+                tracked_call_key = call_key;
             },
             Err(e) => {
                 error!("call key parse error: {e:?}");
@@ -291,15 +294,15 @@ impl<'a> CallFlowPreloader<'a> {
             // };
             let (step_id, progressing) = if first {
                 first = false;
-                self.move_to_first_step(iter_step_id, replay);
+                self.move_to_first_step(iter_step_id, replay)?
             } else {
-                self.move_to_next_step(iter_step_id, replay);
+                self.move_to_next_step(iter_step_id, replay)
             };
 
             iter_step_id = step_id;
             let mut expr_loader = ExprLoader::new(CoreTrace::default());
-            self.location = replay.load_location(&mut expr_loader);
-            let new_call_key = match self.call_key_from(self.location) {
+            self.location = replay.load_location(&mut expr_loader)?;
+            let new_call_key = match self.call_key_from(&self.location) {
                 Ok(call_key) => {
                     call_key
                 }
@@ -309,8 +312,20 @@ impl<'a> CallFlowPreloader<'a> {
                 }
             };
 
-            if self.mode == FlowMode::Call && last_call_key != new_call_key || !progressing {
-                flow_view_update = self.add_return_value(flow_view_update, replay, call_key);
+            if self.mode == FlowMode::Call && tracked_call_key != new_call_key || !progressing {
+                replay.step(Action::StepIn, false)?; // hopefully go back to the end of our original function
+                let return_location = replay.load_location(&mut expr_loader)?;
+                let mut load_return_value = false;
+                // maybe this can be improved with a limited loop/jump to return/exit of call in the future
+                if let Ok(return_call_key) = self.call_key_from(&return_location) {
+                    if return_call_key == tracked_call_key {
+                        flow_view_update = self.add_return_value(flow_view_update, replay);
+                        load_return_value = true;
+                    }
+                }
+                if !load_return_value {
+                    warn!("we can't load return value");
+                }
                 info!("break flow");
                 break;
             }
@@ -333,8 +348,8 @@ impl<'a> CallFlowPreloader<'a> {
             flow_view_update.add_step_count(line, step_count);
             info!("process loops");
             let path_buf = &PathBuf::from(&self.location.path);
-            flow_view_update = self.process_loops(flow_view_update.clone(), Position(self.location.line.0), replay.current_step_id(), path_buf, step_count);
-            flow_view_update = self.log_expressions(flow_view_update.clone(), Position(self.location.0), replay, step_id);
+            flow_view_update = self.process_loops(flow_view_update.clone(), Position(self.location.line), replay.current_step_id(), path_buf, step_count);
+            flow_view_update = self.log_expressions(flow_view_update.clone(), Position(self.location.line), replay, step_id);
             step_count += 1;
         }
         let path_buf = &PathBuf::from(&self.location.path);
@@ -346,7 +361,7 @@ impl<'a> CallFlowPreloader<'a> {
                 .expr_loader
                 .final_branch_load(path_buf, &flow_view_update.branches_taken[0][0].table),
         );
-        flow_view_update
+        Ok(flow_view_update)
     }
 
     #[allow(clippy::unwrap_used)]
@@ -358,7 +373,7 @@ impl<'a> CallFlowPreloader<'a> {
         path_buf: &PathBuf,
         step_count: i64,
     ) -> FlowViewUpdate {
-        if let Some(loop_shape) = self.flow_preloader.expr_loader.get_loop_shape(&line, path_buf) {
+        if let Some(loop_shape) = self.flow_preloader.expr_loader.get_loop_shape(line, path_buf) {
             if loop_shape.first.0 == line.0 && !self.active_loops.contains(&loop_shape.first) {
                 flow_view_update.loops.push(Loop {
                     base: LoopId(loop_shape.loop_id.0),
@@ -418,14 +433,14 @@ impl<'a> CallFlowPreloader<'a> {
                     .insert(line.0 as usize, step_count as usize);
                 flow_view_update.add_branches(
                     flow_view_update.loops.clone().last_mut().unwrap().base.0,
-                    self.flow_preloader.expr_loader.load_branch_for_position(&line, path_buf),
+                    self.flow_preloader.expr_loader.load_branch_for_position(line, path_buf),
                 );
             }
         } else {
             flow_view_update.loop_iteration_steps[0][0]
                 .table
                 .insert(line.0 as usize, step_count as usize);
-            flow_view_update.add_branches(0, self.flow_preloader.expr_loader.load_branch_for_position(&line, path_buf));
+            flow_view_update.add_branches(0, self.flow_preloader.expr_loader.load_branch_for_position(line, path_buf));
         }
         flow_view_update
     }
@@ -479,12 +494,12 @@ impl<'a> CallFlowPreloader<'a> {
         //     variable_map.insert(name.clone(), full_value_record);
         // }
 
-        if let Some(var_list) = self.flow_preloader.get_var_list(line.0, &self.location) {
+        if let Some(var_list) = self.flow_preloader.get_var_list(line, &self.location) {
             info!("var_list {:?}", var_list.clone());
             for value_name in &var_list {
                 if let Ok(value) = replay.load_value(value_name) {
                 // if variable_map.contains_key(value_name) {
-                    let db = Db::new(PathBuf::from("")); // no state needed for to_ct_value 
+                    let db = Db::new(&PathBuf::from("")); // no state needed for to_ct_value 
                     let ct_value = db.to_ct_value(&value);
                     flow_view_update
                         .steps
@@ -507,7 +522,7 @@ impl<'a> CallFlowPreloader<'a> {
                 if variable_map.contains_key(variable) {
                     flow_view_update.steps[index]
                         .after_values
-                        .insert(variable.clone(), variable_map[variable]);
+                        .insert(variable.clone(), variable_map[variable].clone());
                 }
             }
         }