lsp-types-max 26.6.8

Types for interaction with a language server, using VSCode's Language Server Protocol
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use crate::types::NumberOrString;
use serde::{de, Deserialize, Deserializer, Serialize, Serializer};

/// A request message to describe a request between the client and the server.
/// Every request starts with an internal id.
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
pub struct RequestMessage {
    /// The protocol version. Always "2.0"
    pub jsonrpc: String,

    /// The request id.
    pub id: NumberOrString,

    /// The method to be invoked.
    pub method: String,

    /// The method's params.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub params: Option<serde_json::Value>,
}

/// A response message is sent as a result of a request.
#[derive(Debug, PartialEq, Clone)]
pub enum ResponseMessage {
    Success {
        /// The protocol version. Always "2.0"
        jsonrpc: String,
        /// The request id.
        id: Option<NumberOrString>,
        /// The result of a request.
        result: serde_json::Value,
    },
    Error {
        /// The protocol version. Always "2.0"
        jsonrpc: String,
        /// The request id.
        id: Option<NumberOrString>,
        /// The error object in case a request fails.
        error: ResponseError,
    },
}

impl Serialize for ResponseMessage {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        use serde::ser::SerializeStruct;
        let mut state = serializer.serialize_struct("ResponseMessage", 3)?;
        match self {
            ResponseMessage::Success {
                jsonrpc,
                id,
                result,
            } => {
                state.serialize_field("jsonrpc", jsonrpc)?;
                state.serialize_field("id", id)?;
                state.serialize_field("result", result)?;
            }
            ResponseMessage::Error { jsonrpc, id, error } => {
                state.serialize_field("jsonrpc", jsonrpc)?;
                state.serialize_field("id", id)?;
                state.serialize_field("error", error)?;
            }
        }
        state.end()
    }
}

impl<'de> Deserialize<'de> for ResponseMessage {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let value = serde_json::Value::deserialize(deserializer)?;

        let jsonrpc = value
            .get("jsonrpc")
            .and_then(|v| v.as_str())
            .ok_or_else(|| de::Error::missing_field("jsonrpc"))?
            .to_string();

        let id_val = value
            .get("id")
            .ok_or_else(|| de::Error::missing_field("id"))?;
        let id = if id_val.is_null() {
            None
        } else {
            Some(serde_json::from_value(id_val.clone()).map_err(de::Error::custom)?)
        };

        let has_result = value.get("result").is_some();
        let has_error = value.get("error").is_some();

        if has_result && has_error {
            return Err(de::Error::custom(
                "ResponseMessage cannot contain both 'result' and 'error'",
            ));
        } else if !has_result && !has_error {
            return Err(de::Error::custom(
                "ResponseMessage must contain either 'result' or 'error'",
            ));
        }

        if has_result {
            let result = value.get("result").unwrap().clone();
            Ok(ResponseMessage::Success {
                jsonrpc,
                id,
                result,
            })
        } else {
            let error = serde_json::from_value(value.get("error").unwrap().clone())
                .map_err(de::Error::custom)?;
            Ok(ResponseMessage::Error { jsonrpc, id, error })
        }
    }
}

/// A NotificationMessage works like an event and does not send a response back.
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
pub struct NotificationMessage {
    /// The protocol version. Always "2.0"
    pub jsonrpc: String,

    /// The method to be invoked.
    pub method: String,

    /// The notification's params.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub params: Option<serde_json::Value>,
}

/// The error object in case a request fails.
#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
pub struct ResponseError {
    /// A number indicating the error type that occurred.
    pub code: i32,

    /// A string providing a short description of the error.
    pub message: String,

    /// A primitive or structured value that contains additional
    /// information about the error. Can be omitted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub data: Option<serde_json::Value>,
}