mirror of https://github.com/helix-editor/helix
Merge branch 'master' into help-command
Omnikar
3 years ago
commit
c95317a8ec
@ -0,0 +1,33 @@
|
|||||||
|
use crate::merge_toml_values;
|
||||||
|
|
||||||
|
/// Default bultin-in languages.toml.
|
||||||
|
pub fn default_lang_config() -> toml::Value {
|
||||||
|
toml::from_slice(include_bytes!("../../languages.toml"))
|
||||||
|
.expect("Could not parse bultin-in languages.toml to valid toml")
|
||||||
|
}
|
||||||
|
|
||||||
|
/// User configured languages.toml file, merged with the default config.
|
||||||
|
pub fn user_lang_config() -> Result<toml::Value, toml::de::Error> {
|
||||||
|
let def_lang_conf = default_lang_config();
|
||||||
|
let data = std::fs::read(crate::config_dir().join("languages.toml"));
|
||||||
|
let user_lang_conf = match data {
|
||||||
|
Ok(raw) => {
|
||||||
|
let value = toml::from_slice(&raw)?;
|
||||||
|
merge_toml_values(def_lang_conf, value)
|
||||||
|
}
|
||||||
|
Err(_) => def_lang_conf,
|
||||||
|
};
|
||||||
|
|
||||||
|
Ok(user_lang_conf)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Syntax configuration loader based on built-in languages.toml.
|
||||||
|
pub fn default_syntax_loader() -> crate::syntax::Configuration {
|
||||||
|
default_lang_config()
|
||||||
|
.try_into()
|
||||||
|
.expect("Could not serialize built-in language.toml")
|
||||||
|
}
|
||||||
|
/// Syntax configuration loader based on user configured languages.toml.
|
||||||
|
pub fn user_syntax_loader() -> Result<crate::syntax::Configuration, toml::de::Error> {
|
||||||
|
user_lang_config()?.try_into()
|
||||||
|
}
|
||||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,24 @@
|
|||||||
|
[package]
|
||||||
|
name = "helix-dap"
|
||||||
|
version = "0.6.0"
|
||||||
|
authors = ["Blaž Hrastnik <blaz@mxxn.io>"]
|
||||||
|
edition = "2018"
|
||||||
|
license = "MPL-2.0"
|
||||||
|
description = "DAP client implementation for Helix project"
|
||||||
|
categories = ["editor"]
|
||||||
|
repository = "https://github.com/helix-editor/helix"
|
||||||
|
homepage = "https://helix-editor.com"
|
||||||
|
|
||||||
|
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
||||||
|
|
||||||
|
[dependencies]
|
||||||
|
helix-core = { version = "0.6", path = "../helix-core" }
|
||||||
|
anyhow = "1.0"
|
||||||
|
log = "0.4"
|
||||||
|
serde = { version = "1.0", features = ["derive"] }
|
||||||
|
serde_json = "1.0"
|
||||||
|
thiserror = "1.0"
|
||||||
|
tokio = { version = "1", features = ["rt", "rt-multi-thread", "io-util", "io-std", "time", "process", "macros", "fs", "parking_lot", "net", "sync"] }
|
||||||
|
|
||||||
|
[dev-dependencies]
|
||||||
|
fern = "0.6"
|
||||||
@ -0,0 +1,477 @@
|
|||||||
|
use crate::{
|
||||||
|
transport::{Payload, Request, Response, Transport},
|
||||||
|
types::*,
|
||||||
|
Error, Result, ThreadId,
|
||||||
|
};
|
||||||
|
use helix_core::syntax::DebuggerQuirks;
|
||||||
|
|
||||||
|
use serde_json::Value;
|
||||||
|
|
||||||
|
use anyhow::anyhow;
|
||||||
|
pub use log::{error, info};
|
||||||
|
use std::{
|
||||||
|
collections::HashMap,
|
||||||
|
future::Future,
|
||||||
|
net::{IpAddr, Ipv4Addr, SocketAddr},
|
||||||
|
path::PathBuf,
|
||||||
|
process::Stdio,
|
||||||
|
sync::atomic::{AtomicU64, Ordering},
|
||||||
|
};
|
||||||
|
use tokio::{
|
||||||
|
io::{AsyncBufRead, AsyncWrite, BufReader, BufWriter},
|
||||||
|
net::TcpStream,
|
||||||
|
process::{Child, Command},
|
||||||
|
sync::mpsc::{channel, unbounded_channel, UnboundedReceiver, UnboundedSender},
|
||||||
|
time,
|
||||||
|
};
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub struct Client {
|
||||||
|
id: usize,
|
||||||
|
_process: Option<Child>,
|
||||||
|
server_tx: UnboundedSender<Payload>,
|
||||||
|
request_counter: AtomicU64,
|
||||||
|
pub caps: Option<DebuggerCapabilities>,
|
||||||
|
// thread_id -> frames
|
||||||
|
pub stack_frames: HashMap<ThreadId, Vec<StackFrame>>,
|
||||||
|
pub thread_states: HashMap<ThreadId, String>,
|
||||||
|
pub thread_id: Option<ThreadId>,
|
||||||
|
/// Currently active frame for the current thread.
|
||||||
|
pub active_frame: Option<usize>,
|
||||||
|
pub quirks: DebuggerQuirks,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Client {
|
||||||
|
// Spawn a process and communicate with it by either TCP or stdio
|
||||||
|
pub async fn process(
|
||||||
|
transport: &str,
|
||||||
|
command: &str,
|
||||||
|
args: Vec<&str>,
|
||||||
|
port_arg: Option<&str>,
|
||||||
|
id: usize,
|
||||||
|
) -> Result<(Self, UnboundedReceiver<Payload>)> {
|
||||||
|
if command.is_empty() {
|
||||||
|
return Result::Err(Error::Other(anyhow!("Command not provided")));
|
||||||
|
}
|
||||||
|
if transport == "tcp" && port_arg.is_some() {
|
||||||
|
Self::tcp_process(command, args, port_arg.unwrap(), id).await
|
||||||
|
} else if transport == "stdio" {
|
||||||
|
Self::stdio(command, args, id)
|
||||||
|
} else {
|
||||||
|
Result::Err(Error::Other(anyhow!("Incorrect transport {}", transport)))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn streams(
|
||||||
|
rx: Box<dyn AsyncBufRead + Unpin + Send>,
|
||||||
|
tx: Box<dyn AsyncWrite + Unpin + Send>,
|
||||||
|
err: Option<Box<dyn AsyncBufRead + Unpin + Send>>,
|
||||||
|
id: usize,
|
||||||
|
process: Option<Child>,
|
||||||
|
) -> Result<(Self, UnboundedReceiver<Payload>)> {
|
||||||
|
let (server_rx, server_tx) = Transport::start(rx, tx, err, id);
|
||||||
|
let (client_rx, client_tx) = unbounded_channel();
|
||||||
|
|
||||||
|
let client = Self {
|
||||||
|
id,
|
||||||
|
_process: process,
|
||||||
|
server_tx,
|
||||||
|
request_counter: AtomicU64::new(0),
|
||||||
|
caps: None,
|
||||||
|
//
|
||||||
|
stack_frames: HashMap::new(),
|
||||||
|
thread_states: HashMap::new(),
|
||||||
|
thread_id: None,
|
||||||
|
active_frame: None,
|
||||||
|
quirks: DebuggerQuirks::default(),
|
||||||
|
};
|
||||||
|
|
||||||
|
tokio::spawn(Self::recv(server_rx, client_rx));
|
||||||
|
|
||||||
|
Ok((client, client_tx))
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn tcp(
|
||||||
|
addr: std::net::SocketAddr,
|
||||||
|
id: usize,
|
||||||
|
) -> Result<(Self, UnboundedReceiver<Payload>)> {
|
||||||
|
let stream = TcpStream::connect(addr).await?;
|
||||||
|
let (rx, tx) = stream.into_split();
|
||||||
|
Self::streams(Box::new(BufReader::new(rx)), Box::new(tx), None, id, None)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn stdio(
|
||||||
|
cmd: &str,
|
||||||
|
args: Vec<&str>,
|
||||||
|
id: usize,
|
||||||
|
) -> Result<(Self, UnboundedReceiver<Payload>)> {
|
||||||
|
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 errors = process.stderr.take().map(BufReader::new);
|
||||||
|
|
||||||
|
Self::streams(
|
||||||
|
Box::new(BufReader::new(reader)),
|
||||||
|
Box::new(writer),
|
||||||
|
// errors.map(|errors| Box::new(BufReader::new(errors))),
|
||||||
|
match errors {
|
||||||
|
Some(errors) => Some(Box::new(BufReader::new(errors))),
|
||||||
|
None => None,
|
||||||
|
},
|
||||||
|
id,
|
||||||
|
Some(process),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn get_port() -> Option<u16> {
|
||||||
|
Some(
|
||||||
|
tokio::net::TcpListener::bind(SocketAddr::new(
|
||||||
|
IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)),
|
||||||
|
0,
|
||||||
|
))
|
||||||
|
.await
|
||||||
|
.ok()?
|
||||||
|
.local_addr()
|
||||||
|
.ok()?
|
||||||
|
.port(),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn tcp_process(
|
||||||
|
cmd: &str,
|
||||||
|
args: Vec<&str>,
|
||||||
|
port_format: &str,
|
||||||
|
id: usize,
|
||||||
|
) -> Result<(Self, UnboundedReceiver<Payload>)> {
|
||||||
|
let port = Self::get_port().await.unwrap();
|
||||||
|
|
||||||
|
let process = Command::new(cmd)
|
||||||
|
.args(args)
|
||||||
|
.args(port_format.replace("{}", &port.to_string()).split(' '))
|
||||||
|
// silence messages
|
||||||
|
.stdin(Stdio::null())
|
||||||
|
.stdout(Stdio::null())
|
||||||
|
.stderr(Stdio::null())
|
||||||
|
// Do not kill debug adapter when leaving, it should exit automatically
|
||||||
|
.spawn()?;
|
||||||
|
|
||||||
|
// Wait for adapter to become ready for connection
|
||||||
|
time::sleep(time::Duration::from_millis(500)).await;
|
||||||
|
|
||||||
|
let stream = TcpStream::connect(SocketAddr::new(
|
||||||
|
IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)),
|
||||||
|
port,
|
||||||
|
))
|
||||||
|
.await?;
|
||||||
|
|
||||||
|
let (rx, tx) = stream.into_split();
|
||||||
|
Self::streams(
|
||||||
|
Box::new(BufReader::new(rx)),
|
||||||
|
Box::new(tx),
|
||||||
|
None,
|
||||||
|
id,
|
||||||
|
Some(process),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn recv(mut server_rx: UnboundedReceiver<Payload>, client_tx: UnboundedSender<Payload>) {
|
||||||
|
while let Some(msg) = server_rx.recv().await {
|
||||||
|
match msg {
|
||||||
|
Payload::Event(ev) => {
|
||||||
|
client_tx.send(Payload::Event(ev)).expect("Failed to send");
|
||||||
|
}
|
||||||
|
Payload::Response(_) => unreachable!(),
|
||||||
|
Payload::Request(req) => {
|
||||||
|
client_tx
|
||||||
|
.send(Payload::Request(req))
|
||||||
|
.expect("Failed to send");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn id(&self) -> usize {
|
||||||
|
self.id
|
||||||
|
}
|
||||||
|
|
||||||
|
fn next_request_id(&self) -> u64 {
|
||||||
|
self.request_counter.fetch_add(1, Ordering::Relaxed)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Internal, called by specific DAP commands when resuming
|
||||||
|
pub fn resume_application(&mut self) {
|
||||||
|
if let Some(thread_id) = self.thread_id {
|
||||||
|
self.thread_states.insert(thread_id, "running".to_string());
|
||||||
|
self.stack_frames.remove(&thread_id);
|
||||||
|
}
|
||||||
|
self.active_frame = None;
|
||||||
|
self.thread_id = None;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Execute a RPC request on the debugger.
|
||||||
|
pub fn call<R: crate::types::Request>(
|
||||||
|
&self,
|
||||||
|
arguments: R::Arguments,
|
||||||
|
) -> impl Future<Output = Result<Value>>
|
||||||
|
where
|
||||||
|
R::Arguments: serde::Serialize,
|
||||||
|
{
|
||||||
|
let server_tx = self.server_tx.clone();
|
||||||
|
let id = self.next_request_id();
|
||||||
|
|
||||||
|
async move {
|
||||||
|
use std::time::Duration;
|
||||||
|
use tokio::time::timeout;
|
||||||
|
|
||||||
|
let arguments = Some(serde_json::to_value(arguments)?);
|
||||||
|
|
||||||
|
let (callback_tx, mut callback_rx) = channel(1);
|
||||||
|
|
||||||
|
let req = Request {
|
||||||
|
back_ch: Some(callback_tx),
|
||||||
|
seq: id,
|
||||||
|
command: R::COMMAND.to_string(),
|
||||||
|
arguments,
|
||||||
|
};
|
||||||
|
|
||||||
|
server_tx
|
||||||
|
.send(Payload::Request(req))
|
||||||
|
.map_err(|e| Error::Other(e.into()))?;
|
||||||
|
|
||||||
|
// TODO: specifiable timeout, delay other calls until initialize success
|
||||||
|
timeout(Duration::from_secs(20), callback_rx.recv())
|
||||||
|
.await
|
||||||
|
.map_err(|_| Error::Timeout)? // return Timeout
|
||||||
|
.ok_or(Error::StreamClosed)?
|
||||||
|
.map(|response| response.body.unwrap_or_default())
|
||||||
|
// TODO: check response.success
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn request<R: crate::types::Request>(&self, params: R::Arguments) -> Result<R::Result>
|
||||||
|
where
|
||||||
|
R::Arguments: serde::Serialize,
|
||||||
|
R::Result: core::fmt::Debug, // TODO: temporary
|
||||||
|
{
|
||||||
|
// a future that resolves into the response
|
||||||
|
let json = self.call::<R>(params).await?;
|
||||||
|
let response = serde_json::from_value(json)?;
|
||||||
|
Ok(response)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn reply(
|
||||||
|
&self,
|
||||||
|
request_seq: u64,
|
||||||
|
command: &str,
|
||||||
|
result: core::result::Result<Value, Error>,
|
||||||
|
) -> impl Future<Output = Result<()>> {
|
||||||
|
let server_tx = self.server_tx.clone();
|
||||||
|
let command = command.to_string();
|
||||||
|
|
||||||
|
async move {
|
||||||
|
let response = match result {
|
||||||
|
Ok(result) => Response {
|
||||||
|
request_seq,
|
||||||
|
command,
|
||||||
|
success: true,
|
||||||
|
message: None,
|
||||||
|
body: Some(result),
|
||||||
|
},
|
||||||
|
Err(error) => Response {
|
||||||
|
request_seq,
|
||||||
|
command,
|
||||||
|
success: false,
|
||||||
|
message: Some(error.to_string()),
|
||||||
|
body: None,
|
||||||
|
},
|
||||||
|
};
|
||||||
|
|
||||||
|
server_tx
|
||||||
|
.send(Payload::Response(response))
|
||||||
|
.map_err(|e| Error::Other(e.into()))?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn capabilities(&self) -> &DebuggerCapabilities {
|
||||||
|
self.caps.as_ref().expect("debugger not yet initialized!")
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn initialize(&mut self, adapter_id: String) -> Result<()> {
|
||||||
|
let args = requests::InitializeArguments {
|
||||||
|
client_id: Some("hx".to_owned()),
|
||||||
|
client_name: Some("helix".to_owned()),
|
||||||
|
adapter_id,
|
||||||
|
locale: Some("en-us".to_owned()),
|
||||||
|
lines_start_at_one: Some(true),
|
||||||
|
columns_start_at_one: Some(true),
|
||||||
|
path_format: Some("path".to_owned()),
|
||||||
|
supports_variable_type: Some(true),
|
||||||
|
supports_variable_paging: Some(false),
|
||||||
|
supports_run_in_terminal_request: Some(true),
|
||||||
|
supports_memory_references: Some(false),
|
||||||
|
supports_progress_reporting: Some(false),
|
||||||
|
supports_invalidated_event: Some(false),
|
||||||
|
};
|
||||||
|
|
||||||
|
let response = self.request::<requests::Initialize>(args).await?;
|
||||||
|
self.caps = Some(response);
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn disconnect(&self) -> impl Future<Output = Result<Value>> {
|
||||||
|
self.call::<requests::Disconnect>(())
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn launch(&self, args: serde_json::Value) -> impl Future<Output = Result<Value>> {
|
||||||
|
self.call::<requests::Launch>(args)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn attach(&self, args: serde_json::Value) -> impl Future<Output = Result<Value>> {
|
||||||
|
self.call::<requests::Attach>(args)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn set_breakpoints(
|
||||||
|
&self,
|
||||||
|
file: PathBuf,
|
||||||
|
breakpoints: Vec<SourceBreakpoint>,
|
||||||
|
) -> Result<Option<Vec<Breakpoint>>> {
|
||||||
|
let args = requests::SetBreakpointsArguments {
|
||||||
|
source: Source {
|
||||||
|
path: Some(file),
|
||||||
|
name: None,
|
||||||
|
source_reference: None,
|
||||||
|
presentation_hint: None,
|
||||||
|
origin: None,
|
||||||
|
sources: None,
|
||||||
|
adapter_data: None,
|
||||||
|
checksums: None,
|
||||||
|
},
|
||||||
|
breakpoints: Some(breakpoints),
|
||||||
|
source_modified: Some(false),
|
||||||
|
};
|
||||||
|
|
||||||
|
let response = self.request::<requests::SetBreakpoints>(args).await?;
|
||||||
|
|
||||||
|
Ok(response.breakpoints)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn configuration_done(&self) -> Result<()> {
|
||||||
|
self.request::<requests::ConfigurationDone>(()).await
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn continue_thread(&self, thread_id: ThreadId) -> impl Future<Output = Result<Value>> {
|
||||||
|
let args = requests::ContinueArguments { thread_id };
|
||||||
|
|
||||||
|
self.call::<requests::Continue>(args)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn stack_trace(
|
||||||
|
&self,
|
||||||
|
thread_id: ThreadId,
|
||||||
|
) -> Result<(Vec<StackFrame>, Option<usize>)> {
|
||||||
|
let args = requests::StackTraceArguments {
|
||||||
|
thread_id,
|
||||||
|
start_frame: None,
|
||||||
|
levels: None,
|
||||||
|
format: None,
|
||||||
|
};
|
||||||
|
|
||||||
|
let response = self.request::<requests::StackTrace>(args).await?;
|
||||||
|
Ok((response.stack_frames, response.total_frames))
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn threads(&self) -> impl Future<Output = Result<Value>> {
|
||||||
|
self.call::<requests::Threads>(())
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn scopes(&self, frame_id: usize) -> Result<Vec<Scope>> {
|
||||||
|
let args = requests::ScopesArguments { frame_id };
|
||||||
|
|
||||||
|
let response = self.request::<requests::Scopes>(args).await?;
|
||||||
|
Ok(response.scopes)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn variables(&self, variables_reference: usize) -> Result<Vec<Variable>> {
|
||||||
|
let args = requests::VariablesArguments {
|
||||||
|
variables_reference,
|
||||||
|
filter: None,
|
||||||
|
start: None,
|
||||||
|
count: None,
|
||||||
|
format: None,
|
||||||
|
};
|
||||||
|
|
||||||
|
let response = self.request::<requests::Variables>(args).await?;
|
||||||
|
Ok(response.variables)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn step_in(&self, thread_id: ThreadId) -> impl Future<Output = Result<Value>> {
|
||||||
|
let args = requests::StepInArguments {
|
||||||
|
thread_id,
|
||||||
|
target_id: None,
|
||||||
|
granularity: None,
|
||||||
|
};
|
||||||
|
|
||||||
|
self.call::<requests::StepIn>(args)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn step_out(&self, thread_id: ThreadId) -> impl Future<Output = Result<Value>> {
|
||||||
|
let args = requests::StepOutArguments {
|
||||||
|
thread_id,
|
||||||
|
granularity: None,
|
||||||
|
};
|
||||||
|
|
||||||
|
self.call::<requests::StepOut>(args)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn next(&self, thread_id: ThreadId) -> impl Future<Output = Result<Value>> {
|
||||||
|
let args = requests::NextArguments {
|
||||||
|
thread_id,
|
||||||
|
granularity: None,
|
||||||
|
};
|
||||||
|
|
||||||
|
self.call::<requests::Next>(args)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn pause(&self, thread_id: ThreadId) -> impl Future<Output = Result<Value>> {
|
||||||
|
let args = requests::PauseArguments { thread_id };
|
||||||
|
|
||||||
|
self.call::<requests::Pause>(args)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn eval(
|
||||||
|
&self,
|
||||||
|
expression: String,
|
||||||
|
frame_id: Option<usize>,
|
||||||
|
) -> Result<requests::EvaluateResponse> {
|
||||||
|
let args = requests::EvaluateArguments {
|
||||||
|
expression,
|
||||||
|
frame_id,
|
||||||
|
context: None,
|
||||||
|
format: None,
|
||||||
|
};
|
||||||
|
|
||||||
|
self.request::<requests::Evaluate>(args).await
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn set_exception_breakpoints(
|
||||||
|
&self,
|
||||||
|
filters: Vec<String>,
|
||||||
|
) -> impl Future<Output = Result<Value>> {
|
||||||
|
let args = requests::SetExceptionBreakpointsArguments { filters };
|
||||||
|
|
||||||
|
self.call::<requests::SetExceptionBreakpoints>(args)
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,24 @@
|
|||||||
|
mod client;
|
||||||
|
mod transport;
|
||||||
|
mod types;
|
||||||
|
|
||||||
|
pub use client::Client;
|
||||||
|
pub use events::Event;
|
||||||
|
pub use transport::{Payload, Response, Transport};
|
||||||
|
pub use types::*;
|
||||||
|
|
||||||
|
use thiserror::Error;
|
||||||
|
#[derive(Error, Debug)]
|
||||||
|
pub enum Error {
|
||||||
|
#[error("failed to parse: {0}")]
|
||||||
|
Parse(#[from] serde_json::Error),
|
||||||
|
#[error("IO Error: {0}")]
|
||||||
|
IO(#[from] std::io::Error),
|
||||||
|
#[error("request timed out")]
|
||||||
|
Timeout,
|
||||||
|
#[error("server closed the stream")]
|
||||||
|
StreamClosed,
|
||||||
|
#[error(transparent)]
|
||||||
|
Other(#[from] anyhow::Error),
|
||||||
|
}
|
||||||
|
pub type Result<T> = core::result::Result<T, Error>;
|
||||||
@ -0,0 +1,280 @@
|
|||||||
|
use crate::{Error, Event, Result};
|
||||||
|
use anyhow::Context;
|
||||||
|
use log::{error, info, warn};
|
||||||
|
use serde::{Deserialize, Serialize};
|
||||||
|
use serde_json::Value;
|
||||||
|
use std::collections::HashMap;
|
||||||
|
use std::sync::Arc;
|
||||||
|
use tokio::{
|
||||||
|
io::{AsyncBufRead, AsyncBufReadExt, AsyncReadExt, AsyncWrite, AsyncWriteExt},
|
||||||
|
sync::{
|
||||||
|
mpsc::{unbounded_channel, Sender, UnboundedReceiver, UnboundedSender},
|
||||||
|
Mutex,
|
||||||
|
},
|
||||||
|
};
|
||||||
|
|
||||||
|
#[derive(Debug, Clone, Deserialize, Serialize)]
|
||||||
|
pub struct Request {
|
||||||
|
#[serde(skip)]
|
||||||
|
pub back_ch: Option<Sender<Result<Response>>>,
|
||||||
|
pub seq: u64,
|
||||||
|
pub command: String,
|
||||||
|
pub arguments: Option<Value>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
pub struct Response {
|
||||||
|
// seq is omitted as unused and is not sent by some implementations
|
||||||
|
pub request_seq: u64,
|
||||||
|
pub success: bool,
|
||||||
|
pub command: String,
|
||||||
|
pub message: Option<String>,
|
||||||
|
pub body: Option<Value>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(tag = "type", rename_all = "camelCase")]
|
||||||
|
pub enum Payload {
|
||||||
|
// type = "event"
|
||||||
|
Event(Box<Event>),
|
||||||
|
// type = "response"
|
||||||
|
Response(Response),
|
||||||
|
// type = "request"
|
||||||
|
Request(Request),
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub struct Transport {
|
||||||
|
#[allow(unused)]
|
||||||
|
id: usize,
|
||||||
|
pending_requests: Mutex<HashMap<u64, Sender<Result<Response>>>>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Transport {
|
||||||
|
pub fn start(
|
||||||
|
server_stdout: Box<dyn AsyncBufRead + Unpin + Send>,
|
||||||
|
server_stdin: Box<dyn AsyncWrite + Unpin + Send>,
|
||||||
|
server_stderr: Option<Box<dyn AsyncBufRead + Unpin + Send>>,
|
||||||
|
id: usize,
|
||||||
|
) -> (UnboundedReceiver<Payload>, UnboundedSender<Payload>) {
|
||||||
|
let (client_tx, rx) = unbounded_channel();
|
||||||
|
let (tx, client_rx) = unbounded_channel();
|
||||||
|
|
||||||
|
let transport = Self {
|
||||||
|
id,
|
||||||
|
pending_requests: Mutex::new(HashMap::default()),
|
||||||
|
};
|
||||||
|
|
||||||
|
let transport = Arc::new(transport);
|
||||||
|
|
||||||
|
tokio::spawn(Self::recv(transport.clone(), server_stdout, client_tx));
|
||||||
|
tokio::spawn(Self::send(transport, server_stdin, client_rx));
|
||||||
|
if let Some(stderr) = server_stderr {
|
||||||
|
tokio::spawn(Self::err(stderr));
|
||||||
|
}
|
||||||
|
|
||||||
|
(rx, tx)
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn recv_server_message(
|
||||||
|
reader: &mut Box<dyn AsyncBufRead + Unpin + Send>,
|
||||||
|
buffer: &mut String,
|
||||||
|
) -> Result<Payload> {
|
||||||
|
let mut content_length = None;
|
||||||
|
loop {
|
||||||
|
buffer.truncate(0);
|
||||||
|
if reader.read_line(buffer).await? == 0 {
|
||||||
|
return Err(Error::StreamClosed);
|
||||||
|
};
|
||||||
|
|
||||||
|
if buffer == "\r\n" {
|
||||||
|
// look for an empty CRLF line
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
let header = buffer.trim();
|
||||||
|
let parts = header.split_once(": ");
|
||||||
|
|
||||||
|
match parts {
|
||||||
|
Some(("Content-Length", value)) => {
|
||||||
|
content_length = Some(value.parse().context("invalid content length")?);
|
||||||
|
}
|
||||||
|
Some((_, _)) => {}
|
||||||
|
None => {
|
||||||
|
// Workaround: Some non-conformant language servers will output logging and other garbage
|
||||||
|
// into the same stream as JSON-RPC messages. This can also happen from shell scripts that spawn
|
||||||
|
// the server. Skip such lines and log a warning.
|
||||||
|
|
||||||
|
// warn!("Failed to parse header: {:?}", header);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
let content_length = content_length.context("missing content length")?;
|
||||||
|
|
||||||
|
//TODO: reuse vector
|
||||||
|
let mut content = vec![0; content_length];
|
||||||
|
reader.read_exact(&mut content).await?;
|
||||||
|
let msg = std::str::from_utf8(&content).context("invalid utf8 from server")?;
|
||||||
|
|
||||||
|
info!("<- DAP {}", msg);
|
||||||
|
|
||||||
|
// try parsing as output (server response) or call (server request)
|
||||||
|
let output: serde_json::Result<Payload> = serde_json::from_str(msg);
|
||||||
|
|
||||||
|
Ok(output?)
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn recv_server_error(
|
||||||
|
err: &mut (impl AsyncBufRead + Unpin + Send),
|
||||||
|
buffer: &mut String,
|
||||||
|
) -> Result<()> {
|
||||||
|
buffer.truncate(0);
|
||||||
|
if err.read_line(buffer).await? == 0 {
|
||||||
|
return Err(Error::StreamClosed);
|
||||||
|
};
|
||||||
|
error!("err <- {}", buffer);
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn send_payload_to_server(
|
||||||
|
&self,
|
||||||
|
server_stdin: &mut Box<dyn AsyncWrite + Unpin + Send>,
|
||||||
|
mut payload: Payload,
|
||||||
|
) -> Result<()> {
|
||||||
|
if let Payload::Request(request) = &mut payload {
|
||||||
|
if let Some(back) = request.back_ch.take() {
|
||||||
|
self.pending_requests.lock().await.insert(request.seq, back);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
let json = serde_json::to_string(&payload)?;
|
||||||
|
self.send_string_to_server(server_stdin, json).await
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn send_string_to_server(
|
||||||
|
&self,
|
||||||
|
server_stdin: &mut Box<dyn AsyncWrite + Unpin + Send>,
|
||||||
|
request: String,
|
||||||
|
) -> Result<()> {
|
||||||
|
info!("-> DAP {}", request);
|
||||||
|
|
||||||
|
// send the headers
|
||||||
|
server_stdin
|
||||||
|
.write_all(format!("Content-Length: {}\r\n\r\n", request.len()).as_bytes())
|
||||||
|
.await?;
|
||||||
|
|
||||||
|
// send the body
|
||||||
|
server_stdin.write_all(request.as_bytes()).await?;
|
||||||
|
|
||||||
|
server_stdin.flush().await?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn process_response(res: Response) -> Result<Response> {
|
||||||
|
if res.success {
|
||||||
|
info!("<- DAP success in response to {}", res.request_seq);
|
||||||
|
|
||||||
|
Ok(res)
|
||||||
|
} else {
|
||||||
|
error!(
|
||||||
|
"<- DAP error {:?} ({:?}) for command #{} {}",
|
||||||
|
res.message, res.body, res.request_seq, res.command
|
||||||
|
);
|
||||||
|
|
||||||
|
Err(Error::Other(anyhow::format_err!("{:?}", res.body)))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn process_server_message(
|
||||||
|
&self,
|
||||||
|
client_tx: &UnboundedSender<Payload>,
|
||||||
|
msg: Payload,
|
||||||
|
) -> Result<()> {
|
||||||
|
match msg {
|
||||||
|
Payload::Response(res) => {
|
||||||
|
let request_seq = res.request_seq;
|
||||||
|
let tx = self.pending_requests.lock().await.remove(&request_seq);
|
||||||
|
|
||||||
|
match tx {
|
||||||
|
Some(tx) => match tx.send(Self::process_response(res)).await {
|
||||||
|
Ok(_) => (),
|
||||||
|
Err(_) => error!(
|
||||||
|
"Tried sending response into a closed channel (id={:?}), original request likely timed out",
|
||||||
|
request_seq
|
||||||
|
),
|
||||||
|
}
|
||||||
|
None => {
|
||||||
|
warn!("Response to nonexistent request #{}", res.request_seq);
|
||||||
|
client_tx.send(Payload::Response(res)).expect("Failed to send");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
Payload::Request(Request {
|
||||||
|
ref command,
|
||||||
|
ref seq,
|
||||||
|
..
|
||||||
|
}) => {
|
||||||
|
info!("<- DAP request {} #{}", command, seq);
|
||||||
|
client_tx.send(msg).expect("Failed to send");
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
Payload::Event(ref event) => {
|
||||||
|
info!("<- DAP event {:?}", event);
|
||||||
|
client_tx.send(msg).expect("Failed to send");
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn recv(
|
||||||
|
transport: Arc<Self>,
|
||||||
|
mut server_stdout: Box<dyn AsyncBufRead + Unpin + Send>,
|
||||||
|
client_tx: UnboundedSender<Payload>,
|
||||||
|
) {
|
||||||
|
let mut recv_buffer = String::new();
|
||||||
|
loop {
|
||||||
|
match Self::recv_server_message(&mut server_stdout, &mut recv_buffer).await {
|
||||||
|
Ok(msg) => {
|
||||||
|
transport
|
||||||
|
.process_server_message(&client_tx, msg)
|
||||||
|
.await
|
||||||
|
.unwrap();
|
||||||
|
}
|
||||||
|
Err(err) => {
|
||||||
|
error!("err: <- {:?}", err);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn send(
|
||||||
|
transport: Arc<Self>,
|
||||||
|
mut server_stdin: Box<dyn AsyncWrite + Unpin + Send>,
|
||||||
|
mut client_rx: UnboundedReceiver<Payload>,
|
||||||
|
) {
|
||||||
|
while let Some(payload) = client_rx.recv().await {
|
||||||
|
transport
|
||||||
|
.send_payload_to_server(&mut server_stdin, payload)
|
||||||
|
.await
|
||||||
|
.unwrap()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn err(mut server_stderr: Box<dyn AsyncBufRead + Unpin + Send>) {
|
||||||
|
let mut recv_buffer = String::new();
|
||||||
|
loop {
|
||||||
|
match Self::recv_server_error(&mut server_stderr, &mut recv_buffer).await {
|
||||||
|
Ok(_) => {}
|
||||||
|
Err(err) => {
|
||||||
|
error!("err: <- {:?}", err);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,707 @@
|
|||||||
|
use serde::{Deserialize, Serialize};
|
||||||
|
use serde_json::Value;
|
||||||
|
use std::collections::HashMap;
|
||||||
|
use std::path::PathBuf;
|
||||||
|
|
||||||
|
#[derive(
|
||||||
|
Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Deserialize, Serialize,
|
||||||
|
)]
|
||||||
|
pub struct ThreadId(isize);
|
||||||
|
|
||||||
|
impl std::fmt::Display for ThreadId {
|
||||||
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||||
|
self.0.fmt(f)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub trait Request {
|
||||||
|
type Arguments: serde::de::DeserializeOwned + serde::Serialize;
|
||||||
|
type Result: serde::de::DeserializeOwned + serde::Serialize;
|
||||||
|
const COMMAND: &'static str;
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct ColumnDescriptor {
|
||||||
|
pub attribute_name: String,
|
||||||
|
pub label: String,
|
||||||
|
pub format: Option<String>,
|
||||||
|
#[serde(rename = "type")]
|
||||||
|
pub ty: Option<String>,
|
||||||
|
pub width: Option<usize>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct ExceptionBreakpointsFilter {
|
||||||
|
pub filter: String,
|
||||||
|
pub label: String,
|
||||||
|
pub description: Option<String>,
|
||||||
|
pub default: Option<bool>,
|
||||||
|
pub supports_condition: Option<bool>,
|
||||||
|
pub condition_description: Option<String>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct DebuggerCapabilities {
|
||||||
|
pub supports_configuration_done_request: Option<bool>,
|
||||||
|
pub supports_function_breakpoints: Option<bool>,
|
||||||
|
pub supports_conditional_breakpoints: Option<bool>,
|
||||||
|
pub supports_hit_conditional_breakpoints: Option<bool>,
|
||||||
|
pub supports_evaluate_for_hovers: Option<bool>,
|
||||||
|
pub supports_step_back: Option<bool>,
|
||||||
|
pub supports_set_variable: Option<bool>,
|
||||||
|
pub supports_restart_frame: Option<bool>,
|
||||||
|
pub supports_goto_targets_request: Option<bool>,
|
||||||
|
pub supports_step_in_targets_request: Option<bool>,
|
||||||
|
pub supports_completions_request: Option<bool>,
|
||||||
|
pub supports_modules_request: Option<bool>,
|
||||||
|
pub supports_restart_request: Option<bool>,
|
||||||
|
pub supports_exception_options: Option<bool>,
|
||||||
|
pub supports_value_formatting_options: Option<bool>,
|
||||||
|
pub supports_exception_info_request: Option<bool>,
|
||||||
|
pub support_terminate_debuggee: Option<bool>,
|
||||||
|
pub support_suspend_debuggee: Option<bool>,
|
||||||
|
pub supports_delayed_stack_trace_loading: Option<bool>,
|
||||||
|
pub supports_loaded_sources_request: Option<bool>,
|
||||||
|
pub supports_log_points: Option<bool>,
|
||||||
|
pub supports_terminate_threads_request: Option<bool>,
|
||||||
|
pub supports_set_expression: Option<bool>,
|
||||||
|
pub supports_terminate_request: Option<bool>,
|
||||||
|
pub supports_data_breakpoints: Option<bool>,
|
||||||
|
pub supports_read_memory_request: Option<bool>,
|
||||||
|
pub supports_write_memory_request: Option<bool>,
|
||||||
|
pub supports_disassemble_request: Option<bool>,
|
||||||
|
pub supports_cancel_request: Option<bool>,
|
||||||
|
pub supports_breakpoint_locations_request: Option<bool>,
|
||||||
|
pub supports_clipboard_context: Option<bool>,
|
||||||
|
pub supports_stepping_granularity: Option<bool>,
|
||||||
|
pub supports_instruction_breakpoints: Option<bool>,
|
||||||
|
pub supports_exception_filter_options: Option<bool>,
|
||||||
|
pub exception_breakpoint_filters: Option<Vec<ExceptionBreakpointsFilter>>,
|
||||||
|
pub completion_trigger_characters: Option<Vec<String>>,
|
||||||
|
pub additional_module_columns: Option<Vec<ColumnDescriptor>>,
|
||||||
|
pub supported_checksum_algorithms: Option<Vec<String>>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct Checksum {
|
||||||
|
pub algorithm: String,
|
||||||
|
pub checksum: String,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, Default, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct Source {
|
||||||
|
pub name: Option<String>,
|
||||||
|
pub path: Option<PathBuf>,
|
||||||
|
pub source_reference: Option<usize>,
|
||||||
|
pub presentation_hint: Option<String>,
|
||||||
|
pub origin: Option<String>,
|
||||||
|
pub sources: Option<Vec<Source>>,
|
||||||
|
pub adapter_data: Option<Value>,
|
||||||
|
pub checksums: Option<Vec<Checksum>>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, Default, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct SourceBreakpoint {
|
||||||
|
pub line: usize,
|
||||||
|
pub column: Option<usize>,
|
||||||
|
pub condition: Option<String>,
|
||||||
|
pub hit_condition: Option<String>,
|
||||||
|
pub log_message: Option<String>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[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")]
|
||||||
|
pub struct StackFrameFormat {
|
||||||
|
pub parameters: Option<bool>,
|
||||||
|
pub parameter_types: Option<bool>,
|
||||||
|
pub parameter_names: Option<bool>,
|
||||||
|
pub parameter_values: Option<bool>,
|
||||||
|
pub line: Option<bool>,
|
||||||
|
pub module: Option<bool>,
|
||||||
|
pub include_all: Option<bool>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct StackFrame {
|
||||||
|
pub id: usize,
|
||||||
|
pub name: String,
|
||||||
|
pub source: Option<Source>,
|
||||||
|
pub line: usize,
|
||||||
|
pub column: usize,
|
||||||
|
pub end_line: Option<usize>,
|
||||||
|
pub end_column: Option<usize>,
|
||||||
|
pub can_restart: Option<bool>,
|
||||||
|
pub instruction_pointer_reference: Option<String>,
|
||||||
|
pub module_id: Option<Value>,
|
||||||
|
pub presentation_hint: Option<String>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct Thread {
|
||||||
|
pub id: ThreadId,
|
||||||
|
pub name: String,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct Scope {
|
||||||
|
pub name: String,
|
||||||
|
pub presentation_hint: Option<String>,
|
||||||
|
pub variables_reference: usize,
|
||||||
|
pub named_variables: Option<usize>,
|
||||||
|
pub indexed_variables: Option<usize>,
|
||||||
|
pub expensive: bool,
|
||||||
|
pub source: Option<Source>,
|
||||||
|
pub line: Option<usize>,
|
||||||
|
pub column: Option<usize>,
|
||||||
|
pub end_line: Option<usize>,
|
||||||
|
pub end_column: Option<usize>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct ValueFormat {
|
||||||
|
pub hex: Option<bool>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct VariablePresentationHint {
|
||||||
|
pub kind: Option<String>,
|
||||||
|
pub attributes: Option<Vec<String>>,
|
||||||
|
pub visibility: Option<String>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct Variable {
|
||||||
|
pub name: String,
|
||||||
|
pub value: String,
|
||||||
|
#[serde(rename = "type")]
|
||||||
|
pub ty: Option<String>,
|
||||||
|
pub presentation_hint: Option<VariablePresentationHint>,
|
||||||
|
pub evaluate_name: Option<String>,
|
||||||
|
pub variables_reference: usize,
|
||||||
|
pub named_variables: Option<usize>,
|
||||||
|
pub indexed_variables: Option<usize>,
|
||||||
|
pub memory_reference: Option<String>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct Module {
|
||||||
|
pub id: String, // TODO: || number
|
||||||
|
pub name: String,
|
||||||
|
pub path: Option<PathBuf>,
|
||||||
|
pub is_optimized: Option<bool>,
|
||||||
|
pub is_user_code: Option<bool>,
|
||||||
|
pub version: Option<String>,
|
||||||
|
pub symbol_status: Option<String>,
|
||||||
|
pub symbol_file_path: Option<String>,
|
||||||
|
pub date_time_stamp: Option<String>,
|
||||||
|
pub address_range: Option<String>,
|
||||||
|
}
|
||||||
|
|
||||||
|
pub mod requests {
|
||||||
|
use super::*;
|
||||||
|
#[derive(Debug, Default, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct InitializeArguments {
|
||||||
|
#[serde(rename = "clientID")]
|
||||||
|
pub client_id: Option<String>,
|
||||||
|
pub client_name: Option<String>,
|
||||||
|
#[serde(rename = "adapterID")]
|
||||||
|
pub adapter_id: String,
|
||||||
|
pub locale: Option<String>,
|
||||||
|
#[serde(rename = "linesStartAt1")]
|
||||||
|
pub lines_start_at_one: Option<bool>,
|
||||||
|
#[serde(rename = "columnsStartAt1")]
|
||||||
|
pub columns_start_at_one: Option<bool>,
|
||||||
|
pub path_format: Option<String>,
|
||||||
|
pub supports_variable_type: Option<bool>,
|
||||||
|
pub supports_variable_paging: Option<bool>,
|
||||||
|
pub supports_run_in_terminal_request: Option<bool>,
|
||||||
|
pub supports_memory_references: Option<bool>,
|
||||||
|
pub supports_progress_reporting: Option<bool>,
|
||||||
|
pub supports_invalidated_event: Option<bool>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum Initialize {}
|
||||||
|
|
||||||
|
impl Request for Initialize {
|
||||||
|
type Arguments = InitializeArguments;
|
||||||
|
type Result = DebuggerCapabilities;
|
||||||
|
const COMMAND: &'static str = "initialize";
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum Launch {}
|
||||||
|
|
||||||
|
impl Request for Launch {
|
||||||
|
type Arguments = Value;
|
||||||
|
type Result = Value;
|
||||||
|
const COMMAND: &'static str = "launch";
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum Attach {}
|
||||||
|
|
||||||
|
impl Request for Attach {
|
||||||
|
type Arguments = Value;
|
||||||
|
type Result = Value;
|
||||||
|
const COMMAND: &'static str = "attach";
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum Disconnect {}
|
||||||
|
|
||||||
|
impl Request for Disconnect {
|
||||||
|
type Arguments = ();
|
||||||
|
type Result = ();
|
||||||
|
const COMMAND: &'static str = "disconnect";
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum ConfigurationDone {}
|
||||||
|
|
||||||
|
impl Request for ConfigurationDone {
|
||||||
|
type Arguments = ();
|
||||||
|
type Result = ();
|
||||||
|
const COMMAND: &'static str = "configurationDone";
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, Default, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct SetBreakpointsArguments {
|
||||||
|
pub source: Source,
|
||||||
|
pub breakpoints: Option<Vec<SourceBreakpoint>>,
|
||||||
|
// lines is deprecated
|
||||||
|
pub source_modified: Option<bool>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, Default, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct SetBreakpointsResponse {
|
||||||
|
pub breakpoints: Option<Vec<Breakpoint>>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum SetBreakpoints {}
|
||||||
|
|
||||||
|
impl Request for SetBreakpoints {
|
||||||
|
type Arguments = SetBreakpointsArguments;
|
||||||
|
type Result = SetBreakpointsResponse;
|
||||||
|
const COMMAND: &'static str = "setBreakpoints";
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, Default, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct ContinueArguments {
|
||||||
|
pub thread_id: ThreadId,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct ContinueResponse {
|
||||||
|
pub all_threads_continued: Option<bool>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum Continue {}
|
||||||
|
|
||||||
|
impl Request for Continue {
|
||||||
|
type Arguments = ContinueArguments;
|
||||||
|
type Result = ContinueResponse;
|
||||||
|
const COMMAND: &'static str = "continue";
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, Default, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct StackTraceArguments {
|
||||||
|
pub thread_id: ThreadId,
|
||||||
|
pub start_frame: Option<usize>,
|
||||||
|
pub levels: Option<usize>,
|
||||||
|
pub format: Option<StackFrameFormat>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct StackTraceResponse {
|
||||||
|
pub total_frames: Option<usize>,
|
||||||
|
pub stack_frames: Vec<StackFrame>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum StackTrace {}
|
||||||
|
|
||||||
|
impl Request for StackTrace {
|
||||||
|
type Arguments = StackTraceArguments;
|
||||||
|
type Result = StackTraceResponse;
|
||||||
|
const COMMAND: &'static str = "stackTrace";
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct ThreadsResponse {
|
||||||
|
pub threads: Vec<Thread>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum Threads {}
|
||||||
|
|
||||||
|
impl Request for Threads {
|
||||||
|
type Arguments = ();
|
||||||
|
type Result = ThreadsResponse;
|
||||||
|
const COMMAND: &'static str = "threads";
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct ScopesArguments {
|
||||||
|
pub frame_id: usize,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct ScopesResponse {
|
||||||
|
pub scopes: Vec<Scope>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum Scopes {}
|
||||||
|
|
||||||
|
impl Request for Scopes {
|
||||||
|
type Arguments = ScopesArguments;
|
||||||
|
type Result = ScopesResponse;
|
||||||
|
const COMMAND: &'static str = "scopes";
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, Default, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct VariablesArguments {
|
||||||
|
pub variables_reference: usize,
|
||||||
|
pub filter: Option<String>,
|
||||||
|
pub start: Option<usize>,
|
||||||
|
pub count: Option<usize>,
|
||||||
|
pub format: Option<ValueFormat>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct VariablesResponse {
|
||||||
|
pub variables: Vec<Variable>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum Variables {}
|
||||||
|
|
||||||
|
impl Request for Variables {
|
||||||
|
type Arguments = VariablesArguments;
|
||||||
|
type Result = VariablesResponse;
|
||||||
|
const COMMAND: &'static str = "variables";
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct StepInArguments {
|
||||||
|
pub thread_id: ThreadId,
|
||||||
|
pub target_id: Option<usize>,
|
||||||
|
pub granularity: Option<String>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum StepIn {}
|
||||||
|
|
||||||
|
impl Request for StepIn {
|
||||||
|
type Arguments = StepInArguments;
|
||||||
|
type Result = ();
|
||||||
|
const COMMAND: &'static str = "stepIn";
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct StepOutArguments {
|
||||||
|
pub thread_id: ThreadId,
|
||||||
|
pub granularity: Option<String>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum StepOut {}
|
||||||
|
|
||||||
|
impl Request for StepOut {
|
||||||
|
type Arguments = StepOutArguments;
|
||||||
|
type Result = ();
|
||||||
|
const COMMAND: &'static str = "stepOut";
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct NextArguments {
|
||||||
|
pub thread_id: ThreadId,
|
||||||
|
pub granularity: Option<String>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum Next {}
|
||||||
|
|
||||||
|
impl Request for Next {
|
||||||
|
type Arguments = NextArguments;
|
||||||
|
type Result = ();
|
||||||
|
const COMMAND: &'static str = "next";
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct PauseArguments {
|
||||||
|
pub thread_id: ThreadId,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum Pause {}
|
||||||
|
|
||||||
|
impl Request for Pause {
|
||||||
|
type Arguments = PauseArguments;
|
||||||
|
type Result = ();
|
||||||
|
const COMMAND: &'static str = "pause";
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct EvaluateArguments {
|
||||||
|
pub expression: String,
|
||||||
|
pub frame_id: Option<usize>,
|
||||||
|
pub context: Option<String>,
|
||||||
|
pub format: Option<ValueFormat>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct EvaluateResponse {
|
||||||
|
pub result: String,
|
||||||
|
#[serde(rename = "type")]
|
||||||
|
pub ty: Option<String>,
|
||||||
|
pub presentation_hint: Option<VariablePresentationHint>,
|
||||||
|
pub variables_reference: usize,
|
||||||
|
pub named_variables: Option<usize>,
|
||||||
|
pub indexed_variables: Option<usize>,
|
||||||
|
pub memory_reference: Option<String>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum Evaluate {}
|
||||||
|
|
||||||
|
impl Request for Evaluate {
|
||||||
|
type Arguments = EvaluateArguments;
|
||||||
|
type Result = EvaluateResponse;
|
||||||
|
const COMMAND: &'static str = "evaluate";
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct SetExceptionBreakpointsArguments {
|
||||||
|
pub filters: Vec<String>,
|
||||||
|
// pub filterOptions: Option<Vec<ExceptionFilterOptions>>, // needs capability
|
||||||
|
// pub exceptionOptions: Option<Vec<ExceptionOptions>>, // needs capability
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct SetExceptionBreakpointsResponse {
|
||||||
|
pub breakpoints: Option<Vec<Breakpoint>>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum SetExceptionBreakpoints {}
|
||||||
|
|
||||||
|
impl Request for SetExceptionBreakpoints {
|
||||||
|
type Arguments = SetExceptionBreakpointsArguments;
|
||||||
|
type Result = SetExceptionBreakpointsResponse;
|
||||||
|
const COMMAND: &'static str = "setExceptionBreakpoints";
|
||||||
|
}
|
||||||
|
|
||||||
|
// Reverse Requests
|
||||||
|
|
||||||
|
#[derive(Debug, Default, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct RunInTerminalResponse {
|
||||||
|
pub process_id: Option<u32>,
|
||||||
|
pub shell_process_id: Option<u32>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct RunInTerminalArguments {
|
||||||
|
pub kind: Option<String>,
|
||||||
|
pub title: Option<String>,
|
||||||
|
pub cwd: Option<String>,
|
||||||
|
pub args: Vec<String>,
|
||||||
|
pub env: Option<HashMap<String, Option<String>>>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum RunInTerminal {}
|
||||||
|
|
||||||
|
impl Request for RunInTerminal {
|
||||||
|
type Arguments = RunInTerminalArguments;
|
||||||
|
type Result = RunInTerminalResponse;
|
||||||
|
const COMMAND: &'static str = "runInTerminal";
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Events
|
||||||
|
|
||||||
|
pub mod events {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
#[serde(tag = "event", content = "body")]
|
||||||
|
// seq is omitted as unused and is not sent by some implementations
|
||||||
|
pub enum Event {
|
||||||
|
Initialized,
|
||||||
|
Stopped(Stopped),
|
||||||
|
Continued(Continued),
|
||||||
|
Exited(Exited),
|
||||||
|
Terminated(Option<Terminated>),
|
||||||
|
Thread(Thread),
|
||||||
|
Output(Output),
|
||||||
|
Breakpoint(Breakpoint),
|
||||||
|
Module(Module),
|
||||||
|
LoadedSource(LoadedSource),
|
||||||
|
Process(Process),
|
||||||
|
Capabilities(Capabilities),
|
||||||
|
// ProgressStart(),
|
||||||
|
// ProgressUpdate(),
|
||||||
|
// ProgressEnd(),
|
||||||
|
// Invalidated(),
|
||||||
|
Memory(Memory),
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct Stopped {
|
||||||
|
pub reason: String,
|
||||||
|
pub description: Option<String>,
|
||||||
|
pub thread_id: Option<ThreadId>,
|
||||||
|
pub preserve_focus_hint: Option<bool>,
|
||||||
|
pub text: Option<String>,
|
||||||
|
pub all_threads_stopped: Option<bool>,
|
||||||
|
pub hit_breakpoint_ids: Option<Vec<usize>>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct Continued {
|
||||||
|
pub thread_id: ThreadId,
|
||||||
|
pub all_threads_continued: Option<bool>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct Exited {
|
||||||
|
pub exit_code: usize,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct Terminated {
|
||||||
|
pub restart: Option<Value>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct Thread {
|
||||||
|
pub reason: String,
|
||||||
|
pub thread_id: ThreadId,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct Output {
|
||||||
|
pub output: String,
|
||||||
|
pub category: Option<String>,
|
||||||
|
pub group: Option<String>,
|
||||||
|
pub line: Option<usize>,
|
||||||
|
pub column: Option<usize>,
|
||||||
|
pub variables_reference: Option<usize>,
|
||||||
|
pub source: Option<Source>,
|
||||||
|
pub data: Option<Value>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct Breakpoint {
|
||||||
|
pub reason: String,
|
||||||
|
pub breakpoint: super::Breakpoint,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct Module {
|
||||||
|
pub reason: String,
|
||||||
|
pub module: super::Module,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct LoadedSource {
|
||||||
|
pub reason: String,
|
||||||
|
pub source: super::Source,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct Process {
|
||||||
|
pub name: String,
|
||||||
|
pub system_process_id: Option<usize>,
|
||||||
|
pub is_local_process: Option<bool>,
|
||||||
|
pub start_method: Option<String>, // TODO: use enum
|
||||||
|
pub pointer_size: Option<usize>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct Capabilities {
|
||||||
|
pub capabilities: super::DebuggerCapabilities,
|
||||||
|
}
|
||||||
|
|
||||||
|
// #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
// #[serde(rename_all = "camelCase")]
|
||||||
|
// pub struct Invalidated {
|
||||||
|
// pub areas: Vec<InvalidatedArea>,
|
||||||
|
// pub thread_id: Option<ThreadId>,
|
||||||
|
// pub stack_frame_id: Option<usize>,
|
||||||
|
// }
|
||||||
|
|
||||||
|
#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
|
||||||
|
#[serde(rename_all = "camelCase")]
|
||||||
|
pub struct Memory {
|
||||||
|
pub memory_reference: String,
|
||||||
|
pub offset: usize,
|
||||||
|
pub count: usize,
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1 @@
|
|||||||
|
Subproject commit bd50ccf66b42c55252ac8efc1086af4ac6bab8cd
|
||||||
@ -0,0 +1 @@
|
|||||||
|
Subproject commit 86985bde399c5f40b00bc75f7ab70a6c69a5f9c3
|
||||||
@ -0,0 +1 @@
|
|||||||
|
Subproject commit 0e4f0baf90b57e5aeb62dcdbf03062c6315d43ea
|
||||||
@ -1 +1 @@
|
|||||||
Subproject commit 2a83dfdd759a632651f852aa4dc0af2525fae5cd
|
Subproject commit 0fa917a7022d1cd2e9b779a6a8fc5dc7fad69c75
|
||||||
@ -0,0 +1 @@
|
|||||||
|
Subproject commit 5e66e961eee421786bdda8495ed1db045e06b5fe
|
||||||
@ -1 +1 @@
|
|||||||
Subproject commit 237f4eb4417c28f643a29d795ed227246afb66f9
|
Subproject commit b6ec26f181dd059eedd506fa5fbeae1b8e5556c8
|
||||||
@ -0,0 +1 @@
|
|||||||
|
Subproject commit 3ec55082cf0be015d03148be8edfdfa8c56e77f9
|
||||||
@ -0,0 +1 @@
|
|||||||
|
Subproject commit d98426109258b266e1e92358c5f11716d2e8f638
|
||||||
@ -0,0 +1 @@
|
|||||||
|
Subproject commit 06fabca19454b2dc00c1b211a7cb7ad0bc2585f1
|
||||||
@ -0,0 +1 @@
|
|||||||
|
Subproject commit a4b9187417d6be349ee5fd4b6e77b4172c6827dd
|
||||||
@ -1 +1 @@
|
|||||||
Subproject commit 0d63eaf94e8d6c0694551b016c802787e61b3fb2
|
Subproject commit 57f855461aeeca73bd4218754fb26b5ac143f98f
|
||||||
@ -0,0 +1 @@
|
|||||||
|
Subproject commit e1cfca3c79896ff79842f057ea13e529b66af636
|
||||||
@ -0,0 +1 @@
|
|||||||
|
Subproject commit 761eb9126b65e078b1b5770ac296b4af8870f933
|
||||||
@ -0,0 +1 @@
|
|||||||
|
Subproject commit b7444181fb38e603e25ea8fcdac55f9492e49c27
|
||||||
@ -1 +1 @@
|
|||||||
Subproject commit 1f27fd1dfe7f352408f01b4894c7825f3a1d6c47
|
Subproject commit 93331b8bd8b4ebee2b575490b2758f16ad4e9f30
|
||||||
@ -1,12 +1,17 @@
|
|||||||
|
use std::borrow::Cow;
|
||||||
use std::process::Command;
|
use std::process::Command;
|
||||||
|
|
||||||
fn main() {
|
fn main() {
|
||||||
let git_hash = Command::new("git")
|
let git_hash = Command::new("git")
|
||||||
.args(&["describe", "--dirty"])
|
.args(&["rev-parse", "HEAD"])
|
||||||
.output()
|
.output()
|
||||||
.map(|x| String::from_utf8(x.stdout).ok())
|
|
||||||
.ok()
|
.ok()
|
||||||
.flatten()
|
.and_then(|x| String::from_utf8(x.stdout).ok());
|
||||||
.unwrap_or_else(|| String::from(env!("CARGO_PKG_VERSION")));
|
|
||||||
println!("cargo:rustc-env=VERSION_AND_GIT_HASH={}", git_hash);
|
let version: Cow<_> = match git_hash {
|
||||||
|
Some(git_hash) => format!("{} ({})", env!("CARGO_PKG_VERSION"), &git_hash[..8]).into(),
|
||||||
|
None => env!("CARGO_PKG_VERSION").into(),
|
||||||
|
};
|
||||||
|
|
||||||
|
println!("cargo:rustc-env=VERSION_AND_GIT_HASH={}", version);
|
||||||
}
|
}
|
||||||
|
|||||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,827 @@
|
|||||||
|
use super::{align_view, Align, Context, Editor};
|
||||||
|
use crate::{
|
||||||
|
compositor::{self, Compositor},
|
||||||
|
job::{Callback, Jobs},
|
||||||
|
ui::{self, overlay::overlayed, FilePicker, Picker, Popup, Prompt, PromptEvent, Text},
|
||||||
|
};
|
||||||
|
use helix_core::{
|
||||||
|
syntax::{DebugArgumentValue, DebugConfigCompletion},
|
||||||
|
Selection,
|
||||||
|
};
|
||||||
|
use helix_dap::{self as dap, Client, ThreadId};
|
||||||
|
use helix_lsp::block_on;
|
||||||
|
use helix_view::editor::Breakpoint;
|
||||||
|
|
||||||
|
use serde_json::{to_value, Value};
|
||||||
|
use tokio_stream::wrappers::UnboundedReceiverStream;
|
||||||
|
|
||||||
|
use std::collections::HashMap;
|
||||||
|
use std::future::Future;
|
||||||
|
use std::path::PathBuf;
|
||||||
|
|
||||||
|
use anyhow::{anyhow, bail};
|
||||||
|
|
||||||
|
#[macro_export]
|
||||||
|
macro_rules! debugger {
|
||||||
|
($editor:expr) => {{
|
||||||
|
match &mut $editor.debugger {
|
||||||
|
Some(debugger) => debugger,
|
||||||
|
None => return,
|
||||||
|
}
|
||||||
|
}};
|
||||||
|
}
|
||||||
|
|
||||||
|
// general utils:
|
||||||
|
pub fn dap_pos_to_pos(doc: &helix_core::Rope, line: usize, column: usize) -> Option<usize> {
|
||||||
|
// 1-indexing to 0 indexing
|
||||||
|
let line = doc.try_line_to_char(line - 1).ok()?;
|
||||||
|
let pos = line + column.saturating_sub(1);
|
||||||
|
// TODO: this is probably utf-16 offsets
|
||||||
|
Some(pos)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn select_thread_id(editor: &mut Editor, thread_id: ThreadId, force: bool) {
|
||||||
|
let debugger = debugger!(editor);
|
||||||
|
|
||||||
|
if !force && debugger.thread_id.is_some() {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
debugger.thread_id = Some(thread_id);
|
||||||
|
fetch_stack_trace(debugger, thread_id).await;
|
||||||
|
|
||||||
|
let frame = debugger.stack_frames[&thread_id].get(0).cloned();
|
||||||
|
if let Some(frame) = &frame {
|
||||||
|
jump_to_stack_frame(editor, frame);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub async fn fetch_stack_trace(debugger: &mut Client, thread_id: ThreadId) {
|
||||||
|
let (frames, _) = match debugger.stack_trace(thread_id).await {
|
||||||
|
Ok(frames) => frames,
|
||||||
|
Err(_) => return,
|
||||||
|
};
|
||||||
|
debugger.stack_frames.insert(thread_id, frames);
|
||||||
|
debugger.active_frame = Some(0);
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn jump_to_stack_frame(editor: &mut Editor, frame: &helix_dap::StackFrame) {
|
||||||
|
let path = if let Some(helix_dap::Source {
|
||||||
|
path: Some(ref path),
|
||||||
|
..
|
||||||
|
}) = frame.source
|
||||||
|
{
|
||||||
|
path.clone()
|
||||||
|
} else {
|
||||||
|
return;
|
||||||
|
};
|
||||||
|
|
||||||
|
if let Err(e) = editor.open(path, helix_view::editor::Action::Replace) {
|
||||||
|
editor.set_error(format!("Unable to jump to stack frame: {}", e));
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
let (view, doc) = current!(editor);
|
||||||
|
|
||||||
|
let text_end = doc.text().len_chars().saturating_sub(1);
|
||||||
|
let start = dap_pos_to_pos(doc.text(), frame.line, frame.column).unwrap_or(0);
|
||||||
|
let end = frame
|
||||||
|
.end_line
|
||||||
|
.and_then(|end_line| dap_pos_to_pos(doc.text(), end_line, frame.end_column.unwrap_or(0)))
|
||||||
|
.unwrap_or(start);
|
||||||
|
|
||||||
|
let selection = Selection::single(start.min(text_end), end.min(text_end));
|
||||||
|
doc.set_selection(view.id, selection);
|
||||||
|
align_view(doc, view, Align::Center);
|
||||||
|
}
|
||||||
|
|
||||||
|
fn thread_picker(
|
||||||
|
cx: &mut Context,
|
||||||
|
callback_fn: impl Fn(&mut Editor, &dap::Thread) + Send + 'static,
|
||||||
|
) {
|
||||||
|
let debugger = debugger!(cx.editor);
|
||||||
|
|
||||||
|
let future = debugger.threads();
|
||||||
|
dap_callback(
|
||||||
|
cx.jobs,
|
||||||
|
future,
|
||||||
|
move |editor: &mut Editor,
|
||||||
|
compositor: &mut Compositor,
|
||||||
|
response: dap::requests::ThreadsResponse| {
|
||||||
|
let threads = response.threads;
|
||||||
|
if threads.len() == 1 {
|
||||||
|
callback_fn(editor, &threads[0]);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
let debugger = debugger!(editor);
|
||||||
|
|
||||||
|
let thread_states = debugger.thread_states.clone();
|
||||||
|
let picker = FilePicker::new(
|
||||||
|
threads,
|
||||||
|
move |thread| {
|
||||||
|
format!(
|
||||||
|
"{} ({})",
|
||||||
|
thread.name,
|
||||||
|
thread_states
|
||||||
|
.get(&thread.id)
|
||||||
|
.map(|state| state.as_str())
|
||||||
|
.unwrap_or("unknown")
|
||||||
|
)
|
||||||
|
.into()
|
||||||
|
},
|
||||||
|
move |cx, thread, _action| callback_fn(cx.editor, thread),
|
||||||
|
move |editor, thread| {
|
||||||
|
let frames = editor.debugger.as_ref()?.stack_frames.get(&thread.id)?;
|
||||||
|
let frame = frames.get(0)?;
|
||||||
|
let path = frame.source.as_ref()?.path.clone()?;
|
||||||
|
let pos = Some((
|
||||||
|
frame.line.saturating_sub(1),
|
||||||
|
frame.end_line.unwrap_or(frame.line).saturating_sub(1),
|
||||||
|
));
|
||||||
|
Some((path, pos))
|
||||||
|
},
|
||||||
|
);
|
||||||
|
compositor.push(Box::new(picker));
|
||||||
|
},
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
fn get_breakpoint_at_current_line(editor: &mut Editor) -> Option<(usize, Breakpoint)> {
|
||||||
|
let (view, doc) = current!(editor);
|
||||||
|
let text = doc.text().slice(..);
|
||||||
|
|
||||||
|
let line = doc.selection(view.id).primary().cursor_line(text);
|
||||||
|
let path = doc.path()?;
|
||||||
|
editor.breakpoints.get(path).and_then(|breakpoints| {
|
||||||
|
let i = breakpoints.iter().position(|b| b.line == line);
|
||||||
|
i.map(|i| (i, breakpoints[i].clone()))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
// -- DAP
|
||||||
|
|
||||||
|
fn dap_callback<T, F>(
|
||||||
|
jobs: &mut Jobs,
|
||||||
|
call: impl Future<Output = helix_dap::Result<serde_json::Value>> + 'static + Send,
|
||||||
|
callback: F,
|
||||||
|
) where
|
||||||
|
T: for<'de> serde::Deserialize<'de> + Send + 'static,
|
||||||
|
F: FnOnce(&mut Editor, &mut Compositor, T) + Send + 'static,
|
||||||
|
{
|
||||||
|
let callback = Box::pin(async move {
|
||||||
|
let json = call.await?;
|
||||||
|
let response = serde_json::from_value(json)?;
|
||||||
|
let call: Callback = Box::new(move |editor: &mut Editor, compositor: &mut Compositor| {
|
||||||
|
callback(editor, compositor, response)
|
||||||
|
});
|
||||||
|
Ok(call)
|
||||||
|
});
|
||||||
|
jobs.callback(callback);
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn dap_start_impl(
|
||||||
|
cx: &mut compositor::Context,
|
||||||
|
name: Option<&str>,
|
||||||
|
socket: Option<std::net::SocketAddr>,
|
||||||
|
params: Option<Vec<std::borrow::Cow<str>>>,
|
||||||
|
) -> Result<(), anyhow::Error> {
|
||||||
|
let doc = doc!(cx.editor);
|
||||||
|
|
||||||
|
let config = doc
|
||||||
|
.language_config()
|
||||||
|
.and_then(|config| config.debugger.as_ref())
|
||||||
|
.ok_or(anyhow!("No debug adapter available for language"))?;
|
||||||
|
|
||||||
|
let result = match socket {
|
||||||
|
Some(socket) => block_on(Client::tcp(socket, 0)),
|
||||||
|
None => block_on(Client::process(
|
||||||
|
&config.transport,
|
||||||
|
&config.command,
|
||||||
|
config.args.iter().map(|arg| arg.as_str()).collect(),
|
||||||
|
config.port_arg.as_deref(),
|
||||||
|
0,
|
||||||
|
)),
|
||||||
|
};
|
||||||
|
|
||||||
|
let (mut debugger, events) = match result {
|
||||||
|
Ok(r) => r,
|
||||||
|
Err(e) => bail!("Failed to start debug session: {}", e),
|
||||||
|
};
|
||||||
|
|
||||||
|
let request = debugger.initialize(config.name.clone());
|
||||||
|
if let Err(e) = block_on(request) {
|
||||||
|
bail!("Failed to initialize debug adapter: {}", e);
|
||||||
|
}
|
||||||
|
|
||||||
|
debugger.quirks = config.quirks.clone();
|
||||||
|
|
||||||
|
// TODO: avoid refetching all of this... pass a config in
|
||||||
|
let template = match name {
|
||||||
|
Some(name) => config.templates.iter().find(|t| t.name == name),
|
||||||
|
None => config.templates.get(0),
|
||||||
|
}
|
||||||
|
.ok_or(anyhow!("No debug config with given name"))?;
|
||||||
|
|
||||||
|
let mut args: HashMap<&str, Value> = HashMap::new();
|
||||||
|
|
||||||
|
if let Some(params) = params {
|
||||||
|
for (k, t) in &template.args {
|
||||||
|
let mut value = t.clone();
|
||||||
|
for (i, x) in params.iter().enumerate() {
|
||||||
|
let mut param = x.to_string();
|
||||||
|
if let Some(DebugConfigCompletion::Advanced(cfg)) = template.completion.get(i) {
|
||||||
|
if matches!(cfg.completion.as_deref(), Some("filename" | "directory")) {
|
||||||
|
param = std::fs::canonicalize(x.as_ref())
|
||||||
|
.ok()
|
||||||
|
.and_then(|pb| pb.into_os_string().into_string().ok())
|
||||||
|
.unwrap_or_else(|| x.to_string());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// 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, ¶m))
|
||||||
|
}
|
||||||
|
DebugArgumentValue::Array(arr) => DebugArgumentValue::Array(
|
||||||
|
arr.iter().map(|v| v.replace(&pattern, ¶m)).collect(),
|
||||||
|
),
|
||||||
|
DebugArgumentValue::Boolean(_) => value,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
match value {
|
||||||
|
DebugArgumentValue::String(string) => {
|
||||||
|
if let Ok(integer) = string.parse::<usize>() {
|
||||||
|
args.insert(k, to_value(integer).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());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
let args = to_value(args).unwrap();
|
||||||
|
|
||||||
|
let callback = |_editor: &mut Editor, _compositor: &mut Compositor, _response: Value| {
|
||||||
|
// if let Err(e) = result {
|
||||||
|
// editor.set_error(format!("Failed {} target: {}", template.request, e));
|
||||||
|
// }
|
||||||
|
};
|
||||||
|
|
||||||
|
match &template.request[..] {
|
||||||
|
"launch" => {
|
||||||
|
let call = debugger.launch(args);
|
||||||
|
dap_callback(cx.jobs, call, callback);
|
||||||
|
}
|
||||||
|
"attach" => {
|
||||||
|
let call = debugger.attach(args);
|
||||||
|
dap_callback(cx.jobs, call, callback);
|
||||||
|
}
|
||||||
|
request => bail!("Unsupported request '{}'", request),
|
||||||
|
};
|
||||||
|
|
||||||
|
// TODO: either await "initialized" or buffer commands until event is received
|
||||||
|
cx.editor.debugger = Some(debugger);
|
||||||
|
let stream = UnboundedReceiverStream::new(events);
|
||||||
|
cx.editor.debugger_events.push(stream);
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn dap_launch(cx: &mut Context) {
|
||||||
|
if cx.editor.debugger.is_some() {
|
||||||
|
cx.editor.set_error("Debugger is already running");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
let doc = doc!(cx.editor);
|
||||||
|
|
||||||
|
let config = match doc
|
||||||
|
.language_config()
|
||||||
|
.and_then(|config| config.debugger.as_ref())
|
||||||
|
{
|
||||||
|
Some(c) => c,
|
||||||
|
None => {
|
||||||
|
cx.editor
|
||||||
|
.set_error("No debug adapter available for language");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
let templates = config.templates.clone();
|
||||||
|
|
||||||
|
cx.push_layer(Box::new(overlayed(Picker::new(
|
||||||
|
templates,
|
||||||
|
|template| template.name.as_str().into(),
|
||||||
|
|cx, template, _action| {
|
||||||
|
let completions = template.completion.clone();
|
||||||
|
let name = template.name.clone();
|
||||||
|
let callback = Box::pin(async move {
|
||||||
|
let call: Callback =
|
||||||
|
Box::new(move |_editor: &mut Editor, compositor: &mut Compositor| {
|
||||||
|
let prompt = debug_parameter_prompt(completions, name, Vec::new());
|
||||||
|
compositor.push(Box::new(prompt));
|
||||||
|
});
|
||||||
|
Ok(call)
|
||||||
|
});
|
||||||
|
cx.jobs.callback(callback);
|
||||||
|
},
|
||||||
|
))));
|
||||||
|
}
|
||||||
|
|
||||||
|
fn debug_parameter_prompt(
|
||||||
|
completions: Vec<DebugConfigCompletion>,
|
||||||
|
config_name: String,
|
||||||
|
mut params: Vec<String>,
|
||||||
|
) -> Prompt {
|
||||||
|
let completion = completions.get(params.len()).unwrap();
|
||||||
|
let field_type = if let DebugConfigCompletion::Advanced(cfg) = completion {
|
||||||
|
cfg.completion.as_deref().unwrap_or("")
|
||||||
|
} else {
|
||||||
|
""
|
||||||
|
};
|
||||||
|
let name = match completion {
|
||||||
|
DebugConfigCompletion::Advanced(cfg) => cfg.name.as_deref().unwrap_or(field_type),
|
||||||
|
DebugConfigCompletion::Named(name) => name.as_str(),
|
||||||
|
};
|
||||||
|
let default_val = match completion {
|
||||||
|
DebugConfigCompletion::Advanced(cfg) => cfg.default.as_deref().unwrap_or(""),
|
||||||
|
_ => "",
|
||||||
|
}
|
||||||
|
.to_owned();
|
||||||
|
|
||||||
|
let completer = match field_type {
|
||||||
|
"filename" => ui::completers::filename,
|
||||||
|
"directory" => ui::completers::directory,
|
||||||
|
_ => |_input: &str| Vec::new(),
|
||||||
|
};
|
||||||
|
Prompt::new(
|
||||||
|
format!("{}: ", name).into(),
|
||||||
|
None,
|
||||||
|
completer,
|
||||||
|
move |cx, input: &str, event: PromptEvent| {
|
||||||
|
if event != PromptEvent::Validate {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
let mut value = input.to_owned();
|
||||||
|
if value.is_empty() {
|
||||||
|
value = default_val.clone();
|
||||||
|
}
|
||||||
|
params.push(value);
|
||||||
|
|
||||||
|
if params.len() < completions.len() {
|
||||||
|
let completions = completions.clone();
|
||||||
|
let config_name = config_name.clone();
|
||||||
|
let params = params.clone();
|
||||||
|
let callback = Box::pin(async move {
|
||||||
|
let call: Callback =
|
||||||
|
Box::new(move |_editor: &mut Editor, compositor: &mut Compositor| {
|
||||||
|
let prompt = debug_parameter_prompt(completions, config_name, params);
|
||||||
|
compositor.push(Box::new(prompt));
|
||||||
|
});
|
||||||
|
Ok(call)
|
||||||
|
});
|
||||||
|
cx.jobs.callback(callback);
|
||||||
|
} else if let Err(e) = dap_start_impl(
|
||||||
|
cx,
|
||||||
|
Some(&config_name),
|
||||||
|
None,
|
||||||
|
Some(params.iter().map(|x| x.into()).collect()),
|
||||||
|
) {
|
||||||
|
cx.editor.set_error(e.to_string());
|
||||||
|
}
|
||||||
|
},
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn dap_toggle_breakpoint(cx: &mut Context) {
|
||||||
|
let (view, doc) = current!(cx.editor);
|
||||||
|
let path = match doc.path() {
|
||||||
|
Some(path) => path.clone(),
|
||||||
|
None => {
|
||||||
|
cx.editor
|
||||||
|
.set_error("Can't set breakpoint: document has no path");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
let text = doc.text().slice(..);
|
||||||
|
let line = doc.selection(view.id).primary().cursor_line(text);
|
||||||
|
dap_toggle_breakpoint_impl(cx, path, line);
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn breakpoints_changed(
|
||||||
|
debugger: &mut dap::Client,
|
||||||
|
path: PathBuf,
|
||||||
|
breakpoints: &mut [Breakpoint],
|
||||||
|
) -> Result<(), anyhow::Error> {
|
||||||
|
// TODO: handle capabilities correctly again, by filterin breakpoints when emitting
|
||||||
|
// if breakpoint.condition.is_some()
|
||||||
|
// && !debugger
|
||||||
|
// .caps
|
||||||
|
// .as_ref()
|
||||||
|
// .unwrap()
|
||||||
|
// .supports_conditional_breakpoints
|
||||||
|
// .unwrap_or_default()
|
||||||
|
// {
|
||||||
|
// bail!(
|
||||||
|
// "Can't edit breakpoint: debugger does not support conditional breakpoints"
|
||||||
|
// )
|
||||||
|
// }
|
||||||
|
// if breakpoint.log_message.is_some()
|
||||||
|
// && !debugger
|
||||||
|
// .caps
|
||||||
|
// .as_ref()
|
||||||
|
// .unwrap()
|
||||||
|
// .supports_log_points
|
||||||
|
// .unwrap_or_default()
|
||||||
|
// {
|
||||||
|
// bail!("Can't edit breakpoint: debugger does not support logpoints")
|
||||||
|
// }
|
||||||
|
let source_breakpoints = breakpoints
|
||||||
|
.iter()
|
||||||
|
.map(|breakpoint| helix_dap::SourceBreakpoint {
|
||||||
|
line: breakpoint.line + 1, // convert from 0-indexing to 1-indexing (TODO: could set debugger to 0-indexing on init)
|
||||||
|
..Default::default()
|
||||||
|
})
|
||||||
|
.collect::<Vec<_>>();
|
||||||
|
|
||||||
|
let request = debugger.set_breakpoints(path, source_breakpoints);
|
||||||
|
match block_on(request) {
|
||||||
|
Ok(Some(dap_breakpoints)) => {
|
||||||
|
for (breakpoint, dap_breakpoint) in breakpoints.iter_mut().zip(dap_breakpoints) {
|
||||||
|
breakpoint.id = dap_breakpoint.id;
|
||||||
|
breakpoint.verified = dap_breakpoint.verified;
|
||||||
|
breakpoint.message = dap_breakpoint.message;
|
||||||
|
// TODO: handle breakpoint.message
|
||||||
|
// TODO: verify source matches
|
||||||
|
breakpoint.line = dap_breakpoint.line.unwrap_or(0).saturating_sub(1); // convert to 0-indexing
|
||||||
|
// TODO: no unwrap
|
||||||
|
breakpoint.column = dap_breakpoint.column;
|
||||||
|
// TODO: verify end_linef/col instruction reference, offset
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Err(e) => anyhow::bail!("Failed to set breakpoints: {}", e),
|
||||||
|
_ => {}
|
||||||
|
};
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn dap_toggle_breakpoint_impl(cx: &mut Context, path: PathBuf, line: usize) {
|
||||||
|
// TODO: need to map breakpoints over edits and update them?
|
||||||
|
// we shouldn't really allow editing while debug is running though
|
||||||
|
|
||||||
|
let breakpoints = cx.editor.breakpoints.entry(path.clone()).or_default();
|
||||||
|
// TODO: always keep breakpoints sorted and use binary search to determine insertion point
|
||||||
|
if let Some(pos) = breakpoints
|
||||||
|
.iter()
|
||||||
|
.position(|breakpoint| breakpoint.line == line)
|
||||||
|
{
|
||||||
|
breakpoints.remove(pos);
|
||||||
|
} else {
|
||||||
|
breakpoints.push(Breakpoint {
|
||||||
|
line,
|
||||||
|
..Default::default()
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
let debugger = debugger!(cx.editor);
|
||||||
|
|
||||||
|
if let Err(e) = breakpoints_changed(debugger, path, breakpoints) {
|
||||||
|
cx.editor
|
||||||
|
.set_error(format!("Failed to set breakpoints: {}", e));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn dap_continue(cx: &mut Context) {
|
||||||
|
let debugger = debugger!(cx.editor);
|
||||||
|
|
||||||
|
if let Some(thread_id) = debugger.thread_id {
|
||||||
|
let request = debugger.continue_thread(thread_id);
|
||||||
|
|
||||||
|
dap_callback(
|
||||||
|
cx.jobs,
|
||||||
|
request,
|
||||||
|
|editor, _compositor, _response: dap::requests::ContinueResponse| {
|
||||||
|
debugger!(editor).resume_application();
|
||||||
|
},
|
||||||
|
);
|
||||||
|
} else {
|
||||||
|
cx.editor
|
||||||
|
.set_error("Currently active thread is not stopped. Switch the thread.");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn dap_pause(cx: &mut Context) {
|
||||||
|
thread_picker(cx, |editor, thread| {
|
||||||
|
let debugger = debugger!(editor);
|
||||||
|
let request = debugger.pause(thread.id);
|
||||||
|
// NOTE: we don't need to set active thread id here because DAP will emit a "stopped" event
|
||||||
|
if let Err(e) = block_on(request) {
|
||||||
|
editor.set_error(format!("Failed to pause: {}", e));
|
||||||
|
}
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn dap_step_in(cx: &mut Context) {
|
||||||
|
let debugger = debugger!(cx.editor);
|
||||||
|
|
||||||
|
if let Some(thread_id) = debugger.thread_id {
|
||||||
|
let request = debugger.step_in(thread_id);
|
||||||
|
|
||||||
|
dap_callback(cx.jobs, request, |editor, _compositor, _response: ()| {
|
||||||
|
debugger!(editor).resume_application();
|
||||||
|
});
|
||||||
|
} else {
|
||||||
|
cx.editor
|
||||||
|
.set_error("Currently active thread is not stopped. Switch the thread.");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn dap_step_out(cx: &mut Context) {
|
||||||
|
let debugger = debugger!(cx.editor);
|
||||||
|
|
||||||
|
if let Some(thread_id) = debugger.thread_id {
|
||||||
|
let request = debugger.step_out(thread_id);
|
||||||
|
dap_callback(cx.jobs, request, |editor, _compositor, _response: ()| {
|
||||||
|
debugger!(editor).resume_application();
|
||||||
|
});
|
||||||
|
} else {
|
||||||
|
cx.editor
|
||||||
|
.set_error("Currently active thread is not stopped. Switch the thread.");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn dap_next(cx: &mut Context) {
|
||||||
|
let debugger = debugger!(cx.editor);
|
||||||
|
|
||||||
|
if let Some(thread_id) = debugger.thread_id {
|
||||||
|
let request = debugger.next(thread_id);
|
||||||
|
dap_callback(cx.jobs, request, |editor, _compositor, _response: ()| {
|
||||||
|
debugger!(editor).resume_application();
|
||||||
|
});
|
||||||
|
} else {
|
||||||
|
cx.editor
|
||||||
|
.set_error("Currently active thread is not stopped. Switch the thread.");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn dap_variables(cx: &mut Context) {
|
||||||
|
let debugger = debugger!(cx.editor);
|
||||||
|
|
||||||
|
if debugger.thread_id.is_none() {
|
||||||
|
cx.editor
|
||||||
|
.set_status("Cannot access variables while target is running");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
let (frame, thread_id) = match (debugger.active_frame, debugger.thread_id) {
|
||||||
|
(Some(frame), Some(thread_id)) => (frame, thread_id),
|
||||||
|
_ => {
|
||||||
|
cx.editor
|
||||||
|
.set_status("Cannot find current stack frame to access variables");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
let frame_id = debugger.stack_frames[&thread_id][frame].id;
|
||||||
|
let scopes = match block_on(debugger.scopes(frame_id)) {
|
||||||
|
Ok(s) => s,
|
||||||
|
Err(e) => {
|
||||||
|
cx.editor.set_error(format!("Failed to get scopes: {}", e));
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
// TODO: allow expanding variables into sub-fields
|
||||||
|
let mut variables = Vec::new();
|
||||||
|
|
||||||
|
let theme = &cx.editor.theme;
|
||||||
|
let scope_style = theme.get("ui.linenr.selected");
|
||||||
|
let type_style = theme.get("ui.text");
|
||||||
|
let text_style = theme.get("ui.text.focus");
|
||||||
|
|
||||||
|
for scope in scopes.iter() {
|
||||||
|
// use helix_view::graphics::Style;
|
||||||
|
use tui::text::{Span, Spans};
|
||||||
|
let response = block_on(debugger.variables(scope.variables_reference));
|
||||||
|
|
||||||
|
variables.push(Spans::from(Span::styled(
|
||||||
|
format!("▸ {}", scope.name),
|
||||||
|
scope_style,
|
||||||
|
)));
|
||||||
|
|
||||||
|
if let Ok(vars) = response {
|
||||||
|
variables.reserve(vars.len());
|
||||||
|
for var in vars {
|
||||||
|
let mut spans = Vec::with_capacity(5);
|
||||||
|
|
||||||
|
spans.push(Span::styled(var.name.to_owned(), text_style));
|
||||||
|
if let Some(ty) = var.ty {
|
||||||
|
spans.push(Span::raw(": "));
|
||||||
|
spans.push(Span::styled(ty.to_owned(), type_style));
|
||||||
|
}
|
||||||
|
spans.push(Span::raw(" = "));
|
||||||
|
spans.push(Span::styled(var.value.to_owned(), text_style));
|
||||||
|
variables.push(Spans::from(spans));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
let contents = Text::from(tui::text::Text::from(variables));
|
||||||
|
let popup = Popup::new("dap-variables", contents);
|
||||||
|
cx.push_layer(Box::new(popup));
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn dap_terminate(cx: &mut Context) {
|
||||||
|
let debugger = debugger!(cx.editor);
|
||||||
|
|
||||||
|
let request = debugger.disconnect();
|
||||||
|
dap_callback(cx.jobs, request, |editor, _compositor, _response: ()| {
|
||||||
|
// editor.set_error(format!("Failed to disconnect: {}", e));
|
||||||
|
editor.debugger = None;
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn dap_enable_exceptions(cx: &mut Context) {
|
||||||
|
let debugger = debugger!(cx.editor);
|
||||||
|
|
||||||
|
let filters = match &debugger.capabilities().exception_breakpoint_filters {
|
||||||
|
Some(filters) => filters.iter().map(|f| f.filter.clone()).collect(),
|
||||||
|
None => return,
|
||||||
|
};
|
||||||
|
|
||||||
|
let request = debugger.set_exception_breakpoints(filters);
|
||||||
|
|
||||||
|
dap_callback(
|
||||||
|
cx.jobs,
|
||||||
|
request,
|
||||||
|
|_editor, _compositor, _response: dap::requests::SetExceptionBreakpointsResponse| {
|
||||||
|
// editor.set_error(format!("Failed to set up exception breakpoints: {}", e));
|
||||||
|
},
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn dap_disable_exceptions(cx: &mut Context) {
|
||||||
|
let debugger = debugger!(cx.editor);
|
||||||
|
|
||||||
|
let request = debugger.set_exception_breakpoints(Vec::new());
|
||||||
|
|
||||||
|
dap_callback(
|
||||||
|
cx.jobs,
|
||||||
|
request,
|
||||||
|
|_editor, _compositor, _response: dap::requests::SetExceptionBreakpointsResponse| {
|
||||||
|
// editor.set_error(format!("Failed to set up exception breakpoints: {}", e));
|
||||||
|
},
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
// TODO: both edit condition and edit log need to be stable: we might get new breakpoints from the debugger which can change offsets
|
||||||
|
pub fn dap_edit_condition(cx: &mut Context) {
|
||||||
|
if let Some((pos, breakpoint)) = get_breakpoint_at_current_line(cx.editor) {
|
||||||
|
let path = match doc!(cx.editor).path() {
|
||||||
|
Some(path) => path.clone(),
|
||||||
|
None => return,
|
||||||
|
};
|
||||||
|
let callback = Box::pin(async move {
|
||||||
|
let call: Callback =
|
||||||
|
Box::new(move |_editor: &mut Editor, compositor: &mut Compositor| {
|
||||||
|
let mut prompt = Prompt::new(
|
||||||
|
"condition:".into(),
|
||||||
|
None,
|
||||||
|
|_input: &str| Vec::new(),
|
||||||
|
move |cx, input: &str, event: PromptEvent| {
|
||||||
|
if event != PromptEvent::Validate {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
let breakpoints = &mut cx.editor.breakpoints.get_mut(&path).unwrap();
|
||||||
|
breakpoints[pos].condition = match input {
|
||||||
|
"" => None,
|
||||||
|
input => Some(input.to_owned()),
|
||||||
|
};
|
||||||
|
|
||||||
|
let debugger = debugger!(cx.editor);
|
||||||
|
|
||||||
|
if let Err(e) = breakpoints_changed(debugger, path.clone(), breakpoints)
|
||||||
|
{
|
||||||
|
cx.editor
|
||||||
|
.set_error(format!("Failed to set breakpoints: {}", e));
|
||||||
|
}
|
||||||
|
},
|
||||||
|
);
|
||||||
|
if let Some(condition) = breakpoint.condition {
|
||||||
|
prompt.insert_str(&condition)
|
||||||
|
}
|
||||||
|
compositor.push(Box::new(prompt));
|
||||||
|
});
|
||||||
|
Ok(call)
|
||||||
|
});
|
||||||
|
cx.jobs.callback(callback);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn dap_edit_log(cx: &mut Context) {
|
||||||
|
if let Some((pos, breakpoint)) = get_breakpoint_at_current_line(cx.editor) {
|
||||||
|
let path = match doc!(cx.editor).path() {
|
||||||
|
Some(path) => path.clone(),
|
||||||
|
None => return,
|
||||||
|
};
|
||||||
|
let callback = Box::pin(async move {
|
||||||
|
let call: Callback =
|
||||||
|
Box::new(move |_editor: &mut Editor, compositor: &mut Compositor| {
|
||||||
|
let mut prompt = Prompt::new(
|
||||||
|
"log-message:".into(),
|
||||||
|
None,
|
||||||
|
|_input: &str| Vec::new(),
|
||||||
|
move |cx, input: &str, event: PromptEvent| {
|
||||||
|
if event != PromptEvent::Validate {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
let breakpoints = &mut cx.editor.breakpoints.get_mut(&path).unwrap();
|
||||||
|
breakpoints[pos].log_message = match input {
|
||||||
|
"" => None,
|
||||||
|
input => Some(input.to_owned()),
|
||||||
|
};
|
||||||
|
|
||||||
|
let debugger = debugger!(cx.editor);
|
||||||
|
if let Err(e) = breakpoints_changed(debugger, path.clone(), breakpoints)
|
||||||
|
{
|
||||||
|
cx.editor
|
||||||
|
.set_error(format!("Failed to set breakpoints: {}", e));
|
||||||
|
}
|
||||||
|
},
|
||||||
|
);
|
||||||
|
if let Some(log_message) = breakpoint.log_message {
|
||||||
|
prompt.insert_str(&log_message);
|
||||||
|
}
|
||||||
|
compositor.push(Box::new(prompt));
|
||||||
|
});
|
||||||
|
Ok(call)
|
||||||
|
});
|
||||||
|
cx.jobs.callback(callback);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn dap_switch_thread(cx: &mut Context) {
|
||||||
|
thread_picker(cx, |editor, thread| {
|
||||||
|
block_on(select_thread_id(editor, thread.id, true));
|
||||||
|
})
|
||||||
|
}
|
||||||
|
pub fn dap_switch_stack_frame(cx: &mut Context) {
|
||||||
|
let debugger = debugger!(cx.editor);
|
||||||
|
|
||||||
|
let thread_id = match debugger.thread_id {
|
||||||
|
Some(thread_id) => thread_id,
|
||||||
|
None => {
|
||||||
|
cx.editor.set_error("No thread is currently active");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
let frames = debugger.stack_frames[&thread_id].clone();
|
||||||
|
|
||||||
|
let picker = FilePicker::new(
|
||||||
|
frames,
|
||||||
|
|frame| frame.name.clone().into(), // TODO: include thread_states in the label
|
||||||
|
move |cx, frame, _action| {
|
||||||
|
let debugger = debugger!(cx.editor);
|
||||||
|
// TODO: this should be simpler to find
|
||||||
|
let pos = debugger.stack_frames[&thread_id]
|
||||||
|
.iter()
|
||||||
|
.position(|f| f.id == frame.id);
|
||||||
|
debugger.active_frame = pos;
|
||||||
|
|
||||||
|
let frame = debugger.stack_frames[&thread_id]
|
||||||
|
.get(pos.unwrap_or(0))
|
||||||
|
.cloned();
|
||||||
|
if let Some(frame) = &frame {
|
||||||
|
jump_to_stack_frame(cx.editor, frame);
|
||||||
|
}
|
||||||
|
},
|
||||||
|
move |_editor, frame| {
|
||||||
|
frame
|
||||||
|
.source
|
||||||
|
.as_ref()
|
||||||
|
.and_then(|source| source.path.clone())
|
||||||
|
.map(|path| {
|
||||||
|
(
|
||||||
|
path,
|
||||||
|
Some((
|
||||||
|
frame.line.saturating_sub(1),
|
||||||
|
frame.end_line.unwrap_or(frame.line).saturating_sub(1),
|
||||||
|
)),
|
||||||
|
)
|
||||||
|
})
|
||||||
|
},
|
||||||
|
);
|
||||||
|
cx.push_layer(Box::new(picker))
|
||||||
|
}
|
||||||
@ -0,0 +1,73 @@
|
|||||||
|
use crossterm::event::Event;
|
||||||
|
use helix_core::Position;
|
||||||
|
use helix_view::{
|
||||||
|
graphics::{CursorKind, Rect},
|
||||||
|
Editor,
|
||||||
|
};
|
||||||
|
use tui::buffer::Buffer;
|
||||||
|
|
||||||
|
use crate::compositor::{Component, Context, EventResult};
|
||||||
|
|
||||||
|
/// Contains a component placed in the center of the parent component
|
||||||
|
pub struct Overlay<T> {
|
||||||
|
/// Child component
|
||||||
|
pub content: T,
|
||||||
|
/// Function to compute the size and position of the child component
|
||||||
|
pub calc_child_size: Box<dyn Fn(Rect) -> Rect>,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Surrounds the component with a margin of 5% on each side, and an additional 2 rows at the bottom
|
||||||
|
pub fn overlayed<T>(content: T) -> Overlay<T> {
|
||||||
|
Overlay {
|
||||||
|
content,
|
||||||
|
calc_child_size: Box::new(|rect: Rect| clip_rect_relative(rect.clip_bottom(2), 90, 90)),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn clip_rect_relative(rect: Rect, percent_horizontal: u8, percent_vertical: u8) -> Rect {
|
||||||
|
fn mul_and_cast(size: u16, factor: u8) -> u16 {
|
||||||
|
((size as u32) * (factor as u32) / 100).try_into().unwrap()
|
||||||
|
}
|
||||||
|
|
||||||
|
let inner_w = mul_and_cast(rect.width, percent_horizontal);
|
||||||
|
let inner_h = mul_and_cast(rect.height, percent_vertical);
|
||||||
|
|
||||||
|
let offset_x = rect.width.saturating_sub(inner_w) / 2;
|
||||||
|
let offset_y = rect.height.saturating_sub(inner_h) / 2;
|
||||||
|
|
||||||
|
Rect {
|
||||||
|
x: rect.x + offset_x,
|
||||||
|
y: rect.y + offset_y,
|
||||||
|
width: inner_w,
|
||||||
|
height: inner_h,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T: Component + 'static> Component for Overlay<T> {
|
||||||
|
fn render(&mut self, area: Rect, frame: &mut Buffer, ctx: &mut Context) {
|
||||||
|
let dimensions = (self.calc_child_size)(area);
|
||||||
|
self.content.render(dimensions, frame, ctx)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn required_size(&mut self, (width, height): (u16, u16)) -> Option<(u16, u16)> {
|
||||||
|
let area = Rect {
|
||||||
|
x: 0,
|
||||||
|
y: 0,
|
||||||
|
width,
|
||||||
|
height,
|
||||||
|
};
|
||||||
|
let dimensions = (self.calc_child_size)(area);
|
||||||
|
let viewport = (dimensions.width, dimensions.height);
|
||||||
|
let _ = self.content.required_size(viewport)?;
|
||||||
|
Some((width, height))
|
||||||
|
}
|
||||||
|
|
||||||
|
fn handle_event(&mut self, event: Event, ctx: &mut Context) -> EventResult {
|
||||||
|
self.content.handle_event(event, ctx)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn cursor(&self, area: Rect, ctx: &Editor) -> (Option<Position>, CursorKind) {
|
||||||
|
let dimensions = (self.calc_child_size)(area);
|
||||||
|
self.content.cursor(dimensions, ctx)
|
||||||
|
}
|
||||||
|
}
|
||||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue