refactor: pass lang for some cases of loading values/locals

Author: alehander92

src/common/common_types/language_features/value.nim

@@ -72,6 +72,7 @@ type
     rrTicks*: int
     countBudget*: int
     minCountLimit*: int
+    lang*: Lang
 
   CtLoadLocalsResponseBody* = ref object
     locals*: seq[Variable]

src/db-backend/src/db.rs

@@ -1054,7 +1054,7 @@ impl Replay for DbReplay {
         Ok(locals)
     }
 
-    fn load_value(&mut self, expression: &str) -> Result<ValueRecordWithType, Box<dyn Error>> {
+    fn load_value(&mut self, expression: &str, _lang: Lang) -> 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)
@@ -1066,7 +1066,7 @@ impl Replay for DbReplay {
         return Err(format!("variable {expression} not found on this step").into())
     }
 
-    fn load_return_value(&mut self) -> Result<ValueRecordWithType, Box<dyn Error>> {
+    fn load_return_value(&mut self, _lang: Lang) -> Result<ValueRecordWithType, Box<dyn Error>> {
         // assumes self.load_location() has been ran, and that we have the current call key
         Ok(self.to_value_record_with_type(&self.db.calls[self.call_key].return_value.clone()))
     }

src/db-backend/src/flow_preloader.rs

@@ -1,18 +1,21 @@
+use std::collections::{HashMap, HashSet};
+use std::path::{Path, PathBuf};
+use std::error::Error;
+
+use log::{info, warn, error};
+use runtime_tracing::{CallKey, Line, StepId, TypeKind, TypeRecord, TypeSpecificInfo};
+
 use crate::{
     db::{Db, DbRecordEvent},
     expr_loader::ExprLoader,
     task::{
         Action, BranchesTaken, CoreTrace, FlowEvent, FlowStep, FlowUpdate, FlowUpdateState, FlowUpdateStateKind,
         FlowMode, FlowViewUpdate, Iteration, Location, Loop, LoopId, LoopIterationSteps, Position, RRTicks, StepCount, TraceKind,
     },
+    lang::{lang_from_context, Lang},
     replay::Replay,
     value::{to_ct_value, Value, ValueRecordWithType},
 };
-use log::{info, warn, error};
-use runtime_tracing::{CallKey, Line, StepId, TypeKind, TypeRecord, TypeSpecificInfo};
-use std::collections::{HashMap, HashSet};
-use std::path::PathBuf;
-use std::error::Error;
 
 #[derive(Debug)]
 pub struct FlowPreloader {
@@ -109,6 +112,7 @@ pub struct CallFlowPreloader<'a> {
     diff_call_keys: HashSet<i64>, //  TODO: if we add Eq, Hash it seems we can do CallKey
     mode: FlowMode,
     trace_kind: TraceKind,
+    lang: Lang,
 }
 
 impl<'a> CallFlowPreloader<'a> {
@@ -121,14 +125,15 @@ impl<'a> CallFlowPreloader<'a> {
             trace_kind: TraceKind) -> Self {
         CallFlowPreloader {
             flow_preloader,
-            location,
+            location: location.clone(),
             active_loops: vec![],
             last_step_id: StepId(-1),
             last_expr_order: vec![],
             diff_lines,
             diff_call_keys,
             mode,
             trace_kind,
+            lang: lang_from_context(&Path::new(&location.path), trace_kind),
         }
     }
 
@@ -190,7 +195,7 @@ impl<'a> CallFlowPreloader<'a> {
         // are never None, so it is safe to unwrap them.
         if !flow_view_update.steps.is_empty() {
 
-            let return_value_record = replay.load_return_value().unwrap_or(ValueRecordWithType::Error { 
+            let return_value_record = replay.load_return_value(self.lang).unwrap_or(ValueRecordWithType::Error { 
                 msg: "<return value error>".to_string(),
                 typ: TypeRecord { kind: TypeKind::Error, lang_type: "<error>".to_string(), specific_info: TypeSpecificInfo::None },
             });
@@ -521,7 +526,7 @@ impl<'a> CallFlowPreloader<'a> {
         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 let Ok(value) = replay.load_value(value_name, self.lang) {
                 // if variable_map.contains_key(value_name) {
                     let ct_value = to_ct_value(&value);
                     flow_view_update

src/db-backend/src/lang.rs

@@ -1,6 +1,11 @@
+use std::path::Path;
+use std::ffi::OsStr;
+
 use num_derive::FromPrimitive;
 use serde_repr::*;
 
+use crate::task::TraceKind;
+
 #[derive(
     Debug,
     Default,
@@ -36,3 +41,15 @@ pub enum Lang {
     PythonDb,
     Unknown,
 }
+
+pub fn lang_from_context(path: &Path, trace_kind: TraceKind) -> Lang {
+    let extension = path.extension().unwrap_or(OsStr::new("")).to_str().unwrap_or("");
+    // for now important mostly for system langs/rr support
+    // but still good to add all supported langs: TODO
+    match extension {
+        "rs" => if trace_kind == TraceKind::DB { Lang::RustWasm } else { Lang::Rust },
+        "c" => Lang::C,
+        "cpp" => Lang::Cpp,
+        _ => Lang::Unknown,
+    }
+}

src/db-backend/src/query.rs

@@ -1,6 +1,7 @@
 use serde::{Deserialize, Serialize};
 
 use crate::task::{Action, Breakpoint, CtLoadLocalsArguments, Location};
+use crate::lang::Lang;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(tag = "kind")]
@@ -9,11 +10,11 @@ pub enum CtRRQuery {
     LoadLocation,
     Step { action: Action, forward: bool },
     LoadLocals { arg: CtLoadLocalsArguments },
-    LoadReturnValue,
-    LoadValue { expression: String },
-    AddBreakpoint { path: String, line: i64, },
-    DeleteBreakpoint { breakpoint: Breakpoint, },
+    LoadReturnValue { lang: Lang },
+    LoadValue { expression: String, lang: Lang },
+    AddBreakpoint { path: String, line: i64 },
+    DeleteBreakpoint { breakpoint: Breakpoint },
     DeleteBreakpoints,
-    ToggleBreakpoint { breakpoint: Breakpoint, },
+    ToggleBreakpoint { breakpoint: Breakpoint },
     JumpToCall { location: Location },
 }

src/db-backend/src/replay.rs

@@ -3,9 +3,11 @@ use std::error::Error;
 
 use crate::db::DbRecordEvent;
 use crate::expr_loader::ExprLoader;
+use crate::lang::Lang;
 use crate::task::{Action, Breakpoint, Location, ProgramEvent, CtLoadLocalsArguments, VariableWithRecord};
 use crate::value::ValueRecordWithType;
 
+
 #[derive(Debug, Clone)]
 pub struct Events {
     pub events: Vec<ProgramEvent>,
@@ -19,9 +21,12 @@ pub trait Replay: std::fmt::Debug {
     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<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<ValueRecordWithType, Box<dyn Error>>;
+    fn load_value(&mut self, expression: &str, lang: Lang) -> Result<ValueRecordWithType, Box<dyn Error>>;
+
+    // assuming currently the replay is stopped in the right `call`(frame) for both trace kinds; 
+    //   and if rr: possibly near the return value
+    fn load_return_value(&mut self, lang: Lang) -> 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

@@ -13,6 +13,7 @@ use runtime_tracing::StepId;
 
 use crate::db::DbRecordEvent;
 use crate::expr_loader::ExprLoader;
+use crate::lang::Lang;
 use crate::paths::ct_rr_worker_socket_path;
 use crate::query::CtRRQuery;
 use crate::replay::{Events, Replay};
@@ -218,15 +219,17 @@ impl Replay for RRDispatcher {
         Ok(res)
     }
 
-    fn load_value(&mut self, expression: &str) -> Result<ValueRecordWithType, Box<dyn Error>> {
+    fn load_value(&mut self, expression: &str, lang: Lang) -> Result<ValueRecordWithType, Box<dyn Error>> {
         self.ensure_active_stable()?;
-        let res = serde_json::from_str::<ValueRecordWithType>(&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(),
+            lang, })?)?;
         Ok(res)
     }
 
-    fn load_return_value(&mut self) -> Result<ValueRecordWithType, Box<dyn Error>> {
+    fn load_return_value(&mut self, lang: Lang) -> Result<ValueRecordWithType, Box<dyn Error>> {
         self.ensure_active_stable()?;
-        let res = serde_json::from_str::<ValueRecordWithType>(&self.stable.run_query(CtRRQuery::LoadReturnValue)?)?;
+        let res = serde_json::from_str::<ValueRecordWithType>(&self.stable.run_query(CtRRQuery::LoadReturnValue { lang })?)?;
         Ok(res)
     }
 

src/db-backend/src/task.rs

@@ -24,6 +24,7 @@ pub struct CtLoadLocalsArguments {
     pub rr_ticks: i64,
     pub count_budget: i64,
     pub min_count_limit: i64,
+    pub lang: Lang,
 }
 
 /// response for `ct/load-locals`

src/frontend/ui/state.nim

@@ -71,6 +71,7 @@ method onMove(self: StateComponent) {.async.} =
     rrTicks: self.rrTicks,
     countBudget: countBudget,
     minCountLimit: minCountLimit,
+    lang: toLangFromFilename(self.location.path),
   )
   self.api.emit(CtLoadLocals, arguments)
   self.redraw()