use crate::{ transport::{Event, Payload, Request, Response, Transport}, Result, }; use serde::{Deserialize, Serialize}; use serde_json::{from_value, to_value, Value}; use std::process::Stdio; use std::sync::atomic::{AtomicU64, Ordering}; use tokio::{ io::{BufReader, BufWriter}, process::{Child, Command}, sync::mpsc::{channel, UnboundedReceiver, UnboundedSender}, }; #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] pub struct DebuggerCapabilities { supports_configuration_done_request: bool, supports_function_breakpoints: bool, supports_conditional_breakpoints: bool, supports_exception_info_request: bool, support_terminate_debuggee: bool, supports_delayed_stack_trace_loading: bool, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] struct InitializeArguments { client_id: String, client_name: String, adapter_id: String, locale: String, #[serde(rename = "linesStartAt1")] lines_start_at_one: bool, #[serde(rename = "columnsStartAt1")] columns_start_at_one: bool, path_format: String, supports_variable_type: bool, supports_variable_paging: bool, supports_run_in_terminal_request: bool, supports_memory_references: bool, supports_progress_reporting: bool, supports_invalidated_event: bool, } // TODO: split out #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] struct LaunchArguments { mode: String, program: String, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] pub struct Source { path: Option, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] pub struct SourceBreakpoint { pub line: usize, pub column: Option, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] struct SetBreakpointsArguments { source: Source, breakpoints: Option>, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] pub struct Breakpoint { pub id: Option, pub verified: bool, pub message: Option, pub source: Option, pub line: Option, pub column: Option, pub end_line: Option, pub end_column: Option, pub instruction_reference: Option, pub offset: Option, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] struct SetBreakpointsResponseBody { breakpoints: Option>, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] struct ContinueArguments { thread_id: usize, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] struct ContinueResponseBody { all_threads_continued: Option, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] struct StackFrameFormat { parameters: Option, parameter_types: Option, parameter_names: Option, parameter_values: Option, line: Option, module: Option, include_all: Option, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] struct StackTraceArguments { thread_id: usize, start_frame: Option, levels: Option, format: Option, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] pub struct StackFrame { id: usize, name: String, source: Option, line: usize, column: usize, end_line: Option, end_column: Option, can_restart: Option, instruction_pointer_reference: Option, // module_id presentation_hint: Option, } #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] struct StackTraceResponseBody { total_frames: Option, stack_frames: Vec, } #[derive(Debug)] pub struct Client { id: usize, _process: Child, server_tx: UnboundedSender, server_rx: UnboundedReceiver, request_counter: AtomicU64, capabilities: Option, } impl Client { pub fn start(cmd: &str, args: Vec<&str>, id: usize) -> Result { let process = Command::new(cmd) .args(args) .stdin(Stdio::piped()) .stdout(Stdio::piped()) // make sure the process is reaped on drop .kill_on_drop(true) .spawn(); let mut process = process?; // TODO: do we need bufreader/writer here? or do we use async wrappers on unblock? let writer = BufWriter::new(process.stdin.take().expect("Failed to open stdin")); let reader = BufReader::new(process.stdout.take().expect("Failed to open stdout")); let (server_rx, server_tx) = Transport::start(reader, writer, id); let client = Self { id, _process: process, server_tx, server_rx, request_counter: AtomicU64::new(0), capabilities: None, }; // TODO: async client.initialize() // maybe use an arc flag Ok(client) } pub fn id(&self) -> usize { self.id } fn next_request_id(&self) -> u64 { self.request_counter.fetch_add(1, Ordering::Relaxed) } async fn request(&self, command: String, arguments: Option) -> Result { let (callback_rx, mut callback_tx) = channel(1); let req = Request { back_ch: Some(callback_rx), seq: self.next_request_id(), msg_type: "request".to_owned(), command, arguments, }; self.server_tx .send(req) .expect("Failed to send request to debugger"); callback_tx .recv() .await .expect("Failed to receive response") } pub fn capabilities(&self) -> &DebuggerCapabilities { self.capabilities .as_ref() .expect("language server not yet initialized!") } pub async fn initialize(&mut self) -> Result<()> { let args = InitializeArguments { client_id: "hx".to_owned(), client_name: "helix".to_owned(), adapter_id: "go".to_owned(), locale: "en-us".to_owned(), lines_start_at_one: true, columns_start_at_one: true, path_format: "path".to_owned(), supports_variable_type: false, supports_variable_paging: false, supports_run_in_terminal_request: false, supports_memory_references: false, supports_progress_reporting: true, supports_invalidated_event: true, }; let response = self .request("initialize".to_owned(), to_value(args).ok()) .await?; self.capabilities = from_value(response.body.unwrap()).ok(); Ok(()) } pub async fn disconnect(&mut self) -> Result<()> { self.request("disconnect".to_owned(), None).await?; Ok(()) } pub async fn launch(&mut self, executable: String) -> Result<()> { let args = LaunchArguments { mode: "exec".to_owned(), program: executable, }; self.request("launch".to_owned(), to_value(args).ok()) .await?; match self .server_rx .recv() .await .expect("Expected initialized event") { Payload::Event(Event { event, .. }) => { if event == "initialized".to_owned() { Ok(()) } else { unreachable!() } } _ => unreachable!(), } } pub async fn set_breakpoints( &mut self, file: String, breakpoints: Vec, ) -> Result>> { let args = SetBreakpointsArguments { source: Source { path: Some(file) }, breakpoints: Some(breakpoints), }; let response = self .request("setBreakpoints".to_owned(), to_value(args).ok()) .await?; let body: Option = from_value(response.body.unwrap()).ok(); Ok(body.map(|b| b.breakpoints).unwrap()) } pub async fn configuration_done(&mut self) -> Result<()> { self.request("configurationDone".to_owned(), None).await?; Ok(()) } pub async fn wait_for_stopped(&mut self) -> Result<()> { match self.server_rx.recv().await.expect("Expected stopped event") { Payload::Event(Event { event, .. }) => { if event == "stopped".to_owned() { Ok(()) } else { unreachable!() } } _ => unreachable!(), } } pub async fn continue_thread(&mut self, thread_id: usize) -> Result> { let args = ContinueArguments { thread_id }; let response = self .request("continue".to_owned(), to_value(args).ok()) .await?; let body: Option = from_value(response.body.unwrap()).ok(); Ok(body.map(|b| b.all_threads_continued).unwrap()) } pub async fn stack_trace( &mut self, thread_id: usize, ) -> Result<(Vec, Option)> { let args = StackTraceArguments { thread_id, start_frame: None, levels: None, format: None, }; let response = self .request("stackTrace".to_owned(), to_value(args).ok()) .await?; let body: StackTraceResponseBody = from_value(response.body.unwrap()).unwrap(); Ok((body.stack_frames, body.total_frames)) } }