debugger: More tidy up for SSH (#28993)

Split `locator` out of DebugTaskDefinition to make it clearer when
location needs to happen.

Release Notes:

- N/A

---------

Co-authored-by: Anthony Eid <hello@anthonyeid.me>
Co-authored-by: Anthony <anthony@zed.dev>
Co-authored-by: Cole Miller <m@cole-miller.net>

crates/task/src/debug_format.rs

@@ -1,21 +1,14 @@
-use dap_types::StartDebuggingRequestArguments;
+use anyhow::Result;
 use schemars::{JsonSchema, r#gen::SchemaSettings};
 use serde::{Deserialize, Serialize};
-use std::net::Ipv4Addr;
 use std::path::PathBuf;
-use util::ResultExt;
+use std::{net::Ipv4Addr, path::Path};
 
-use crate::{TaskTemplate, TaskTemplates, TaskType, task_template::DebugArgs};
-
-impl Default for DebugConnectionType {
-    fn default() -> Self {
-        DebugConnectionType::TCP(TCPHost::default())
-    }
-}
+use crate::{TaskTemplate, TaskType, task_template::DebugArgs};
 
 /// Represents the host information of the debug adapter
 #[derive(Default, Deserialize, Serialize, PartialEq, Eq, JsonSchema, Clone, Debug)]
-pub struct TCPHost {
+pub struct TcpArgumentsTemplate {
     /// The port that the debug adapter is listening on
     ///
     /// Default: We will try to find an open port
@@ -30,23 +23,39 @@ pub struct TCPHost {
     pub timeout: Option<u64>,
 }
 
-impl TCPHost {
+impl TcpArgumentsTemplate {
     /// 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))
     }
+
+    pub fn from_proto(proto: proto::TcpHost) -> Result<Self> {
+        Ok(Self {
+            port: proto.port.map(|p| p.try_into()).transpose()?,
+            host: proto.host.map(|h| h.parse()).transpose()?,
+            timeout: proto.timeout,
+        })
+    }
+
+    pub fn to_proto(&self) -> proto::TcpHost {
+        proto::TcpHost {
+            port: self.port.map(|p| p.into()),
+            host: self.host.map(|h| h.to_string()),
+            timeout: self.timeout,
+        }
+    }
 }
 
 /// Represents the attach request information of the debug adapter
 #[derive(Default, Deserialize, Serialize, PartialEq, Eq, JsonSchema, Clone, Debug)]
-pub struct AttachConfig {
+pub struct AttachRequest {
     /// 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 {
+pub struct LaunchRequest {
     /// The program that you trying to debug
     pub program: String,
     /// The current working directory of your project
@@ -59,47 +68,26 @@ pub struct LaunchConfig {
 /// 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 {
+pub enum DebugRequest {
     /// Call the `launch` request on the debug adapter
-    Launch(LaunchConfig),
+    Launch(LaunchRequest),
     /// Call the `attach` request on the debug adapter
-    Attach(AttachConfig),
+    Attach(AttachRequest),
 }
 
-impl From<LaunchConfig> for DebugRequestType {
-    fn from(launch_config: LaunchConfig) -> Self {
-        DebugRequestType::Launch(launch_config)
+impl From<LaunchRequest> for DebugRequest {
+    fn from(launch_config: LaunchRequest) -> Self {
+        DebugRequest::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,
-        }
+impl From<AttachRequest> for DebugRequest {
+    fn from(attach_config: AttachRequest) -> Self {
+        DebugRequest::Attach(attach_config)
     }
 }
 
-impl TryFrom<TaskTemplate> for DebugTaskDefinition {
+impl TryFrom<TaskTemplate> for DebugTaskTemplate {
     type Error = ();
 
     fn try_from(value: TaskTemplate) -> Result<Self, Self::Error> {
@@ -108,40 +96,40 @@ impl TryFrom<TaskTemplate> for DebugTaskDefinition {
         };
 
         let request = match debug_args.request {
-            crate::DebugArgsRequest::Launch => DebugRequestType::Launch(LaunchConfig {
+            crate::DebugArgsRequest::Launch => DebugRequest::Launch(LaunchRequest {
                 program: value.command,
                 cwd: value.cwd.map(PathBuf::from),
                 args: value.args,
             }),
-            crate::DebugArgsRequest::Attach(attach_config) => {
-                DebugRequestType::Attach(attach_config)
-            }
+            crate::DebugArgsRequest::Attach(attach_config) => DebugRequest::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,
+        Ok(DebugTaskTemplate {
             locator: debug_args.locator,
-            stop_on_entry: debug_args.stop_on_entry,
+            definition: DebugTaskDefinition {
+                adapter: debug_args.adapter,
+                request,
+                label: value.label,
+                initialize_args: debug_args.initialize_args,
+                tcp_connection: debug_args.tcp_connection,
+                stop_on_entry: debug_args.stop_on_entry,
+            },
         })
     }
 }
 
-impl DebugTaskDefinition {
+impl DebugTaskTemplate {
     /// 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) => (
+    pub fn to_zed_format(self) -> TaskTemplate {
+        let (command, cwd, request) = match self.definition.request {
+            DebugRequest::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) => (
+            DebugRequest::Attach(attach_config) => (
                 "".to_owned(),
                 None,
                 crate::task_template::DebugArgsRequest::Attach(attach_config),
@@ -149,34 +137,33 @@ impl DebugTaskDefinition {
         };
 
         let task_type = TaskType::Debug(DebugArgs {
-            adapter: self.adapter,
+            adapter: self.definition.adapter,
             request,
-            initialize_args: self.initialize_args,
+            initialize_args: self.definition.initialize_args,
             locator: self.locator,
-            tcp_connection: self.tcp_connection,
-            stop_on_entry: self.stop_on_entry,
+            tcp_connection: self.definition.tcp_connection,
+            stop_on_entry: self.definition.stop_on_entry,
         });
 
-        let label = self.label.clone();
+        let label = self.definition.label.clone();
 
-        Ok(TaskTemplate {
+        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,
+#[serde(rename_all = "snake_case")]
+pub struct DebugTaskTemplate {
+    pub locator: Option<String>,
+    #[serde(flatten)]
+    pub definition: DebugTaskDefinition,
 }
 
 /// This struct represent a user created debug task
@@ -187,7 +174,7 @@ pub struct DebugTaskDefinition {
     pub adapter: String,
     /// The type of request that should be called on the debug adapter
     #[serde(flatten)]
-    pub request: DebugRequestType,
+    pub request: DebugRequest,
     /// Name of the debug task
     pub label: String,
     /// Additional initialization arguments to be sent on DAP initialization
@@ -197,18 +184,83 @@ pub struct DebugTaskDefinition {
     /// 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>,
+    pub tcp_connection: Option<TcpArgumentsTemplate>,
     /// Whether to tell the debug adapter to stop on entry
     pub stop_on_entry: Option<bool>,
 }
 
+impl DebugTaskDefinition {
+    pub fn cwd(&self) -> Option<&Path> {
+        if let DebugRequest::Launch(config) = &self.request {
+            config.cwd.as_deref()
+        } else {
+            None
+        }
+    }
+    pub fn to_proto(&self) -> proto::DebugTaskDefinition {
+        proto::DebugTaskDefinition {
+            adapter: self.adapter.clone(),
+            request: Some(match &self.request {
+                DebugRequest::Launch(config) => {
+                    proto::debug_task_definition::Request::DebugLaunchRequest(
+                        proto::DebugLaunchRequest {
+                            program: config.program.clone(),
+                            cwd: config.cwd.as_ref().map(|c| c.to_string_lossy().to_string()),
+                            args: config.args.clone(),
+                        },
+                    )
+                }
+                DebugRequest::Attach(attach_request) => {
+                    proto::debug_task_definition::Request::DebugAttachRequest(
+                        proto::DebugAttachRequest {
+                            process_id: attach_request.process_id.unwrap_or_default(),
+                        },
+                    )
+                }
+            }),
+            label: self.label.clone(),
+            initialize_args: self.initialize_args.as_ref().map(|v| v.to_string()),
+            tcp_connection: self.tcp_connection.as_ref().map(|t| t.to_proto()),
+            stop_on_entry: self.stop_on_entry,
+        }
+    }
+
+    pub fn from_proto(proto: proto::DebugTaskDefinition) -> Result<Self> {
+        let request = proto
+            .request
+            .ok_or_else(|| anyhow::anyhow!("request is required"))?;
+        Ok(Self {
+            label: proto.label,
+            initialize_args: proto.initialize_args.map(|v| v.into()),
+            tcp_connection: proto
+                .tcp_connection
+                .map(TcpArgumentsTemplate::from_proto)
+                .transpose()?,
+            stop_on_entry: proto.stop_on_entry,
+            adapter: proto.adapter.clone(),
+            request: match request {
+                proto::debug_task_definition::Request::DebugAttachRequest(config) => {
+                    DebugRequest::Attach(AttachRequest {
+                        process_id: Some(config.process_id),
+                    })
+                }
+
+                proto::debug_task_definition::Request::DebugLaunchRequest(config) => {
+                    DebugRequest::Launch(LaunchRequest {
+                        program: config.program,
+                        cwd: config.cwd.map(|cwd| cwd.into()),
+                        args: config.args,
+                    })
+                }
+            },
+        })
+    }
+}
+
 /// 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>);
+pub struct DebugTaskFile(pub Vec<DebugTaskTemplate>);
 
 impl DebugTaskFile {
     /// Generates JSON schema of Tasks JSON template format.
@@ -222,31 +274,17 @@ impl DebugTaskFile {
     }
 }
 
-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};
+    use crate::{DebugRequest, LaunchRequest};
 
     #[test]
     fn test_can_deserialize_non_attach_task() {
-        let deserialized: DebugRequestType =
+        let deserialized: DebugRequest =
             serde_json::from_str(r#"{"program": "cafebabe"}"#).unwrap();
         assert_eq!(
             deserialized,
-            DebugRequestType::Launch(LaunchConfig {
+            DebugRequest::Launch(LaunchRequest {
                 program: "cafebabe".to_owned(),
                 ..Default::default()
             })