dap: Start working on runInTerminal support

helix-core/src/syntax.rs

@@ -114,6 +114,7 @@ pub enum DebugConfigCompletion {
 pub enum DebugArgumentValue {
     String(String),
     Array(Vec<String>),
+    Boolean(bool),
 }
 
 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]

helix-dap/src/client.rs

@@ -244,7 +244,7 @@ impl Client {
             path_format: Some("path".to_owned()),
             supports_variable_type: Some(true),
             supports_variable_paging: Some(false),
-            supports_run_in_terminal_request: Some(false),
+            supports_run_in_terminal_request: Some(true),
             supports_memory_references: Some(false),
             supports_progress_reporting: Some(false),
             supports_invalidated_event: Some(false),

helix-term/src/application.rs

@@ -321,147 +321,154 @@ impl Application {
     pub async fn handle_debugger_message(&mut self, payload: helix_dap::Payload) {
         use crate::commands::dap::{breakpoints_changed, resume_application, select_thread_id};
         use helix_dap::{events, Event};
-        let debugger = match self.editor.debugger.as_mut() {
-            Some(debugger) => debugger,
-            None => return,
-        };
 
         match payload {
-            Payload::Event(ev) => match ev {
+            Payload::Event(ev) => {
-                Event::Stopped(events::Stopped {
+                let debugger = match self.editor.debugger.as_mut() {
-                    thread_id,
+                    Some(debugger) => debugger,
-                    description,
+                    None => return,
-                    text,
+                };
-                    reason,
+                match ev {
-                    all_threads_stopped,
+                    Event::Stopped(events::Stopped {
-                    ..
+                        thread_id,
-                }) => {
+                        description,
-                    let all_threads_stopped = all_threads_stopped.unwrap_or_default();
+                        text,
+                        reason,
+                        all_threads_stopped,
+                        ..
+                    }) => {
+                        let all_threads_stopped = all_threads_stopped.unwrap_or_default();
 
-                    if all_threads_stopped {
+                        if all_threads_stopped {
-                        if let Ok(threads) = debugger.threads().await {
+                            if let Ok(threads) = debugger.threads().await {
-                            for thread in threads {
+                                for thread in threads {
-                                fetch_stack_trace(debugger, thread.id).await;
+                                    fetch_stack_trace(debugger, thread.id).await;
+                                }
+                                select_thread_id(
+                                    &mut self.editor,
+                                    thread_id.unwrap_or_default(),
+                                    false,
+                                )
+                                .await;
                             }
-                            select_thread_id(
+                        } else if let Some(thread_id) = thread_id {
-                                &mut self.editor,
+                            debugger.thread_states.insert(thread_id, reason.clone()); // TODO: dap uses "type" || "reason" here
-                                thread_id.unwrap_or_default(),
+
-                                false,
+                            // whichever thread stops is made "current" (if no previously selected thread).
-                            )
+                            select_thread_id(&mut self.editor, thread_id, false).await;
-                            .await;
                         }
-                    } else if let Some(thread_id) = thread_id {
-                        debugger.thread_states.insert(thread_id, reason.clone()); // TODO: dap uses "type" || "reason" here
 
-                        // whichever thread stops is made "current" (if no previously selected thread).
+                        let scope = match thread_id {
-                        select_thread_id(&mut self.editor, thread_id, false).await;
+                            Some(id) => format!("Thread {}", id),
-                    }
+                            None => "Target".to_owned(),
+                        };
 
-                    let scope = match thread_id {
+                        let mut status = format!("{} stopped because of {}", scope, reason);
-                        Some(id) => format!("Thread {}", id),
+                        if let Some(desc) = description {
-                        None => "Target".to_owned(),
+                            status.push_str(&format!(" {}", desc));
-                    };
+                        }
+                        if let Some(text) = text {
+                            status.push_str(&format!(" {}", text));
+                        }
+                        if all_threads_stopped {
+                            status.push_str(" (all threads stopped)");
+                        }
 
-                    let mut status = format!("{} stopped because of {}", scope, reason);
+                        self.editor.set_status(status);
-                    if let Some(desc) = description {
-                        status.push_str(&format!(" {}", desc));
                     }
-                    if let Some(text) = text {
+                    Event::Continued(events::Continued { thread_id, .. }) => {
-                        status.push_str(&format!(" {}", text));
+                        debugger
+                            .thread_states
+                            .insert(thread_id, "running".to_owned());
+                        if debugger.thread_id == Some(thread_id) {
+                            resume_application(debugger)
+                        }
                     }
-                    if all_threads_stopped {
+                    Event::Thread(_) => {
-                        status.push_str(" (all threads stopped)");
+                        // TODO: update thread_states, make threads request
                     }
+                    Event::Breakpoint(events::Breakpoint { reason, breakpoint }) => {
+                        match &reason[..] {
+                            "new" => {
+                                if let Some(source) = breakpoint.source {
+                                    self.editor
+                                        .breakpoints
+                                        .entry(source.path.unwrap()) // TODO: no unwraps
+                                        .or_default()
+                                        .push(Breakpoint {
+                                            id: breakpoint.id,
+                                            verified: breakpoint.verified,
+                                            message: breakpoint.message,
+                                            line: breakpoint.line.unwrap().saturating_sub(1), // TODO: no unwrap
+                                            column: breakpoint.column,
+                                            ..Default::default()
+                                        });
+                                }
+                            }
+                            "changed" => {
+                                for breakpoints in self.editor.breakpoints.values_mut() {
+                                    if let Some(i) =
+                                        breakpoints.iter().position(|b| b.id == breakpoint.id)
+                                    {
+                                        breakpoints[i].verified = breakpoint.verified;
+                                        breakpoints[i].message = breakpoint.message.clone();
+                                        breakpoints[i].line =
+                                            breakpoint.line.unwrap().saturating_sub(1); // TODO: no unwrap
+                                        breakpoints[i].column = breakpoint.column;
+                                    }
+                                }
+                            }
+                            "removed" => {
+                                for breakpoints in self.editor.breakpoints.values_mut() {
+                                    if let Some(i) =
+                                        breakpoints.iter().position(|b| b.id == breakpoint.id)
+                                    {
+                                        breakpoints.remove(i);
+                                    }
+                                }
+                            }
+                            reason => {
+                                warn!("Unknown breakpoint event: {}", reason);
+                            }
+                        }
+                    }
+                    Event::Output(events::Output {
+                        category, output, ..
+                    }) => {
+                        let prefix = match category {
+                            Some(category) => {
+                                if &category == "telemetry" {
+                                    return;
+                                }
+                                format!("Debug ({}):", category)
+                            }
+                            None => "Debug:".to_owned(),
+                        };
 
-                    self.editor.set_status(status);
+                        log::info!("{}", output);
-                }
+                        self.editor.set_status(format!("{} {}", prefix, output));
-                Event::Continued(events::Continued { thread_id, .. }) => {
-                    debugger
-                        .thread_states
-                        .insert(thread_id, "running".to_owned());
-                    if debugger.thread_id == Some(thread_id) {
-                        resume_application(debugger)
                     }
-                }
+                    Event::Initialized => {
-                Event::Thread(_) => {
+                        // send existing breakpoints
-                    // TODO: update thread_states, make threads request
+                        for (path, breakpoints) in &mut self.editor.breakpoints {
-                }
+                            // TODO: call futures in parallel, await all
-                Event::Breakpoint(events::Breakpoint { reason, breakpoint }) => match &reason[..] {
+                            let _ = breakpoints_changed(debugger, path.clone(), breakpoints);
-                    "new" => {
+                        }
-                        if let Some(source) = breakpoint.source {
+                        // TODO: fetch breakpoints (in case we're attaching)
+
+                        if debugger.configuration_done().await.is_ok() {
                             self.editor
-                                .breakpoints
+                                .set_status("Debugged application started".to_owned());
-                                .entry(source.path.unwrap()) // TODO: no unwraps
+                        }; // TODO: do we need to handle error?
-                                .or_default()
-                                .push(Breakpoint {
-                                    id: breakpoint.id,
-                                    verified: breakpoint.verified,
-                                    message: breakpoint.message,
-                                    line: breakpoint.line.unwrap().saturating_sub(1), // TODO: no unwrap
-                                    column: breakpoint.column,
-                                    ..Default::default()
-                                });
-                        }
                     }
-                    "changed" => {
+                    ev => {
-                        for breakpoints in self.editor.breakpoints.values_mut() {
+                        log::warn!("Unhandled event {:?}", ev);
-                            if let Some(i) = breakpoints.iter().position(|b| b.id == breakpoint.id)
+                        return; // return early to skip render
-                            {
-                                breakpoints[i].verified = breakpoint.verified;
-                                breakpoints[i].message = breakpoint.message.clone();
-                                breakpoints[i].line = breakpoint.line.unwrap().saturating_sub(1); // TODO: no unwrap
-                                breakpoints[i].column = breakpoint.column;
-                            }
-                        }
                     }
-                    "removed" => {
-                        for breakpoints in self.editor.breakpoints.values_mut() {
-                            if let Some(i) = breakpoints.iter().position(|b| b.id == breakpoint.id)
-                            {
-                                breakpoints.remove(i);
-                            }
-                        }
-                    }
-                    reason => {
-                        warn!("Unknown breakpoint event: {}", reason);
-                    }
-                },
-                Event::Output(events::Output {
-                    category, output, ..
-                }) => {
-                    let prefix = match category {
-                        Some(category) => {
-                            if &category == "telemetry" {
-                                return;
-                            }
-                            format!("Debug ({}):", category)
-                        }
-                        None => "Debug:".to_owned(),
-                    };
-
-                    log::info!("{}", output);
-                    self.editor.set_status(format!("{} {}", prefix, output));
                 }
-                Event::Initialized => {
+            }
-                    // send existing breakpoints
-                    for (path, breakpoints) in &mut self.editor.breakpoints {
-                        // TODO: call futures in parallel, await all
-                        let _ = breakpoints_changed(debugger, path.clone(), breakpoints);
-                    }
-                    // TODO: fetch breakpoints (in case we're attaching)
-
-                    if debugger.configuration_done().await.is_ok() {
-                        self.editor
-                            .set_status("Debugged application started".to_owned());
-                    }; // TODO: do we need to handle error?
-                }
-                ev => {
-                    log::warn!("Unhandled event {:?}", ev);
-                    return; // return early to skip render
-                }
-            },
             Payload::Response(_) => unreachable!(),
-            Payload::Request(_) => todo!(),
+            Payload::Request(request) => unimplemented!("{:?}", request),
         }
         self.render();
     }

helix-term/src/commands/dap.rs

@@ -251,29 +251,40 @@ pub fn dap_start_impl(
                 // For param #0 replace {0} in args
                 let pattern = format!("{{{}}}", i);
                 value = match value {
+                    // TODO: just use toml::Value -> json::Value
                     DebugArgumentValue::String(v) => {
                         DebugArgumentValue::String(v.replace(&pattern, &param))
                     }
                     DebugArgumentValue::Array(arr) => DebugArgumentValue::Array(
                         arr.iter().map(|v| v.replace(&pattern, &param)).collect(),
                     ),
+                    DebugArgumentValue::Boolean(_) => value,
                 };
             }
 
-            if let DebugArgumentValue::String(string) = value {
+            match value {
-                if let Ok(integer) = string.parse::<usize>() {
+                DebugArgumentValue::String(string) => {
-                    args.insert(k, to_value(integer).unwrap());
+                    if let Ok(integer) = string.parse::<usize>() {
-                } else {
+                        args.insert(k, to_value(integer).unwrap());
-                    args.insert(k, to_value(string).unwrap());
+                    } else {
+                        args.insert(k, to_value(string).unwrap());
+                    }
+                }
+                DebugArgumentValue::Array(arr) => {
+                    args.insert(k, to_value(arr).unwrap());
+                }
+                DebugArgumentValue::Boolean(bool) => {
+                    args.insert(k, to_value(bool).unwrap());
                 }
-            } else if let DebugArgumentValue::Array(arr) = value {
-                args.insert(k, to_value(arr).unwrap());
             }
         }
     }
 
     let args = to_value(args).unwrap();
 
+    // problem: this blocks for too long while we get back the startInTerminal REQ
+
+    log::error!("pre start");
     let result = match &template.request[..] {
         "launch" => block_on(debugger.launch(args)),
         "attach" => block_on(debugger.attach(args)),
@@ -282,6 +293,7 @@ pub fn dap_start_impl(
             return;
         }
     };
+    log::error!("post start");
     if let Err(e) = result {
         let msg = format!("Failed {} target: {}", template.request, e);
         editor.set_error(msg);

languages.toml

@@ -23,6 +23,12 @@ request = "launch"
 completion = [ { name = "binary", completion = "filename" } ]
 args = { program = "{0}" }
 
+[[language.debugger.templates]]
+name = "binary (terminal)"
+request = "launch"
+completion = [ { name = "binary", completion = "filename" } ]
+args = { program = "{0}", runInTerminal = true }
+
 [[language.debugger.templates]]
 name = "attach"
 request = "attach"