1 files changed, 352 insertions, 0 deletions
diff --git a/helix-dap/src/client.rs b/helix-dap/src/client.rs
new file mode 100644
index 00000000..9f269a53
--- /dev/null
+++ b/helix-dap/src/client.rs
@@ -0,0 +1,352 @@
+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<String>,
+}
+
+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SourceBreakpoint {
+    pub line: usize,
+    pub column: Option<usize>,
+}
+
+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct SetBreakpointsArguments {
+    source: Source,
+    breakpoints: Option<Vec<SourceBreakpoint>>,
+}
+
+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Breakpoint {
+    pub id: Option<usize>,
+    pub verified: bool,
+    pub message: Option<String>,
+    pub source: Option<Source>,
+    pub line: Option<usize>,
+    pub column: Option<usize>,
+    pub end_line: Option<usize>,
+    pub end_column: Option<usize>,
+    pub instruction_reference: Option<String>,
+    pub offset: Option<usize>,
+}
+
+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct SetBreakpointsResponseBody {
+    breakpoints: Option<Vec<Breakpoint>>,
+}
+
+#[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<bool>,
+}
+
+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct StackFrameFormat {
+    parameters: Option<bool>,
+    parameter_types: Option<bool>,
+    parameter_names: Option<bool>,
+    parameter_values: Option<bool>,
+    line: Option<bool>,
+    module: Option<bool>,
+    include_all: Option<bool>,
+}
+
+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct StackTraceArguments {
+    thread_id: usize,
+    start_frame: Option<usize>,
+    levels: Option<usize>,
+    format: Option<StackFrameFormat>,
+}
+
+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct StackFrame {
+    id: usize,
+    name: String,
+    source: Option<Source>,
+    line: usize,
+    column: usize,
+    end_line: Option<usize>,
+    end_column: Option<usize>,
+    can_restart: Option<bool>,
+    instruction_pointer_reference: Option<String>,
+    // module_id
+    presentation_hint: Option<String>,
+}
+
+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct StackTraceResponseBody {
+    total_frames: Option<usize>,
+    stack_frames: Vec<StackFrame>,
+}
+
+#[derive(Debug)]
+pub struct Client {
+    id: usize,
+    _process: Child,
+    server_tx: UnboundedSender<Request>,
+    server_rx: UnboundedReceiver<Payload>,
+    request_counter: AtomicU64,
+    capabilities: Option<DebuggerCapabilities>,
+}
+
+impl Client {
+    pub fn start(cmd: &str, args: Vec<&str>, id: usize) -> Result<Self> {
+        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<atomic> 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<Value>) -> Result<Response> {
+        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<SourceBreakpoint>,
+    ) -> Result<Option<Vec<Breakpoint>>> {
+        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<SetBreakpointsResponseBody> = 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<Option<bool>> {
+        let args = ContinueArguments { thread_id };
+
+        let response = self
+            .request("continue".to_owned(), to_value(args).ok())
+            .await?;
+
+        let body: Option<ContinueResponseBody> = 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<StackFrame>, Option<usize>)> {
+        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))
+    }
+}