Anthony Eid
862d0c07ca
There were two bugs that caused the gdb adapter not to work properly,
one on our end and one their end.
The bug on our end was sending `stopOnEntry: null` in our launch request
when stop on entry had no value. I fixed that bug across all dap
adapters
The other bug had to do with python's "great" type system and how we
serialized our unit structs to json; mainly,
`ConfigurationDoneArguments` and `ThreadsArguments`. Gdb seems to follow
a pattern for handling requests where they pass `**args` to a function,
this errors out when the equivalent json is `"arguments": null`.
```py
@capability("supportsConfigurationDoneRequest")
@request("configurationDone", on_dap_thread=True)
def config_done(**args): ### BUG!!
...
```
Release Notes:
- N/A
100 lines
3.0 KiB
Rust
100 lines
3.0 KiB
Rust
use std::{ffi::OsStr, path::PathBuf};
|
|
|
|
use anyhow::Result;
|
|
use async_trait::async_trait;
|
|
use gpui::AsyncApp;
|
|
use task::{DebugAdapterConfig, DebugRequestType, DebugTaskDefinition};
|
|
|
|
use crate::*;
|
|
|
|
#[derive(Default)]
|
|
pub(crate) struct LldbDebugAdapter;
|
|
|
|
impl LldbDebugAdapter {
|
|
const ADAPTER_NAME: &'static str = "LLDB";
|
|
}
|
|
|
|
#[async_trait(?Send)]
|
|
impl DebugAdapter for LldbDebugAdapter {
|
|
fn name(&self) -> DebugAdapterName {
|
|
DebugAdapterName(Self::ADAPTER_NAME.into())
|
|
}
|
|
|
|
async fn get_binary(
|
|
&self,
|
|
delegate: &dyn DapDelegate,
|
|
_: &DebugAdapterConfig,
|
|
user_installed_path: Option<PathBuf>,
|
|
_: &mut AsyncApp,
|
|
) -> Result<DebugAdapterBinary> {
|
|
let lldb_dap_path = if let Some(user_installed_path) = user_installed_path {
|
|
user_installed_path.to_string_lossy().into()
|
|
} else {
|
|
delegate
|
|
.which(OsStr::new("lldb-dap"))
|
|
.and_then(|p| p.to_str().map(|s| s.to_string()))
|
|
.ok_or(anyhow!("Could not find lldb-dap in path"))?
|
|
};
|
|
|
|
Ok(DebugAdapterBinary {
|
|
command: lldb_dap_path,
|
|
arguments: None,
|
|
envs: None,
|
|
cwd: None,
|
|
connection: None,
|
|
})
|
|
}
|
|
|
|
async fn install_binary(
|
|
&self,
|
|
_version: AdapterVersion,
|
|
_delegate: &dyn DapDelegate,
|
|
) -> Result<()> {
|
|
unimplemented!("LLDB debug adapter cannot be installed by Zed (yet)")
|
|
}
|
|
|
|
async fn fetch_latest_adapter_version(&self, _: &dyn DapDelegate) -> Result<AdapterVersion> {
|
|
unimplemented!("Fetch latest adapter version not implemented for lldb (yet)")
|
|
}
|
|
|
|
async fn get_installed_binary(
|
|
&self,
|
|
_: &dyn DapDelegate,
|
|
_: &DebugAdapterConfig,
|
|
_: Option<PathBuf>,
|
|
_: &mut AsyncApp,
|
|
) -> Result<DebugAdapterBinary> {
|
|
unimplemented!("LLDB debug adapter cannot be installed by Zed (yet)")
|
|
}
|
|
|
|
fn request_args(&self, config: &DebugTaskDefinition) -> Value {
|
|
let mut args = json!({
|
|
"request": match config.request {
|
|
DebugRequestType::Launch(_) => "launch",
|
|
DebugRequestType::Attach(_) => "attach",
|
|
},
|
|
});
|
|
let map = args.as_object_mut().unwrap();
|
|
match &config.request {
|
|
DebugRequestType::Attach(attach) => {
|
|
map.insert("pid".into(), attach.process_id.into());
|
|
}
|
|
DebugRequestType::Launch(launch) => {
|
|
map.insert("program".into(), launch.program.clone().into());
|
|
|
|
if !launch.args.is_empty() {
|
|
map.insert("args".into(), launch.args.clone().into());
|
|
}
|
|
|
|
if let Some(stop_on_entry) = config.stop_on_entry {
|
|
map.insert("stopOnEntry".into(), stop_on_entry.into());
|
|
}
|
|
if let Some(cwd) = launch.cwd.as_ref() {
|
|
map.insert("cwd".into(), cwd.to_string_lossy().into_owned().into());
|
|
}
|
|
}
|
|
}
|
|
args
|
|
}
|
|
}
|