fix: start using ValueRecordWithType to be able to embed types in the newer value form

useful for rr: for now add some convert functions for compatibility;
maybe in the future try to replace the old `Value` with the newer versions

Author: alehander92

src/db-backend/src/db.rs

@@ -15,8 +15,8 @@ use crate::distinct_vec::DistinctVec;
 use crate::expr_loader::ExprLoader;
 use crate::lang::Lang;
 use crate::replay::{Events, Replay};
-use crate::task::{Action, Breakpoint, Call, CallArg, CoreTrace, Location, ProgramEvent, RRTicks, NO_INDEX, NO_PATH, NO_POSITION, CtLoadLocalsArguments, Variable};
-use crate::value::{Type, Value};
+use crate::task::{Action, Breakpoint, Call, CallArg, CoreTrace, Location, ProgramEvent, RRTicks, NO_INDEX, NO_PATH, NO_POSITION, CtLoadLocalsArguments, VariableWithRecord};
+use crate::value::{Type, Value, ValueRecordWithType};
 
 const NEXT_INTERNAL_STEP_OVERS_LIMIT: usize = 1_000;
 
@@ -795,6 +795,52 @@ impl DbReplay {
         DbReplay { db, step_id: StepId(0), call_key: CallKey(0), breakpoint_list, breakpoint_next_id: 0 }
     }
 
+    pub fn register_type(&mut self, typ: TypeRecord) -> TypeId {
+        // for no checking for typ.name logic: eventually in ensure_type?
+        self.db.types.push(typ);
+        TypeId(self.db.types.len() - 1)
+    }
+
+    pub fn to_value_record(&mut self, v: ValueRecordWithType) -> ValueRecord {
+        match v {
+            ValueRecordWithType::Int { i, typ } => {
+                let type_id = self.register_type(typ);
+                ValueRecord::Int { i, type_id }
+            },
+            ValueRecordWithType::Float { f, typ } => {
+                let type_id = self.register_type(typ);
+                ValueRecord::Float { f, type_id }
+            }
+            ValueRecordWithType::Bool { b, typ } => {
+                let type_id = self.register_type(typ);
+                ValueRecord::Bool { b, type_id }
+            }
+            ValueRecordWithType::String { text, typ } => {
+                let type_id = self.register_type(typ);
+                ValueRecord::String { text, type_id }
+            }
+            _ => todo!()
+        }
+    }
+
+    pub fn to_value_record_with_type(&mut self, v: &ValueRecord) -> ValueRecordWithType {
+        match v {
+            ValueRecord::Int { i, type_id } => {
+                ValueRecordWithType::Int { i: *i, typ: self.db.types[*type_id].clone() }
+            },
+            ValueRecord::Float { f, type_id } => {
+                ValueRecordWithType::Float { f: *f, typ: self.db.types[*type_id].clone() }
+            }
+            ValueRecord::Bool { b, type_id } => {
+                ValueRecordWithType::Bool { b: *b, typ: self.db.types[*type_id].clone() }
+            }
+            ValueRecord::String { text, type_id } => {
+                ValueRecordWithType::String { text: text.to_string(), typ: self.db.types[*type_id].clone() }
+            }
+            _ => todo!()
+        }
+    }
+
     pub fn step_id_jump(&mut self, step_id: StepId) {
         if step_id.0 != NO_INDEX {
             self.step_id = step_id;
@@ -973,30 +1019,33 @@ impl Replay for DbReplay {
         }
     }
 
-    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]
+    fn load_locals(&mut self, _arg: CtLoadLocalsArguments) -> Result<Vec<VariableWithRecord>, Box<dyn Error>> {
+        let variables_for_step = self.db.variables[self.step_id].clone();
+        let full_value_locals: Vec<VariableWithRecord> = variables_for_step
             .iter()
-            .map(|v| Variable {
+            .map(|v| VariableWithRecord {
                 expression: self.db.variable_name(v.variable_id).to_string(),
-                value: self.db.to_ct_value(&v.value),
+                value: self.to_value_record_with_type(&v.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]
+        let variable_cells_for_step = self.db.variable_cells[self.step_id].clone();
+        let value_tracking_locals: Vec<VariableWithRecord> = variable_cells_for_step
             .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 {
+                VariableWithRecord {
                     expression: self.db.variable_name(*variable_id).to_string(),
-                    value: self.db.to_ct_value(&value),
+                    value: self.to_value_record_with_type(&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();
+        let mut locals: Vec<VariableWithRecord> = 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
@@ -1005,21 +1054,21 @@ impl Replay for DbReplay {
         Ok(locals)
     }
 
-    fn load_value(&mut self, expression: &str) -> Result<ValueRecord, Box<dyn Error>> {
+    fn load_value(&mut self, expression: &str) -> Result<ValueRecordWithType, 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 Ok(self.to_value_record_with_type(&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>> {
+    fn load_return_value(&mut self) -> Result<ValueRecordWithType, 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())
+        Ok(self.to_value_record_with_type(&self.db.calls[self.call_key].return_value.clone()))
     }
 
     fn load_step_events(&mut self, step_id: StepId, exact: bool) -> Vec<DbRecordEvent> {

src/db-backend/src/flow_preloader.rs

@@ -6,10 +6,10 @@ use crate::{
         FlowMode, FlowViewUpdate, Iteration, Location, Loop, LoopId, LoopIterationSteps, Position, RRTicks, StepCount, TraceKind,
     },
     replay::Replay,
-    value::Value,
+    value::{to_ct_value, Value, ValueRecordWithType},
 };
 use log::{info, warn, error};
-use runtime_tracing::{CallKey, Line, StepId, ValueRecord, TypeId};
+use runtime_tracing::{CallKey, Line, StepId, TypeKind, TypeRecord, TypeSpecificInfo};
 use std::collections::{HashMap, HashSet};
 use std::path::PathBuf;
 use std::error::Error;
@@ -179,12 +179,11 @@ impl<'a> CallFlowPreloader<'a> {
         // are never None, so it is safe to unwrap them.
         if !flow_view_update.steps.is_empty() {
 
-            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 { 
+            let return_value_record = replay.load_return_value().unwrap_or(ValueRecordWithType::Error { 
                 msg: "<return value error>".to_string(),
-                type_id: TypeId(0),
+                typ: TypeRecord { kind: TypeKind::Error, lang_type: "<error>".to_string(), specific_info: TypeSpecificInfo::None },
             });
-            let return_value = db.to_ct_value(&return_value_record);
+            let return_value = to_ct_value(&return_value_record);
 
             #[allow(clippy::unwrap_used)]
             flow_view_update.steps.last_mut().unwrap().before_values.insert(
@@ -513,8 +512,7 @@ impl<'a> CallFlowPreloader<'a> {
             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 ct_value = db.to_ct_value(&value);
+                    let ct_value = to_ct_value(&value);
                     flow_view_update
                         .steps
                         .last_mut()

src/db-backend/src/handler.rs

@@ -31,6 +31,7 @@ use crate::task::{
     UpdateTableArgs, Variable, NO_INDEX, NO_PATH, NO_POSITION, NO_STEP_ID,
 };
 use crate::tracepoint_interpreter::TracepointInterpreter;
+use crate::value::to_ct_value;
 
 const TRACEPOINT_RESULTS_LIMIT_BEFORE_UPDATE: usize = 5;
 
@@ -328,7 +329,11 @@ impl Handler {
         // 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)?;
+            let locals_with_records = self.replay.load_locals(args)?;
+            let locals = locals_with_records.iter().map(|l| Variable {
+                expression: l.expression.clone(),
+                value: to_ct_value(&l.value)
+            }).collect();
             self.respond_dap(req, task::CtLoadLocalsResponseBody { locals })?;
             Ok(())
         // }

src/db-backend/src/replay.rs

@@ -1,9 +1,10 @@
-use runtime_tracing::{StepId, ValueRecord};
+use runtime_tracing::StepId;
 use std::error::Error;
 
 use crate::db::DbRecordEvent;
 use crate::expr_loader::ExprLoader;
-use crate::task::{Action, Breakpoint, Location, ProgramEvent, CtLoadLocalsArguments, Variable};
+use crate::task::{Action, Breakpoint, Location, ProgramEvent, CtLoadLocalsArguments, VariableWithRecord};
+use crate::value::ValueRecordWithType;
 
 #[derive(Debug, Clone)]
 pub struct Events {
@@ -17,10 +18,10 @@ pub trait Replay: std::fmt::Debug {
     fn run_to_entry(&mut self) -> Result<(), Box<dyn Error>>;
     fn load_events(&mut self) -> Result<Events, Box<dyn Error>>;
     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 load_value(&mut self, expression: &str) -> Result<ValueRecord, Box<dyn Error>>;
+    fn load_locals(&mut self, arg: CtLoadLocalsArguments) -> Result<Vec<VariableWithRecord>, Box<dyn Error>>;
+    fn load_value(&mut self, expression: &str) -> Result<ValueRecordWithType, Box<dyn Error>>;
     // assuming currently in the right call for both trace kinds; and if rr: possibly near the return value
-    fn load_return_value(&mut self) -> Result<ValueRecord, Box<dyn Error>>;
+    fn load_return_value(&mut self) -> Result<ValueRecordWithType, 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>>;

src/db-backend/src/rr_dispatcher.rs

@@ -8,14 +8,15 @@ use std::thread;
 use std::time::Duration;
 
 use log::{info, warn, error};
-use runtime_tracing::{StepId, ValueRecord};
+use runtime_tracing::StepId;
 
 use crate::db::DbRecordEvent;
 use crate::expr_loader::ExprLoader;
 use crate::paths::ct_rr_worker_socket_path;
 use crate::query::CtRRQuery;
 use crate::replay::{Events, Replay};
-use crate::task::{Action, Breakpoint, Location, CtLoadLocalsArguments, Variable};
+use crate::task::{Action, Breakpoint, Location, CtLoadLocalsArguments, VariableWithRecord};
+use crate::value::ValueRecordWithType;
 
 #[derive(Debug)]
 pub struct RRDispatcher {
@@ -123,7 +124,7 @@ impl CtRRWorker {
 
         res = String::from(res.trim()); // trim newlines/whitespace!
 
-        info!("res {res}");
+        info!("res: `{res}`");
 
         if !res.starts_with("error:") {
             Ok(res)
@@ -192,21 +193,21 @@ impl Replay for RRDispatcher {
         Ok(res)
     }
 
-    fn load_locals(&mut self, arg: CtLoadLocalsArguments) -> Result<Vec<Variable>, Box<dyn Error>> {
+    fn load_locals(&mut self, arg: CtLoadLocalsArguments) -> Result<Vec<VariableWithRecord>, Box<dyn Error>> {
         self.ensure_active_stable()?;
-        let res = serde_json::from_str::<Vec<Variable>>(&self.stable.run_query(CtRRQuery::LoadLocals { arg })?)?;
+        let res = serde_json::from_str::<Vec<VariableWithRecord>>(&self.stable.run_query(CtRRQuery::LoadLocals { arg })?)?;
         Ok(res)
     }
 
-    fn load_value(&mut self, expression: &str) -> Result<ValueRecord, Box<dyn Error>> {
+    fn load_value(&mut self, expression: &str) -> Result<ValueRecordWithType, Box<dyn Error>> {
         self.ensure_active_stable()?;
-        let res = serde_json::from_str::<ValueRecord>(&self.stable.run_query(CtRRQuery::LoadValue { expression: expression.to_string() })?)?;
+        let res = serde_json::from_str::<ValueRecordWithType>(&self.stable.run_query(CtRRQuery::LoadValue { expression: expression.to_string() })?)?;
         Ok(res)
     }
 
-    fn load_return_value(&mut self) -> Result<ValueRecord, Box<dyn Error>> {
+    fn load_return_value(&mut self) -> Result<ValueRecordWithType, Box<dyn Error>> {
         self.ensure_active_stable()?;
-        let res = serde_json::from_str::<ValueRecord>(&self.stable.run_query(CtRRQuery::LoadReturnValue)?)?;
+        let res = serde_json::from_str::<ValueRecordWithType>(&self.stable.run_query(CtRRQuery::LoadReturnValue)?)?;
         Ok(res)
     }
 

src/db-backend/src/task.rs

@@ -11,7 +11,7 @@ use serde::{Deserialize, Serialize};
 use serde_repr::*;
 
 use crate::lang::*;
-use crate::value::{Type, Value};
+use crate::value::{Type, Value, ValueRecordWithType};
 use schemars::JsonSchema;
 
 // IMPORTANT: must keep in sync with `EventLogKind` definition in common_types.nim!
@@ -124,6 +124,20 @@ pub struct Variable {
     pub value: Value,
 }
 
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all(serialize = "camelCase", deserialize = "camelCase"))]
+pub struct VariableWithRecord {
+    pub expression: String,
+    pub value: ValueRecordWithType,
+}
+
+// pub struct ValueRecordAndType {
+//     value: ValueRecord,
+//     typ: Type,
+// }
+
+
 #[derive(Debug, Default, Clone, Serialize, Deserialize)]
 #[serde(rename_all(serialize = "camelCase", deserialize = "camelCase"))]
 pub struct Instruction {