bsp_server/
response.rs

1use crate::{ErrorCode, Message, RequestId};
2use serde::{Deserialize, Serialize};
3
4#[derive(Debug, Serialize, Deserialize, Clone)]
5pub struct Response {
6    // JSON RPC allows this to be null if it was impossible
7    // to decode the request's id. Ignore this special case
8    // and just die horribly.
9    pub id: RequestId,
10    #[serde(skip_serializing_if = "Option::is_none")]
11    pub result: Option<serde_json::Value>,
12    #[serde(skip_serializing_if = "Option::is_none")]
13    pub error: Option<ResponseError>,
14}
15
16#[derive(Debug, Serialize, Deserialize, Clone)]
17pub struct ResponseError {
18    pub code: i32,
19    pub message: String,
20    #[serde(skip_serializing_if = "Option::is_none")]
21    pub data: Option<serde_json::Value>,
22}
23
24impl Response {
25    pub fn ok<R: Serialize>(id: RequestId, result: R) -> Response {
26        Response {
27            id,
28            result: Some(serde_json::to_value(result).unwrap()),
29            error: None,
30        }
31    }
32
33    pub fn err(id: RequestId, code: i32, message: String) -> Response {
34        let error = ResponseError {
35            code,
36            message,
37            data: None,
38        };
39        Response {
40            id,
41            result: None,
42            error: Some(error),
43        }
44    }
45
46    pub fn parse_error(id: RequestId, message: String) -> Response {
47        Self::err(id, ErrorCode::ParseError as i32 as i32, message)
48    }
49
50    pub fn server_not_initialized(id: RequestId, message: String) -> Response {
51        Self::err(id, ErrorCode::ServerNotInitialized as i32, message)
52    }
53
54    pub fn invalid_request(id: RequestId, message: String) -> Response {
55        Self::err(id, ErrorCode::InvalidRequest as i32 as i32, message)
56    }
57
58    pub fn method_not_found(id: RequestId, message: String) -> Response {
59        Self::err(id, ErrorCode::MethodNotFound as i32 as i32, message)
60    }
61
62    pub fn invalid_params(id: RequestId, message: String) -> Response {
63        Self::err(id, ErrorCode::InvalidParams as i32 as i32, message)
64    }
65
66    pub fn internal_error(id: RequestId, message: String) -> Response {
67        Self::err(id, ErrorCode::InternalError as i32 as i32, message)
68    }
69
70    pub fn server_error_start(id: RequestId, message: String) -> Response {
71        Self::err(id, ErrorCode::ServerErrorStart as i32 as i32, message)
72    }
73
74    pub fn server_error_end(id: RequestId, message: String) -> Response {
75        Self::err(id, ErrorCode::ServerErrorEnd as i32 as i32, message)
76    }
77
78    pub fn request_canceled(id: RequestId, message: String) -> Response {
79        Self::err(id, ErrorCode::RequestCanceled as i32 as i32, message)
80    }
81
82    pub fn content_modified(id: RequestId, message: String) -> Response {
83        Self::err(id, ErrorCode::ContentModified as i32 as i32, message)
84    }
85
86    pub fn server_canceled(id: RequestId, message: String) -> Response {
87        Self::err(id, ErrorCode::ServerCancelled as i32 as i32, message)
88    }
89}
90
91impl From<Response> for Message {
92    fn from(response: Response) -> Message {
93        Message::Response(response)
94    }
95}
96
97impl From<(RequestId, String)> for Message {
98    fn from(v: (RequestId, String)) -> Message {
99        Message::Response(Response::ok(v.0, v.1))
100    }
101}
102
103macro_rules! convertible {
104    ($type:path) => {
105        impl From<(RequestId, $type)> for Message {
106            fn from(v: (RequestId, $type)) -> Message {
107                Message::Response(Response::ok(v.0, v.1))
108            }
109        }
110    };
111}
112
113convertible!(bsp_types::InitializeBuildResult);
114convertible!(bsp_types::WorkspaceBuildTargetsResult);
115convertible!(serde_json::Value);
116convertible!(bsp_types::DebugSessionStartResult);
117convertible!(bsp_types::BuildTargetSourcesResult);
118convertible!(bsp_types::BuildTargetTestResult);
119convertible!(bsp_types::BuildTargetRunResult);
120convertible!(bsp_types::BuildTargetCompileResult);
121convertible!(bsp_types::BuildTargetResourcesResult);
122convertible!(bsp_types::BuildTargetDependencyModulesResult);
123convertible!(bsp_types::BuildTargetCleanCacheResult);
124convertible!(bsp_types::BuildTargetInverseSourcesResult);
125convertible!(bsp_types::BuildTargetDependencySourcesResult);