complete emmy new debug launch debug

Author: CppCXY

src/context/debugger/cache.rs

@@ -196,7 +196,7 @@ impl DebuggerCacheItem {
                     match eval_rsp_result {
                         Ok(eval_rsp) => {
                             if eval_rsp.success {
-                                children = eval_rsp.value.children;
+                                children = eval_rsp.value.unwrap().children;
                             }
                         }
                         Err(err) => {

src/context/debugger/mod.rs

@@ -142,15 +142,17 @@ impl DebuggerConnection {
                             let mut start = 0;
                             let mut id_line = None;
                             let mut i = 0;
+                            let mut msg_id = 0;
 
                             while i < pos {
                                 // 查找换行符
                                 if buffer[i] == b'\n' {
                                     if id_line.is_none() {
                                         // 解析第一行作为消息ID
                                         if let Ok(id_str) = std::str::from_utf8(&buffer[start..i]) {
-                                            if let Ok(_msg_id) = id_str.parse::<i32>() {
+                                            if let Ok(parsed_msg_id) = id_str.parse::<i32>() {
                                                 // 记录ID并继续寻找JSON内容
+                                                msg_id = parsed_msg_id;
                                                 id_line = Some(start);
                                                 start = i + 1;
                                             }
@@ -159,9 +161,10 @@ impl DebuggerConnection {
                                         // 已有ID，这一行是JSON内容
                                         if let Ok(msg_str) = std::str::from_utf8(&buffer[start..i])
                                         {
-                                            if let Ok(message) =
-                                                serde_json::from_str::<Message>(msg_str)
-                                            {
+                                            if let Ok(message) = Message::from_str(
+                                                msg_str,
+                                                MessageCMD::from(msg_id as i64),
+                                            ) {
                                                 Self::dispatch_message(
                                                     message,
                                                     &senders,
@@ -436,6 +439,7 @@ pub struct DebuggerData {
     pub stacks: Vec<Stack>,
     pub file_cache: HashMap<String, Option<String>>,
     pub extension: Vec<String>,
+    pub sources: Vec<String>,
     pub current_frame_id: i64,
     pub cache: DebuggerCache,
     pub breakpoints: HashMap<(String, i64), BreakPoint>,

src/context/debugger/proto.rs

@@ -1,3 +1,4 @@
+#[allow(unused)]
 use serde::{Deserialize, Deserializer, Serialize, de};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
@@ -124,21 +125,10 @@ impl Message {
             Message::LogNotify(_) => MessageCMD::LogNotify,
         }
     }
-}
-
-impl<'de> Deserialize<'de> for Message {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let value = serde_json::Value::deserialize(deserializer)?;
-
-        let cmd = value
-            .get("cmd")
-            .and_then(|v| v.as_i64())
-            .ok_or_else(|| de::Error::missing_field("cmd"))?;
 
-        match MessageCMD::from(cmd) {
+    pub fn from_str(s: &str, cmd: MessageCMD) -> Result<Self, serde_json::Error> {
+        let value: serde_json::Value = serde_json::from_str(s)?;
+        match cmd {
             MessageCMD::InitReq => {
                 let init_req: InitReq = serde_json::from_value(value).map_err(de::Error::custom)?;
                 Ok(Message::InitReq(init_req))
@@ -220,7 +210,7 @@ impl<'de> Deserialize<'de> for Message {
                     serde_json::from_value(value).map_err(de::Error::custom)?;
                 Ok(Message::LogNotify(log_notify))
             }
-            _ => Err(de::Error::custom(format!("Unknown command: {}", cmd))),
+            _ => Err(de::Error::custom("Unknown command")),
         }
     }
 }
@@ -448,8 +438,10 @@ pub struct EvalReq {
 pub struct EvalRsp {
     pub seq: i32,
     pub success: bool,
-    pub error: String,
-    pub value: Variable,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub value: Option<Variable>,
 }
 
 #[derive(Debug, Serialize, Deserialize)]

src/context/emmy_new_debugger/mod.rs

@@ -7,4 +7,5 @@ pub struct EmmyNewDebugArguments {
     pub port: u16,
     pub ext: Vec<String>,
     pub ide_connect_debugger: bool,
+    pub source_paths: Vec<String>,
 }

src/handler/evaluate_request.rs

@@ -21,7 +21,7 @@ pub async fn on_evaluate_request(
 
     if eval_rsp.success {
         let mut data = dap.data.lock().await;
-        let value = eval_rsp.value;
+        let value = eval_rsp.value.unwrap();
         let ref_id = data.cache.allocate_cache_id();
         let variable_item = DebuggerCacheItem::Variable(
             DebuggerCacheRef::new(
@@ -44,7 +44,7 @@ pub async fn on_evaluate_request(
         }))
     } else {
         Ok(ResponseBody::Evaluate(EvaluateResponse {
-            result: eval_rsp.error,
+            result: eval_rsp.error.unwrap_or("".to_string()),
             type_field: Some("string".to_string()),
             variables_reference: 0,
             ..Default::default()

src/handler/launch_request.rs

@@ -58,6 +58,7 @@ pub async fn on_launch_request(
 
     let mut data = dap.data.lock().await;
     data.extension = emmy_new_debug_argument.ext.clone();
+    data.sources = emmy_new_debug_argument.source_paths.clone();
 
     let dap = dap.clone();
     tokio::spawn(async move {

src/handler/mod.rs

@@ -99,7 +99,6 @@ pub async fn on_request_dispatch(
                 .task(request, set_breakpoint_argument, on_set_breakpoints_request)
                 .await;
         }
-
         Command::Cancel(cancel_argument) => {
             if let Some(req_id) = cancel_argument.request_id {
                 context.cancel(req_id).await;

src/handler/set_breakpoint_request.rs

@@ -21,6 +21,8 @@ pub async fn on_set_breakpoints_request(
     let mut response_breakpoints = vec![];
     if let Some(path) = source.path {
         let mut data = dap.data.lock().await;
+        log::info!("retain breakpoints");
+        data.breakpoints.retain(|key, _| key.0 != path);
         if let Some(breakpoints) = set_breakpoints_arguments.breakpoints {
             for breakpoint in breakpoints {
                 let line = breakpoint.line;
@@ -44,9 +46,9 @@ pub async fn on_set_breakpoints_request(
 
                 response_breakpoints.push(response_breakpoint);
             }
-
-            send_all_breakpoints(dap.clone()).await;
         }
+        drop(data);
+        send_all_breakpoints(dap.clone()).await;
     } else {
         log::error!("No path provided in source");
     }
@@ -59,6 +61,7 @@ pub async fn on_set_breakpoints_request(
 pub async fn send_all_breakpoints(dap: DapSnapShot) {
     let data = dap.data.lock().await;
     let breakpoints = data.breakpoints.values().cloned().collect::<Vec<_>>();
+    log::info!("send all breakpoint: {:#?}", breakpoints);
     let debugger_conn = dap.debugger_conn.lock().await;
     match debugger_conn
         .send_message(Message::AddBreakPointReq(AddBreakPointReq {

src/handler/stack_trace_request.rs

@@ -1,3 +1,5 @@
+use std::path::Path;
+
 use dap::{requests::StackTraceArguments, responses::ResponseBody, types::Source};
 use tokio_util::sync::CancellationToken;
 
@@ -79,6 +81,11 @@ async fn find_file_path(
     } else {
         chunkname.clone()
     };
+    let sources = data
+        .sources
+        .iter()
+        .map(|s| Path::new(s))
+        .collect::<Vec<_>>();
 
     let mut file_paths = vec![];
     for ext in &data.extension {
@@ -94,11 +101,20 @@ async fn find_file_path(
     }
 
     for file_path in &file_paths {
-        if let Ok(metadata) = tokio::fs::metadata(file_path).await {
-            if metadata.is_file() {
+        let path = Path::new(file_path);
+        if path.exists() {
+            let real_file_path = path.to_string_lossy().to_string();
+            data.file_cache
+                .insert(chunkname.clone(), Some(real_file_path.clone()));
+            return Ok(Some(real_file_path));
+        }
+        for source in &sources {
+            let real_file_path = source.join(path);
+            if real_file_path.exists() {
+                let real_file_path_str = real_file_path.to_string_lossy().to_string();
                 data.file_cache
-                    .insert(chunkname.clone(), Some(file_path.clone()));
-                return Ok(Some(file_path.clone()));
+                    .insert(chunkname.clone(), Some(real_file_path_str.clone()));
+                return Ok(Some(real_file_path_str));
             }
         }
     }

src/logger/mod.rs

@@ -74,10 +74,11 @@ pub fn init_logger(cmd_args: &CmdArgs) {
     let logger = Dispatch::new()
         .format(|out, message, record| {
             out.finish(format_args!(
-                "[{} {} {}] {}",
+                "[{} {} {}:{}] {}",
                 Local::now().format("%Y-%m-%d %H:%M:%S %:z"),
                 record.level(),
                 record.target(),
+                record.line().unwrap_or(0),
                 message
             ))
         })
@@ -98,10 +99,11 @@ pub fn init_stderr_logger(level: LevelFilter) {
     let logger = Dispatch::new()
         .format(|out, message, record| {
             out.finish(format_args!(
-                "[{} {} {}] {}",
+                "[{} {} {}:{}] {}",
                 Local::now().format("%Y-%m-%d %H:%M:%S %:z"),
                 record.level(),
                 record.target(),
+                record.line().unwrap_or(0),
                 message
             ))
         })