1use crate::{ErrorCode, Message, RequestId};
2use serde::{Deserialize, Serialize};
3
4#[derive(Debug, Serialize, Deserialize, Clone)]
5pub struct Response {
6 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);