Mirrors
/
helix
mirror of https://github.com/helix-editor/helix
1
1
Fork 1
Code Issues Packages Projects Releases Wiki Activity

dap: Start working on runInTerminal support

Browse Source
pull/574/head
Blaž Hrastnik 3 years ago
parent 0d73a4d23a
commit 2dbf966293
5 changed files with 155 additions and 129 deletions
Show Stats Download Patch File Download Diff File

1
helix-core/src/syntax.rs
Unescape Escape View File

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

2
helix-dap/src/client.rs
Unescape Escape View File

@ -244,7 +244,7 @@ impl Client {
path_format: Some("path".to_owned()), path_format: Some("path".to_owned()),
supports_variable_type: Some(true), supports_variable_type: Some(true),
supports_variable_paging: Some(false), 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_memory_references: Some(false),
supports_progress_reporting: Some(false), supports_progress_reporting: Some(false),
supports_invalidated_event: Some(false), supports_invalidated_event: Some(false),

249
helix-term/src/application.rs
Unescape Escape View File

@ -321,147 +321,154 @@ impl Application {
pub async fn handle_debugger_message(&mut self, payload: helix_dap::Payload) { pub async fn handle_debugger_message(&mut self, payload: helix_dap::Payload) {
use crate::commands::dap::{breakpoints_changed, resume_application, select_thread_id}; use crate::commands::dap::{breakpoints_changed, resume_application, select_thread_id};
use helix_dap::{events, Event}; use helix_dap::{events, Event};
let debugger = match self.editor.debugger.as_mut() {
Some(debugger) => debugger,
None => return,
};
match payload { 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,
if all_threads_stopped { all_threads_stopped,
if let Ok(threads) = debugger.threads().await { ..
for thread in threads { }) => {
fetch_stack_trace(debugger, thread.id).await; let all_threads_stopped = all_threads_stopped.unwrap_or_default();
if all_threads_stopped {
if let Ok(threads) = debugger.threads().await {
for thread in threads {
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,
)
.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). // whichever thread stops is made "current" (if no previously selected thread).
select_thread_id(&mut self.editor, thread_id, false).await; select_thread_id(&mut self.editor, thread_id, false).await;
} }
let scope = match thread_id { let scope = match thread_id {
Some(id) => format!("Thread {}", id), Some(id) => format!("Thread {}", id),
None => "Target".to_owned(), None => "Target".to_owned(),
}; };
let mut status = format!("{} stopped because of {}", scope, reason); let mut status = format!("{} stopped because of {}", scope, reason);
if let Some(desc) = description { if let Some(desc) = description {
status.push_str(&format!(" {}", desc)); status.push_str(&format!(" {}", desc));
} }
if let Some(text) = text { if let Some(text) = text {
status.push_str(&format!(" {}", text)); status.push_str(&format!(" {}", text));
} }
if all_threads_stopped { if all_threads_stopped {
status.push_str(" (all threads stopped)"); status.push_str(" (all threads stopped)");
} }
self.editor.set_status(status); self.editor.set_status(status);
}
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::Continued(events::Continued { thread_id, .. }) => {
Event::Thread(_) => { debugger
// TODO: update thread_states, make threads request .thread_states
} .insert(thread_id, "running".to_owned());
Event::Breakpoint(events::Breakpoint { reason, breakpoint }) => match &reason[..] { if debugger.thread_id == Some(thread_id) {
"new" => { resume_application(debugger)
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" => { Event::Thread(_) => {
for breakpoints in self.editor.breakpoints.values_mut() { // TODO: update thread_states, make threads request
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" => { Event::Breakpoint(events::Breakpoint { reason, breakpoint }) => {
for breakpoints in self.editor.breakpoints.values_mut() { match &reason[..] {
if let Some(i) = breakpoints.iter().position(|b| b.id == breakpoint.id) "new" => {
{ if let Some(source) = breakpoint.source {
breakpoints.remove(i); 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);
} }
} }
} }
reason => { Event::Output(events::Output {
warn!("Unknown breakpoint event: {}", reason); category, output, ..
} }) => {
}, let prefix = match category {
Event::Output(events::Output { Some(category) => {
category, output, .. if &category == "telemetry" {
}) => { return;
let prefix = match category { }
Some(category) => { format!("Debug ({}):", category)
if &category == "telemetry" {
return;
} }
format!("Debug ({}):", category) None => "Debug:".to_owned(),
} };
None => "Debug:".to_owned(),
};
log::info!("{}", output); log::info!("{}", output);
self.editor.set_status(format!("{} {}", prefix, 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) 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() { if debugger.configuration_done().await.is_ok() {
self.editor self.editor
.set_status("Debugged application started".to_owned()); .set_status("Debugged application started".to_owned());
}; // TODO: do we need to handle error? }; // TODO: do we need to handle error?
} }
ev => { ev => {
log::warn!("Unhandled event {:?}", ev); log::warn!("Unhandled event {:?}", ev);
return; // return early to skip render return; // return early to skip render
}
} }
}, }
Payload::Response(_) => unreachable!(), Payload::Response(_) => unreachable!(),
Payload::Request(_) => todo!(), Payload::Request(request) => unimplemented!("{:?}", request),
} }
self.render(); self.render();
} }

26
helix-term/src/commands/dap.rs
Unescape Escape View File

@ -251,29 +251,40 @@ pub fn dap_start_impl(
// For param #0 replace {0} in args // For param #0 replace {0} in args
let pattern = format!("{{{}}}", i); let pattern = format!("{{{}}}", i);
value = match value { value = match value {
// TODO: just use toml::Value -> json::Value
DebugArgumentValue::String(v) => { DebugArgumentValue::String(v) => {
DebugArgumentValue::String(v.replace(&pattern, &param)) DebugArgumentValue::String(v.replace(&pattern, &param))
} }
DebugArgumentValue::Array(arr) => DebugArgumentValue::Array( DebugArgumentValue::Array(arr) => DebugArgumentValue::Array(
arr.iter().map(|v| v.replace(&pattern, &param)).collect(), 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(); 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[..] { let result = match &template.request[..] {
"launch" => block_on(debugger.launch(args)), "launch" => block_on(debugger.launch(args)),
"attach" => block_on(debugger.attach(args)), "attach" => block_on(debugger.attach(args)),
@ -282,6 +293,7 @@ pub fn dap_start_impl(
return; return;
} }
}; };
log::error!("post start");
if let Err(e) = result { if let Err(e) = result {
let msg = format!("Failed {} target: {}", template.request, e); let msg = format!("Failed {} target: {}", template.request, e);
editor.set_error(msg); editor.set_error(msg);

6
languages.toml
Unescape Escape View File

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

Write Preview
Loading…
Cancel
Save