use dap_types::StartDebuggingRequestArguments;use schemars::{JsonSchema, r#gen::SchemaSettings};use serde::{Deserialize, Serialize};use std::net::Ipv4Addr;use std::path::PathBuf;use util::ResultExt; use crate::{TaskTemplate, TaskTemplates, TaskType, task_template::DebugArgs}; impl Default for DebugConnectionType {    fn default() -> Self {        DebugConnectionType::TCP(TCPHost::default())    }} /// Represents the host information of the debug adapter#[derive(Default, Deserialize, Serialize, PartialEq, Eq, JsonSchema, Clone, Debug)]pub struct TCPHost {    /// The port that the debug adapter is listening on    ///    /// Default: We will try to find an open port    pub port: Option<u16>,    /// The host that the debug adapter is listening too    ///    /// Default: 127.0.0.1    pub host: Option<Ipv4Addr>,    /// The max amount of time in milliseconds to connect to a tcp DAP before returning an error    ///    /// Default: 2000ms    pub timeout: Option<u64>,} impl TCPHost {    /// Get the host or fallback to the default host    pub fn host(&self) -> Ipv4Addr {        self.host.unwrap_or_else(|| Ipv4Addr::new(127, 0, 0, 1))    }} /// Represents the attach request information of the debug adapter#[derive(Default, Deserialize, Serialize, PartialEq, Eq, JsonSchema, Clone, Debug)]pub struct AttachConfig {    /// The processId to attach to, if left empty we will show a process picker    pub process_id: Option<u32>,} /// Represents the launch request information of the debug adapter#[derive(Deserialize, Serialize, Default, PartialEq, Eq, JsonSchema, Clone, Debug)]pub struct LaunchConfig {    /// The program that you trying to debug    pub program: String,    /// The current working directory of your project    pub cwd: Option<PathBuf>,    /// Arguments to pass to a debuggee    #[serde(default)]    pub args: Vec<String>,} /// Represents the type that will determine which request to call on the debug adapter#[derive(Deserialize, Serialize, PartialEq, Eq, JsonSchema, Clone, Debug)]#[serde(rename_all = "lowercase", untagged)]pub enum DebugRequestType {    /// Call the `launch` request on the debug adapter    Launch(LaunchConfig),    /// Call the `attach` request on the debug adapter    Attach(AttachConfig),} impl From<LaunchConfig> for DebugRequestType {    fn from(launch_config: LaunchConfig) -> Self {        DebugRequestType::Launch(launch_config)    }} impl From<AttachConfig> for DebugRequestType {    fn from(attach_config: AttachConfig) -> Self {        DebugRequestType::Attach(attach_config)    }}/// Represents a request for starting the debugger./// Contrary to `DebugRequestType`, `DebugRequestDisposition` is not Serializable.#[derive(PartialEq, Eq, Clone, Debug)]pub enum DebugRequestDisposition {    /// Debug session configured by the user.    UserConfigured(DebugRequestType),    /// Debug session configured by the debug adapter    ReverseRequest(StartDebuggingRequestArguments),} impl DebugRequestDisposition {    /// Get the current working directory from request if it's a launch request and exits    pub fn cwd(&self) -> Option<PathBuf> {        match self {            Self::UserConfigured(DebugRequestType::Launch(launch_config)) => {                launch_config.cwd.clone()            }            _ => None,        }    }}/// Represents the configuration for the debug adapter#[derive(PartialEq, Eq, Clone, Debug)]pub struct DebugAdapterConfig {    /// Name of the debug task    pub label: String,    /// The type of adapter you want to use    pub adapter: String,    /// The type of request that should be called on the debug adapter    pub request: DebugRequestDisposition,    /// Additional initialization arguments to be sent on DAP initialization    pub initialize_args: Option<serde_json::Value>,    /// Optional TCP connection information    ///    /// If provided, this will be used to connect to the debug adapter instead of    /// spawning a new process. This is useful for connecting to a debug adapter    /// that is already running or is started by another process.    pub tcp_connection: Option<TCPHost>,    /// What Locator to use to configure the debug task    pub locator: Option<String>,    /// Whether to tell the debug adapter to stop on entry    pub stop_on_entry: Option<bool>,} impl From<DebugTaskDefinition> for DebugAdapterConfig {    fn from(def: DebugTaskDefinition) -> Self {        Self {            label: def.label,            adapter: def.adapter,            request: DebugRequestDisposition::UserConfigured(def.request),            initialize_args: def.initialize_args,            tcp_connection: def.tcp_connection,            locator: def.locator,            stop_on_entry: def.stop_on_entry,        }    }} impl TryFrom<DebugAdapterConfig> for DebugTaskDefinition {    type Error = ();    fn try_from(def: DebugAdapterConfig) -> Result<Self, Self::Error> {        let request = match def.request {            DebugRequestDisposition::UserConfigured(debug_request_type) => debug_request_type,            DebugRequestDisposition::ReverseRequest(_) => return Err(()),        };         Ok(Self {            label: def.label,            adapter: def.adapter,            request,            initialize_args: def.initialize_args,            tcp_connection: def.tcp_connection,            locator: def.locator,            stop_on_entry: def.stop_on_entry,        })    }} impl TryFrom<TaskTemplate> for DebugTaskDefinition {    type Error = ();     fn try_from(value: TaskTemplate) -> Result<Self, Self::Error> {        let TaskType::Debug(debug_args) = value.task_type else {            return Err(());        };         let request = match debug_args.request {            crate::DebugArgsRequest::Launch => DebugRequestType::Launch(LaunchConfig {                program: value.command,                cwd: value.cwd.map(PathBuf::from),                args: value.args,            }),            crate::DebugArgsRequest::Attach(attach_config) => {                DebugRequestType::Attach(attach_config)            }        };         Ok(DebugTaskDefinition {            adapter: debug_args.adapter,            request,            label: value.label,            initialize_args: debug_args.initialize_args,            tcp_connection: debug_args.tcp_connection,            locator: debug_args.locator,            stop_on_entry: debug_args.stop_on_entry,        })    }} impl DebugTaskDefinition {    /// Translate from debug definition to a task template    pub fn to_zed_format(self) -> anyhow::Result<TaskTemplate> {        let (command, cwd, request) = match self.request {            DebugRequestType::Launch(launch_config) => (                launch_config.program,                launch_config                    .cwd                    .map(|cwd| cwd.to_string_lossy().to_string()),                crate::task_template::DebugArgsRequest::Launch,            ),            DebugRequestType::Attach(attach_config) => (                "".to_owned(),                None,                crate::task_template::DebugArgsRequest::Attach(attach_config),            ),        };         let task_type = TaskType::Debug(DebugArgs {            adapter: self.adapter,            request,            initialize_args: self.initialize_args,            locator: self.locator,            tcp_connection: self.tcp_connection,            stop_on_entry: self.stop_on_entry,        });         let label = self.label.clone();         Ok(TaskTemplate {            label,            command,            args: vec![],            task_type,            cwd,            ..Default::default()        })    }}/// Represents the type of the debugger adapter connection#[derive(Deserialize, Serialize, PartialEq, Eq, JsonSchema, Clone, Debug)]#[serde(rename_all = "lowercase", tag = "connection")]pub enum DebugConnectionType {    /// Connect to the debug adapter via TCP    TCP(TCPHost),    /// Connect to the debug adapter via STDIO    STDIO,} /// This struct represent a user created debug task#[derive(Deserialize, Serialize, PartialEq, Eq, JsonSchema, Clone, Debug)]#[serde(rename_all = "snake_case")]pub struct DebugTaskDefinition {    /// The adapter to run    pub adapter: String,    /// The type of request that should be called on the debug adapter    #[serde(flatten)]    pub request: DebugRequestType,    /// Name of the debug task    pub label: String,    /// Additional initialization arguments to be sent on DAP initialization    pub initialize_args: Option<serde_json::Value>,    /// Optional TCP connection information    ///    /// If provided, this will be used to connect to the debug adapter instead of    /// spawning a new process. This is useful for connecting to a debug adapter    /// that is already running or is started by another process.    pub tcp_connection: Option<TCPHost>,    /// Locator to use    /// -- cargo    pub locator: Option<String>,    /// Whether to tell the debug adapter to stop on entry    pub stop_on_entry: Option<bool>,} /// A group of Debug Tasks defined in a JSON file.#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]#[serde(transparent)]pub struct DebugTaskFile(pub Vec<DebugTaskDefinition>); impl DebugTaskFile {    /// Generates JSON schema of Tasks JSON template format.    pub fn generate_json_schema() -> serde_json_lenient::Value {        let schema = SchemaSettings::draft07()            .with(|settings| settings.option_add_null_type = false)            .into_generator()            .into_root_schema_for::<Self>();         serde_json_lenient::to_value(schema).unwrap()    }} impl TryFrom<DebugTaskFile> for TaskTemplates {    type Error = anyhow::Error;     fn try_from(value: DebugTaskFile) -> Result<Self, Self::Error> {        let templates = value            .0            .into_iter()            .filter_map(|debug_definition| debug_definition.to_zed_format().log_err())            .collect();         Ok(Self(templates))    }} #[cfg(test)]mod tests {    use crate::{DebugRequestType, LaunchConfig};     #[test]    fn test_can_deserialize_non_attach_task() {        let deserialized: DebugRequestType =            serde_json::from_str(r#"{"program": "cafebabe"}"#).unwrap();        assert_eq!(            deserialized,            DebugRequestType::Launch(LaunchConfig {                program: "cafebabe".to_owned(),                ..Default::default()            })        );    }}