sync_lsp/connection/jsonrpc/
message.rs

1use serde_repr::{Deserialize_repr, Serialize_repr};
2use std::fmt::{Formatter, Result as FmtResult};
3use serde::de::{Visitor, MapAccess, Deserializer, Error as SerdeError};
4use serde::{Serialize, Deserialize};
5use serde_json::Value;
6
7#[derive(Serialize, Deserialize, Debug, Clone, Hash, PartialEq, Eq)]
8#[serde(untagged)]
9pub(crate) enum MessageID {
10    Integer(u64),
11    String(String),
12    Null
13}
14
15#[derive(Deserialize, Serialize)]
16pub(crate) struct CancelParams {
17    pub(crate) id: MessageID
18}
19
20#[derive(Serialize, Deserialize, Debug)]
21pub(crate) struct EmptyParams {
22    
23}
24
25#[derive(Serialize, Deserialize, Debug)]
26pub(super) enum Version {
27    #[serde(rename = "2.0")]
28    Current
29}
30
31#[derive(Deserialize, Serialize, Debug)]
32pub(crate) struct Error {
33	pub code: ErrorCode,
34	pub message: String,
35	//pub data: T
36}
37
38/// Error codes used to either return a response or log to the client.
39#[repr(i32)]
40#[derive(Serialize_repr, Deserialize_repr, Debug, PartialEq)]
41pub enum ErrorCode {
42	// Defined by initialize
43	UnknownProtocolVersion = 1,
44
45    // Defined by JSON-RPC
46    ParseError = -32700,
47    InvalidRequest = -32600,
48    MethodNotFound = -32601,
49    InvalidParams = -32602,
50    InternalError = -32603,
51
52	ServerNotInitialized =-32002,
53    #[serde(other)]
54	UnknownErrorCode = -32001,
55	RequestFailed = -32803,
56	ServerCancelled = -32802,
57	ContentModified = -32801,
58	RequestCancelled = -32800,
59}
60
61#[derive(Serialize, Debug)]
62#[serde(untagged)]
63pub(super) enum Message {
64    Request {
65        jsonrpc: Version,
66        id: MessageID,
67        method: String,
68        params: Value
69    },
70    Notification {
71        jsonrpc: Version,
72        method: String,
73        params: Value
74    },
75    Response {
76        jsonrpc: Version,
77        id: MessageID,
78        result: Value
79    },
80    Error {
81        jsonrpc: Version,
82        id: MessageID,
83        error: Error
84    }
85}
86
87struct MessageVisitor;
88
89#[derive(Deserialize)]
90#[serde(field_identifier, rename_all = "camelCase")]
91enum MessageField {
92    Jsonrpc,
93    Id,
94    Method,
95    Params,
96    Result,
97    Error
98}
99
100impl<'a> Deserialize<'a> for Message where  {
101    fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D::Error> {
102        deserializer.deserialize_map(MessageVisitor)
103    }
104}
105
106impl<'a> Visitor<'a> for MessageVisitor {
107    type Value = Message;
108
109    fn expecting(&self, formatter: &mut Formatter) -> FmtResult {
110        formatter.write_str("Hello world")
111    }
112
113    fn visit_map<A: MapAccess<'a>>(self, mut map: A) -> Result<Self::Value, A::Error> {
114
115        let mut jsonrpc = None::<Version>;
116        let mut id = None::<MessageID>;
117        let mut method = None::<String>;
118        let mut params = None::<Value>;
119        let mut result = None::<Value>;
120        let mut error = None::<Error>;
121
122        while let Some(key) = map.next_key()? {
123            match key {
124                MessageField::Jsonrpc => {
125                    if jsonrpc.is_some() {
126                        return Err(SerdeError::duplicate_field("jsonrpc"))
127                    }
128                    jsonrpc = Some(map.next_value()?);
129                },
130                MessageField::Id => {
131                    if id.is_some() {
132                        return Err(SerdeError::duplicate_field("id"))
133                    }
134                    id = Some(map.next_value()?);
135                },
136                MessageField::Method => {
137                    if method.is_some() {
138                        return Err(SerdeError::duplicate_field("method"))
139                    }
140                    method = Some(map.next_value()?)
141                }
142                MessageField::Params => {
143                    if params.is_some() {
144                        return Err(SerdeError::duplicate_field("params"))
145                    }
146                    params = Some(map.next_value()?)
147                }
148                MessageField::Result => {
149                    if result.is_some() {
150                        return Err(SerdeError::duplicate_field("result"))
151                    }
152                    result = Some(map.next_value()?)
153                }
154                MessageField::Error => {
155                    if error.is_some() {
156                        return Err(SerdeError::duplicate_field("error"))
157                    }
158                    error = Some(map.next_value()?)
159                }
160            }
161        }
162
163        let Some(jsonrpc) = jsonrpc else {
164            return Err(SerdeError::missing_field("jsonrpc"))
165        };
166
167        if let Some(params) = params {
168            let fields = &["jsonrpc", "id", "method", "params"];
169            
170            let Some(method) = method else { return Err(SerdeError::missing_field("method")) };
171            if error.is_some() { return Err(SerdeError::unknown_field("error", fields)) }
172            if result.is_some() { return Err(SerdeError::unknown_field("result", fields)) }
173
174            if let Some(id) = id {
175                return Ok(Message::Request { jsonrpc, id, method, params })
176            } else {
177                return Ok(Message::Notification { jsonrpc, method, params })
178            }
179        }
180
181        if let Some(result) = result {
182            let fields = &["jsonrpc", "id", "result"];
183
184            let Some(id) = id else { return Err(SerdeError::missing_field("id")) };
185            if error.is_some() { return Err(SerdeError::unknown_field("error", fields)) }
186            if params.is_some() { return Err(SerdeError::unknown_field("params", fields)) }
187            if method.is_some() { return Err(SerdeError::unknown_field("method", fields)) }
188
189            return Ok(Message::Response { jsonrpc, id, result })
190        }
191
192        if let Some(error) = error {
193            let fields = &["jsonrpc", "id", "error"];
194
195            let Some(id) = id else { return Err(SerdeError::missing_field("id")) };
196            if result.is_some() { return Err(SerdeError::unknown_field("result", fields)) }
197            if params.is_some() { return Err(SerdeError::unknown_field("params", fields)) }
198            if method.is_some() { return Err(SerdeError::unknown_field("method", fields)) }
199
200            return Ok(Message::Error { jsonrpc, id, error })
201        }
202
203        Err(SerdeError::unknown_variant("unknown", &["notification" ,"request", "result", "error"]))
204    }
205}
sync_lsp/connection/jsonrpc/message.rs

sync_lsp/connection/jsonrpc/
message.rs
