1 | /*! |
2 | |
3 | Language Server Protocol types for Rust. |
4 | |
5 | Based on: <https://microsoft.github.io/language-server-protocol/specification> |
6 | |
7 | This library uses the URL crate for parsing URIs. Note that there is |
8 | some confusion on the meaning of URLs vs URIs: |
9 | <http://stackoverflow.com/a/28865728/393898>. According to that |
10 | information, on the classical sense of "URLs", "URLs" are a subset of |
11 | URIs, But on the modern/new meaning of URLs, they are the same as |
12 | URIs. The important take-away aspect is that the URL crate should be |
13 | able to parse any URI, such as `urn:isbn:0451450523`. |
14 | |
15 | |
16 | */ |
17 | #![allow (non_upper_case_globals)] |
18 | #![forbid (unsafe_code)] |
19 | #[macro_use ] |
20 | extern crate bitflags; |
21 | |
22 | use std::{collections::HashMap, fmt::Debug}; |
23 | |
24 | use serde::{de, de::Error as Error_, Deserialize, Serialize}; |
25 | use serde_json::Value; |
26 | pub use url::Url; |
27 | |
28 | // Large enough to contain any enumeration name defined in this crate |
29 | type PascalCaseBuf = [u8; 32]; |
30 | const fn fmt_pascal_case_const(name: &str) -> (PascalCaseBuf, usize) { |
31 | let mut buf = [0; 32]; |
32 | let mut buf_i = 0; |
33 | let mut name_i = 0; |
34 | let name = name.as_bytes(); |
35 | while name_i < name.len() { |
36 | let first = name[name_i]; |
37 | name_i += 1; |
38 | |
39 | buf[buf_i] = first; |
40 | buf_i += 1; |
41 | |
42 | while name_i < name.len() { |
43 | let rest = name[name_i]; |
44 | name_i += 1; |
45 | if rest == b'_' { |
46 | break; |
47 | } |
48 | |
49 | buf[buf_i] = rest.to_ascii_lowercase(); |
50 | buf_i += 1; |
51 | } |
52 | } |
53 | (buf, buf_i) |
54 | } |
55 | |
56 | fn fmt_pascal_case(f: &mut std::fmt::Formatter<'_>, name: &str) -> std::fmt::Result { |
57 | for word: &str in name.split('_' ) { |
58 | let mut chars: Chars<'_> = word.chars(); |
59 | let first: char = chars.next().unwrap(); |
60 | write!(f, " {}" , first)?; |
61 | for rest: char in chars { |
62 | write!(f, " {}" , rest.to_lowercase())?; |
63 | } |
64 | } |
65 | Ok(()) |
66 | } |
67 | |
68 | macro_rules! lsp_enum { |
69 | (impl $typ: ident { $( $(#[$attr:meta])* pub const $name: ident : $enum_type: ty = $value: expr; )* }) => { |
70 | impl $typ { |
71 | $( |
72 | $(#[$attr])* |
73 | pub const $name: $enum_type = $value; |
74 | )* |
75 | } |
76 | |
77 | impl std::fmt::Debug for $typ { |
78 | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { |
79 | match *self { |
80 | $( |
81 | Self::$name => crate::fmt_pascal_case(f, stringify!($name)), |
82 | )* |
83 | _ => write!(f, "{}({})" , stringify!($typ), self.0), |
84 | } |
85 | } |
86 | } |
87 | |
88 | impl std::convert::TryFrom<&str> for $typ { |
89 | type Error = &'static str; |
90 | fn try_from(value: &str) -> Result<Self, Self::Error> { |
91 | match () { |
92 | $( |
93 | _ if { |
94 | const X: (crate::PascalCaseBuf, usize) = crate::fmt_pascal_case_const(stringify!($name)); |
95 | let (buf, len) = X; |
96 | &buf[..len] == value.as_bytes() |
97 | } => Ok(Self::$name), |
98 | )* |
99 | _ => Err("unknown enum variant" ), |
100 | } |
101 | } |
102 | } |
103 | |
104 | } |
105 | } |
106 | |
107 | pub mod error_codes; |
108 | pub mod notification; |
109 | pub mod request; |
110 | |
111 | mod call_hierarchy; |
112 | pub use call_hierarchy::*; |
113 | |
114 | mod code_action; |
115 | pub use code_action::*; |
116 | |
117 | mod code_lens; |
118 | pub use code_lens::*; |
119 | |
120 | mod color; |
121 | pub use color::*; |
122 | |
123 | mod completion; |
124 | pub use completion::*; |
125 | |
126 | mod document_diagnostic; |
127 | pub use document_diagnostic::*; |
128 | |
129 | mod document_highlight; |
130 | pub use document_highlight::*; |
131 | |
132 | mod document_link; |
133 | pub use document_link::*; |
134 | |
135 | mod document_symbols; |
136 | pub use document_symbols::*; |
137 | |
138 | mod file_operations; |
139 | pub use file_operations::*; |
140 | |
141 | mod folding_range; |
142 | pub use folding_range::*; |
143 | |
144 | mod formatting; |
145 | pub use formatting::*; |
146 | |
147 | mod hover; |
148 | pub use hover::*; |
149 | |
150 | mod inlay_hint; |
151 | pub use inlay_hint::*; |
152 | |
153 | mod inline_value; |
154 | pub use inline_value::*; |
155 | |
156 | #[cfg (feature = "proposed" )] |
157 | mod inline_completion; |
158 | #[cfg (feature = "proposed" )] |
159 | pub use inline_completion::*; |
160 | |
161 | mod moniker; |
162 | pub use moniker::*; |
163 | |
164 | mod progress; |
165 | pub use progress::*; |
166 | |
167 | mod references; |
168 | pub use references::*; |
169 | |
170 | mod rename; |
171 | pub use rename::*; |
172 | |
173 | pub mod selection_range; |
174 | pub use selection_range::*; |
175 | |
176 | mod semantic_tokens; |
177 | pub use semantic_tokens::*; |
178 | |
179 | mod signature_help; |
180 | pub use signature_help::*; |
181 | |
182 | mod type_hierarchy; |
183 | pub use type_hierarchy::*; |
184 | |
185 | mod linked_editing; |
186 | pub use linked_editing::*; |
187 | |
188 | mod window; |
189 | pub use window::*; |
190 | |
191 | mod workspace_diagnostic; |
192 | pub use workspace_diagnostic::*; |
193 | |
194 | mod workspace_folders; |
195 | pub use workspace_folders::*; |
196 | |
197 | mod workspace_symbols; |
198 | pub use workspace_symbols::*; |
199 | |
200 | pub mod lsif; |
201 | |
202 | mod trace; |
203 | pub use trace::*; |
204 | |
205 | /* ----------------- Auxiliary types ----------------- */ |
206 | |
207 | #[derive (Debug, Eq, Hash, PartialEq, Clone, Deserialize, Serialize)] |
208 | #[serde(untagged)] |
209 | pub enum NumberOrString { |
210 | Number(i32), |
211 | String(String), |
212 | } |
213 | |
214 | /* ----------------- Cancel support ----------------- */ |
215 | |
216 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
217 | pub struct CancelParams { |
218 | /// The request id to cancel. |
219 | pub id: NumberOrString, |
220 | } |
221 | |
222 | /* ----------------- Basic JSON Structures ----------------- */ |
223 | |
224 | /// The LSP any type |
225 | /// |
226 | /// @since 3.17.0 |
227 | pub type LSPAny = serde_json::Value; |
228 | |
229 | /// LSP object definition. |
230 | /// |
231 | /// @since 3.17.0 |
232 | pub type LSPObject = serde_json::Map<String, serde_json::Value>; |
233 | |
234 | /// LSP arrays. |
235 | /// |
236 | /// @since 3.17.0 |
237 | pub type LSPArray = Vec<serde_json::Value>; |
238 | |
239 | /// Position in a text document expressed as zero-based line and character offset. |
240 | /// A position is between two characters like an 'insert' cursor in a editor. |
241 | #[derive (Debug, Eq, PartialEq, Ord, PartialOrd, Copy, Clone, Default, Deserialize, Serialize, Hash)] |
242 | pub struct Position { |
243 | /// Line position in a document (zero-based). |
244 | pub line: u32, |
245 | /// Character offset on a line in a document (zero-based). The meaning of this |
246 | /// offset is determined by the negotiated `PositionEncodingKind`. |
247 | /// |
248 | /// If the character value is greater than the line length it defaults back |
249 | /// to the line length. |
250 | pub character: u32, |
251 | } |
252 | |
253 | impl Position { |
254 | pub fn new(line: u32, character: u32) -> Position { |
255 | Position { line, character } |
256 | } |
257 | } |
258 | |
259 | /// A range in a text document expressed as (zero-based) start and end positions. |
260 | /// A range is comparable to a selection in an editor. Therefore the end position is exclusive. |
261 | #[derive (Debug, Eq, PartialEq, Copy, Clone, Default, Deserialize, Serialize, Hash)] |
262 | pub struct Range { |
263 | /// The range's start position. |
264 | pub start: Position, |
265 | /// The range's end position. |
266 | pub end: Position, |
267 | } |
268 | |
269 | impl Range { |
270 | pub fn new(start: Position, end: Position) -> Range { |
271 | Range { start, end } |
272 | } |
273 | } |
274 | |
275 | /// Represents a location inside a resource, such as a line inside a text file. |
276 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize, Hash)] |
277 | pub struct Location { |
278 | pub uri: Url, |
279 | pub range: Range, |
280 | } |
281 | |
282 | impl Location { |
283 | pub fn new(uri: Url, range: Range) -> Location { |
284 | Location { uri, range } |
285 | } |
286 | } |
287 | |
288 | /// Represents a link between a source and a target location. |
289 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
290 | #[serde(rename_all = "camelCase" )] |
291 | pub struct LocationLink { |
292 | /// Span of the origin of this link. |
293 | /// |
294 | /// Used as the underlined span for mouse interaction. Defaults to the word range at |
295 | /// the mouse position. |
296 | #[serde(skip_serializing_if = "Option::is_none" )] |
297 | pub origin_selection_range: Option<Range>, |
298 | |
299 | /// The target resource identifier of this link. |
300 | pub target_uri: Url, |
301 | |
302 | /// The full target range of this link. |
303 | pub target_range: Range, |
304 | |
305 | /// The span of this link. |
306 | pub target_selection_range: Range, |
307 | } |
308 | |
309 | /// A type indicating how positions are encoded, |
310 | /// specifically what column offsets mean. |
311 | /// |
312 | /// @since 3.17.0 |
313 | #[derive (Debug, Eq, PartialEq, Hash, PartialOrd, Clone, Deserialize, Serialize)] |
314 | pub struct PositionEncodingKind(std::borrow::Cow<'static, str>); |
315 | |
316 | impl PositionEncodingKind { |
317 | /// Character offsets count UTF-8 code units. |
318 | pub const UTF8: PositionEncodingKind = PositionEncodingKind::new("utf-8" ); |
319 | |
320 | /// Character offsets count UTF-16 code units. |
321 | /// |
322 | /// This is the default and must always be supported |
323 | /// by servers |
324 | pub const UTF16: PositionEncodingKind = PositionEncodingKind::new("utf-16" ); |
325 | |
326 | /// Character offsets count UTF-32 code units. |
327 | /// |
328 | /// Implementation note: these are the same as Unicode code points, |
329 | /// so this `PositionEncodingKind` may also be used for an |
330 | /// encoding-agnostic representation of character offsets. |
331 | pub const UTF32: PositionEncodingKind = PositionEncodingKind::new("utf-32" ); |
332 | |
333 | pub const fn new(tag: &'static str) -> Self { |
334 | PositionEncodingKind(std::borrow::Cow::Borrowed(tag)) |
335 | } |
336 | |
337 | pub fn as_str(&self) -> &str { |
338 | &self.0 |
339 | } |
340 | } |
341 | |
342 | impl From<String> for PositionEncodingKind { |
343 | fn from(from: String) -> Self { |
344 | PositionEncodingKind(std::borrow::Cow::from(from)) |
345 | } |
346 | } |
347 | |
348 | impl From<&'static str> for PositionEncodingKind { |
349 | fn from(from: &'static str) -> Self { |
350 | PositionEncodingKind::new(tag:from) |
351 | } |
352 | } |
353 | |
354 | /// Represents a diagnostic, such as a compiler error or warning. |
355 | /// Diagnostic objects are only valid in the scope of a resource. |
356 | #[derive (Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] |
357 | #[serde(rename_all = "camelCase" )] |
358 | pub struct Diagnostic { |
359 | /// The range at which the message applies. |
360 | pub range: Range, |
361 | |
362 | /// The diagnostic's severity. Can be omitted. If omitted it is up to the |
363 | /// client to interpret diagnostics as error, warning, info or hint. |
364 | #[serde(skip_serializing_if = "Option::is_none" )] |
365 | pub severity: Option<DiagnosticSeverity>, |
366 | |
367 | /// The diagnostic's code. Can be omitted. |
368 | #[serde(skip_serializing_if = "Option::is_none" )] |
369 | pub code: Option<NumberOrString>, |
370 | |
371 | /// An optional property to describe the error code. |
372 | /// |
373 | /// @since 3.16.0 |
374 | #[serde(skip_serializing_if = "Option::is_none" )] |
375 | pub code_description: Option<CodeDescription>, |
376 | |
377 | /// A human-readable string describing the source of this |
378 | /// diagnostic, e.g. 'typescript' or 'super lint'. |
379 | #[serde(skip_serializing_if = "Option::is_none" )] |
380 | pub source: Option<String>, |
381 | |
382 | /// The diagnostic's message. |
383 | pub message: String, |
384 | |
385 | /// An array of related diagnostic information, e.g. when symbol-names within |
386 | /// a scope collide all definitions can be marked via this property. |
387 | #[serde(skip_serializing_if = "Option::is_none" )] |
388 | pub related_information: Option<Vec<DiagnosticRelatedInformation>>, |
389 | |
390 | /// Additional metadata about the diagnostic. |
391 | #[serde(skip_serializing_if = "Option::is_none" )] |
392 | pub tags: Option<Vec<DiagnosticTag>>, |
393 | |
394 | /// A data entry field that is preserved between a `textDocument/publishDiagnostics` |
395 | /// notification and `textDocument/codeAction` request. |
396 | /// |
397 | /// @since 3.16.0 |
398 | #[serde(skip_serializing_if = "Option::is_none" )] |
399 | pub data: Option<serde_json::Value>, |
400 | } |
401 | |
402 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
403 | #[serde(rename_all = "camelCase" )] |
404 | pub struct CodeDescription { |
405 | pub href: Url, |
406 | } |
407 | |
408 | impl Diagnostic { |
409 | pub fn new( |
410 | range: Range, |
411 | severity: Option<DiagnosticSeverity>, |
412 | code: Option<NumberOrString>, |
413 | source: Option<String>, |
414 | message: String, |
415 | related_information: Option<Vec<DiagnosticRelatedInformation>>, |
416 | tags: Option<Vec<DiagnosticTag>>, |
417 | ) -> Diagnostic { |
418 | Diagnostic { |
419 | range, |
420 | severity, |
421 | code, |
422 | source, |
423 | message, |
424 | related_information, |
425 | tags, |
426 | ..Diagnostic::default() |
427 | } |
428 | } |
429 | |
430 | pub fn new_simple(range: Range, message: String) -> Diagnostic { |
431 | Self::new(range, None, None, None, message, None, None) |
432 | } |
433 | |
434 | pub fn new_with_code_number( |
435 | range: Range, |
436 | severity: DiagnosticSeverity, |
437 | code_number: i32, |
438 | source: Option<String>, |
439 | message: String, |
440 | ) -> Diagnostic { |
441 | let code = Some(NumberOrString::Number(code_number)); |
442 | Self::new(range, Some(severity), code, source, message, None, None) |
443 | } |
444 | } |
445 | |
446 | /// The protocol currently supports the following diagnostic severities: |
447 | #[derive (Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Deserialize, Serialize)] |
448 | #[serde(transparent)] |
449 | pub struct DiagnosticSeverity(i32); |
450 | lsp_enum! { |
451 | impl DiagnosticSeverity { |
452 | /// Reports an error. |
453 | pub const ERROR: DiagnosticSeverity = DiagnosticSeverity(1); |
454 | /// Reports a warning. |
455 | pub const WARNING: DiagnosticSeverity = DiagnosticSeverity(2); |
456 | /// Reports an information. |
457 | pub const INFORMATION: DiagnosticSeverity = DiagnosticSeverity(3); |
458 | /// Reports a hint. |
459 | pub const HINT: DiagnosticSeverity = DiagnosticSeverity(4); |
460 | } |
461 | } |
462 | |
463 | /// Represents a related message and source code location for a diagnostic. This |
464 | /// should be used to point to code locations that cause or related to a |
465 | /// diagnostics, e.g when duplicating a symbol in a scope. |
466 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
467 | pub struct DiagnosticRelatedInformation { |
468 | /// The location of this related diagnostic information. |
469 | pub location: Location, |
470 | |
471 | /// The message of this related diagnostic information. |
472 | pub message: String, |
473 | } |
474 | |
475 | /// The diagnostic tags. |
476 | #[derive (Eq, PartialEq, Clone, Deserialize, Serialize)] |
477 | #[serde(transparent)] |
478 | pub struct DiagnosticTag(i32); |
479 | lsp_enum! { |
480 | impl DiagnosticTag { |
481 | /// Unused or unnecessary code. |
482 | /// Clients are allowed to render diagnostics with this tag faded out instead of having |
483 | /// an error squiggle. |
484 | pub const UNNECESSARY: DiagnosticTag = DiagnosticTag(1); |
485 | |
486 | /// Deprecated or obsolete code. |
487 | /// Clients are allowed to rendered diagnostics with this tag strike through. |
488 | pub const DEPRECATED: DiagnosticTag = DiagnosticTag(2); |
489 | } |
490 | } |
491 | |
492 | /// Represents a reference to a command. Provides a title which will be used to represent a command in the UI. |
493 | /// Commands are identified by a string identifier. The recommended way to handle commands is to implement |
494 | /// their execution on the server side if the client and server provides the corresponding capabilities. |
495 | /// Alternatively the tool extension code could handle the command. |
496 | /// The protocol currently doesn’t specify a set of well-known commands. |
497 | #[derive (Debug, PartialEq, Clone, Default, Deserialize, Serialize)] |
498 | pub struct Command { |
499 | /// Title of the command, like `save`. |
500 | pub title: String, |
501 | /// The identifier of the actual command handler. |
502 | pub command: String, |
503 | /// Arguments that the command handler should be |
504 | /// invoked with. |
505 | #[serde(skip_serializing_if = "Option::is_none" )] |
506 | pub arguments: Option<Vec<Value>>, |
507 | } |
508 | |
509 | impl Command { |
510 | pub fn new(title: String, command: String, arguments: Option<Vec<Value>>) -> Command { |
511 | Command { |
512 | title, |
513 | command, |
514 | arguments, |
515 | } |
516 | } |
517 | } |
518 | |
519 | /// A textual edit applicable to a text document. |
520 | /// |
521 | /// If n `TextEdit`s are applied to a text document all text edits describe changes to the initial document version. |
522 | /// Execution wise text edits should applied from the bottom to the top of the text document. Overlapping text edits |
523 | /// are not supported. |
524 | #[derive (Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] |
525 | #[serde(rename_all = "camelCase" )] |
526 | pub struct TextEdit { |
527 | /// The range of the text document to be manipulated. To insert |
528 | /// text into a document create a range where start === end. |
529 | pub range: Range, |
530 | /// The string to be inserted. For delete operations use an |
531 | /// empty string. |
532 | pub new_text: String, |
533 | } |
534 | |
535 | impl TextEdit { |
536 | pub fn new(range: Range, new_text: String) -> TextEdit { |
537 | TextEdit { range, new_text } |
538 | } |
539 | } |
540 | |
541 | /// An identifier referring to a change annotation managed by a workspace |
542 | /// edit. |
543 | /// |
544 | /// @since 3.16.0 |
545 | pub type ChangeAnnotationIdentifier = String; |
546 | |
547 | /// A special text edit with an additional change annotation. |
548 | /// |
549 | /// @since 3.16.0 |
550 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
551 | #[serde(rename_all = "camelCase" )] |
552 | pub struct AnnotatedTextEdit { |
553 | #[serde(flatten)] |
554 | pub text_edit: TextEdit, |
555 | |
556 | /// The actual annotation |
557 | pub annotation_id: ChangeAnnotationIdentifier, |
558 | } |
559 | |
560 | /// Describes textual changes on a single text document. The text document is referred to as a |
561 | /// `OptionalVersionedTextDocumentIdentifier` to allow clients to check the text document version before an |
562 | /// edit is applied. A `TextDocumentEdit` describes all changes on a version Si and after they are |
563 | /// applied move the document to version Si+1. So the creator of a `TextDocumentEdit` doesn't need to |
564 | /// sort the array or do any kind of ordering. However the edits must be non overlapping. |
565 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
566 | #[serde(rename_all = "camelCase" )] |
567 | pub struct TextDocumentEdit { |
568 | /// The text document to change. |
569 | pub text_document: OptionalVersionedTextDocumentIdentifier, |
570 | |
571 | /// The edits to be applied. |
572 | /// |
573 | /// @since 3.16.0 - support for AnnotatedTextEdit. This is guarded by the |
574 | /// client capability `workspace.workspaceEdit.changeAnnotationSupport` |
575 | pub edits: Vec<OneOf<TextEdit, AnnotatedTextEdit>>, |
576 | } |
577 | |
578 | /// Additional information that describes document changes. |
579 | /// |
580 | /// @since 3.16.0 |
581 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
582 | #[serde(rename_all = "camelCase" )] |
583 | pub struct ChangeAnnotation { |
584 | /// A human-readable string describing the actual change. The string |
585 | /// is rendered prominent in the user interface. |
586 | pub label: String, |
587 | |
588 | /// A flag which indicates that user confirmation is needed |
589 | /// before applying the change. |
590 | #[serde(skip_serializing_if = "Option::is_none" )] |
591 | pub needs_confirmation: Option<bool>, |
592 | |
593 | /// A human-readable string which is rendered less prominent in |
594 | /// the user interface. |
595 | #[serde(skip_serializing_if = "Option::is_none" )] |
596 | pub description: Option<String>, |
597 | } |
598 | |
599 | #[derive (Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] |
600 | #[serde(rename_all = "camelCase" )] |
601 | pub struct ChangeAnnotationWorkspaceEditClientCapabilities { |
602 | /// Whether the client groups edits with equal labels into tree nodes, |
603 | /// for instance all edits labelled with "Changes in Strings" would |
604 | /// be a tree node. |
605 | #[serde(skip_serializing_if = "Option::is_none" )] |
606 | pub groups_on_label: Option<bool>, |
607 | } |
608 | |
609 | /// Options to create a file. |
610 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
611 | #[serde(rename_all = "camelCase" )] |
612 | pub struct CreateFileOptions { |
613 | /// Overwrite existing file. Overwrite wins over `ignoreIfExists` |
614 | #[serde(skip_serializing_if = "Option::is_none" )] |
615 | pub overwrite: Option<bool>, |
616 | /// Ignore if exists. |
617 | #[serde(skip_serializing_if = "Option::is_none" )] |
618 | pub ignore_if_exists: Option<bool>, |
619 | } |
620 | |
621 | /// Create file operation |
622 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
623 | #[serde(rename_all = "camelCase" )] |
624 | pub struct CreateFile { |
625 | /// The resource to create. |
626 | pub uri: Url, |
627 | /// Additional options |
628 | #[serde(skip_serializing_if = "Option::is_none" )] |
629 | pub options: Option<CreateFileOptions>, |
630 | |
631 | /// An optional annotation identifier describing the operation. |
632 | /// |
633 | /// @since 3.16.0 |
634 | #[serde(skip_serializing_if = "Option::is_none" )] |
635 | pub annotation_id: Option<ChangeAnnotationIdentifier>, |
636 | } |
637 | |
638 | /// Rename file options |
639 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
640 | #[serde(rename_all = "camelCase" )] |
641 | pub struct RenameFileOptions { |
642 | /// Overwrite target if existing. Overwrite wins over `ignoreIfExists` |
643 | #[serde(skip_serializing_if = "Option::is_none" )] |
644 | pub overwrite: Option<bool>, |
645 | /// Ignores if target exists. |
646 | #[serde(skip_serializing_if = "Option::is_none" )] |
647 | pub ignore_if_exists: Option<bool>, |
648 | } |
649 | |
650 | /// Rename file operation |
651 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
652 | #[serde(rename_all = "camelCase" )] |
653 | pub struct RenameFile { |
654 | /// The old (existing) location. |
655 | pub old_uri: Url, |
656 | /// The new location. |
657 | pub new_uri: Url, |
658 | /// Rename options. |
659 | #[serde(skip_serializing_if = "Option::is_none" )] |
660 | pub options: Option<RenameFileOptions>, |
661 | |
662 | /// An optional annotation identifier describing the operation. |
663 | /// |
664 | /// @since 3.16.0 |
665 | #[serde(skip_serializing_if = "Option::is_none" )] |
666 | pub annotation_id: Option<ChangeAnnotationIdentifier>, |
667 | } |
668 | |
669 | /// Delete file options |
670 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
671 | #[serde(rename_all = "camelCase" )] |
672 | pub struct DeleteFileOptions { |
673 | /// Delete the content recursively if a folder is denoted. |
674 | #[serde(skip_serializing_if = "Option::is_none" )] |
675 | pub recursive: Option<bool>, |
676 | /// Ignore the operation if the file doesn't exist. |
677 | #[serde(skip_serializing_if = "Option::is_none" )] |
678 | pub ignore_if_not_exists: Option<bool>, |
679 | |
680 | /// An optional annotation identifier describing the operation. |
681 | /// |
682 | /// @since 3.16.0 |
683 | #[serde(skip_serializing_if = "Option::is_none" )] |
684 | pub annotation_id: Option<ChangeAnnotationIdentifier>, |
685 | } |
686 | |
687 | /// Delete file operation |
688 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
689 | #[serde(rename_all = "camelCase" )] |
690 | pub struct DeleteFile { |
691 | /// The file to delete. |
692 | pub uri: Url, |
693 | /// Delete options. |
694 | #[serde(skip_serializing_if = "Option::is_none" )] |
695 | pub options: Option<DeleteFileOptions>, |
696 | } |
697 | |
698 | /// A workspace edit represents changes to many resources managed in the workspace. |
699 | /// The edit should either provide `changes` or `documentChanges`. |
700 | /// If the client can handle versioned document edits and if `documentChanges` are present, |
701 | /// the latter are preferred over `changes`. |
702 | #[derive (Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] |
703 | #[serde(rename_all = "camelCase" )] |
704 | pub struct WorkspaceEdit { |
705 | /// Holds changes to existing resources. |
706 | #[serde(with = "url_map" )] |
707 | #[serde(skip_serializing_if = "Option::is_none" )] |
708 | #[serde(default)] |
709 | pub changes: Option<HashMap<Url, Vec<TextEdit>>>, // changes?: { [uri: string]: TextEdit[]; }; |
710 | |
711 | /// Depending on the client capability `workspace.workspaceEdit.resourceOperations` document changes |
712 | /// are either an array of `TextDocumentEdit`s to express changes to n different text documents |
713 | /// where each text document edit addresses a specific version of a text document. Or it can contain |
714 | /// above `TextDocumentEdit`s mixed with create, rename and delete file / folder operations. |
715 | /// |
716 | /// Whether a client supports versioned document edits is expressed via |
717 | /// `workspace.workspaceEdit.documentChanges` client capability. |
718 | /// |
719 | /// If a client neither supports `documentChanges` nor `workspace.workspaceEdit.resourceOperations` then |
720 | /// only plain `TextEdit`s using the `changes` property are supported. |
721 | #[serde(skip_serializing_if = "Option::is_none" )] |
722 | pub document_changes: Option<DocumentChanges>, |
723 | |
724 | /// A map of change annotations that can be referenced in |
725 | /// `AnnotatedTextEdit`s or create, rename and delete file / folder |
726 | /// operations. |
727 | /// |
728 | /// Whether clients honor this property depends on the client capability |
729 | /// `workspace.changeAnnotationSupport`. |
730 | /// |
731 | /// @since 3.16.0 |
732 | #[serde(skip_serializing_if = "Option::is_none" )] |
733 | pub change_annotations: Option<HashMap<ChangeAnnotationIdentifier, ChangeAnnotation>>, |
734 | } |
735 | |
736 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
737 | #[serde(untagged)] |
738 | pub enum DocumentChanges { |
739 | Edits(Vec<TextDocumentEdit>), |
740 | Operations(Vec<DocumentChangeOperation>), |
741 | } |
742 | |
743 | // TODO: Once https://github.com/serde-rs/serde/issues/912 is solved |
744 | // we can remove ResourceOp and switch to the following implementation |
745 | // of DocumentChangeOperation: |
746 | // |
747 | // #[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
748 | // #[serde(tag = "kind", rename_all="lowercase" )] |
749 | // pub enum DocumentChangeOperation { |
750 | // Create(CreateFile), |
751 | // Rename(RenameFile), |
752 | // Delete(DeleteFile), |
753 | // |
754 | // #[serde(other)] |
755 | // Edit(TextDocumentEdit), |
756 | // } |
757 | |
758 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
759 | #[serde(untagged, rename_all = "lowercase" )] |
760 | pub enum DocumentChangeOperation { |
761 | Op(ResourceOp), |
762 | Edit(TextDocumentEdit), |
763 | } |
764 | |
765 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
766 | #[serde(tag = "kind" , rename_all = "lowercase" )] |
767 | pub enum ResourceOp { |
768 | Create(CreateFile), |
769 | Rename(RenameFile), |
770 | Delete(DeleteFile), |
771 | } |
772 | |
773 | pub type DidChangeConfigurationClientCapabilities = DynamicRegistrationClientCapabilities; |
774 | |
775 | #[derive (Debug, Default, Eq, PartialEq, Clone, Deserialize, Serialize)] |
776 | #[serde(rename_all = "camelCase" )] |
777 | pub struct ConfigurationParams { |
778 | pub items: Vec<ConfigurationItem>, |
779 | } |
780 | |
781 | #[derive (Debug, Default, Eq, PartialEq, Clone, Deserialize, Serialize)] |
782 | #[serde(rename_all = "camelCase" )] |
783 | pub struct ConfigurationItem { |
784 | /// The scope to get the configuration section for. |
785 | #[serde(skip_serializing_if = "Option::is_none" )] |
786 | pub scope_uri: Option<Url>, |
787 | |
788 | ///The configuration section asked for. |
789 | #[serde(skip_serializing_if = "Option::is_none" )] |
790 | pub section: Option<String>, |
791 | } |
792 | |
793 | mod url_map { |
794 | use std::fmt; |
795 | use std::marker::PhantomData; |
796 | |
797 | use super::*; |
798 | |
799 | pub fn deserialize<'de, D, V>(deserializer: D) -> Result<Option<HashMap<Url, V>>, D::Error> |
800 | where |
801 | D: serde::Deserializer<'de>, |
802 | V: de::DeserializeOwned, |
803 | { |
804 | struct UrlMapVisitor<V> { |
805 | _marker: PhantomData<V>, |
806 | } |
807 | |
808 | impl<V: de::DeserializeOwned> Default for UrlMapVisitor<V> { |
809 | fn default() -> Self { |
810 | UrlMapVisitor { |
811 | _marker: PhantomData, |
812 | } |
813 | } |
814 | } |
815 | impl<'de, V: de::DeserializeOwned> de::Visitor<'de> for UrlMapVisitor<V> { |
816 | type Value = HashMap<Url, V>; |
817 | |
818 | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
819 | formatter.write_str("map" ) |
820 | } |
821 | |
822 | fn visit_map<M>(self, mut visitor: M) -> Result<Self::Value, M::Error> |
823 | where |
824 | M: de::MapAccess<'de>, |
825 | { |
826 | let mut values = HashMap::with_capacity(visitor.size_hint().unwrap_or(0)); |
827 | |
828 | // While there are entries remaining in the input, add them |
829 | // into our map. |
830 | while let Some((key, value)) = visitor.next_entry::<Url, _>()? { |
831 | values.insert(key, value); |
832 | } |
833 | |
834 | Ok(values) |
835 | } |
836 | } |
837 | |
838 | struct OptionUrlMapVisitor<V> { |
839 | _marker: PhantomData<V>, |
840 | } |
841 | impl<V: de::DeserializeOwned> Default for OptionUrlMapVisitor<V> { |
842 | fn default() -> Self { |
843 | OptionUrlMapVisitor { |
844 | _marker: PhantomData, |
845 | } |
846 | } |
847 | } |
848 | impl<'de, V: de::DeserializeOwned> de::Visitor<'de> for OptionUrlMapVisitor<V> { |
849 | type Value = Option<HashMap<Url, V>>; |
850 | |
851 | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
852 | formatter.write_str("option" ) |
853 | } |
854 | |
855 | #[inline ] |
856 | fn visit_unit<E>(self) -> Result<Self::Value, E> |
857 | where |
858 | E: serde::de::Error, |
859 | { |
860 | Ok(None) |
861 | } |
862 | |
863 | #[inline ] |
864 | fn visit_none<E>(self) -> Result<Self::Value, E> |
865 | where |
866 | E: serde::de::Error, |
867 | { |
868 | Ok(None) |
869 | } |
870 | |
871 | #[inline ] |
872 | fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error> |
873 | where |
874 | D: serde::Deserializer<'de>, |
875 | { |
876 | deserializer |
877 | .deserialize_map(UrlMapVisitor::<V>::default()) |
878 | .map(Some) |
879 | } |
880 | } |
881 | |
882 | // Instantiate our Visitor and ask the Deserializer to drive |
883 | // it over the input data, resulting in an instance of MyMap. |
884 | deserializer.deserialize_option(OptionUrlMapVisitor::default()) |
885 | } |
886 | |
887 | pub fn serialize<S, V>( |
888 | changes: &Option<HashMap<Url, V>>, |
889 | serializer: S, |
890 | ) -> Result<S::Ok, S::Error> |
891 | where |
892 | S: serde::Serializer, |
893 | V: serde::Serialize, |
894 | { |
895 | use serde::ser::SerializeMap; |
896 | |
897 | match *changes { |
898 | Some(ref changes) => { |
899 | let mut map = serializer.serialize_map(Some(changes.len()))?; |
900 | for (k, v) in changes { |
901 | map.serialize_entry(k.as_str(), v)?; |
902 | } |
903 | map.end() |
904 | } |
905 | None => serializer.serialize_none(), |
906 | } |
907 | } |
908 | } |
909 | |
910 | impl WorkspaceEdit { |
911 | pub fn new(changes: HashMap<Url, Vec<TextEdit>>) -> WorkspaceEdit { |
912 | WorkspaceEdit { |
913 | changes: Some(changes), |
914 | document_changes: None, |
915 | ..Default::default() |
916 | } |
917 | } |
918 | } |
919 | |
920 | /// Text documents are identified using a URI. On the protocol level, URIs are passed as strings. |
921 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
922 | pub struct TextDocumentIdentifier { |
923 | // !!!!!! Note: |
924 | // In the spec VersionedTextDocumentIdentifier extends TextDocumentIdentifier |
925 | // This modelled by "mixing-in" TextDocumentIdentifier in VersionedTextDocumentIdentifier, |
926 | // so any changes to this type must be effected in the sub-type as well. |
927 | /// The text document's URI. |
928 | pub uri: Url, |
929 | } |
930 | |
931 | impl TextDocumentIdentifier { |
932 | pub fn new(uri: Url) -> TextDocumentIdentifier { |
933 | TextDocumentIdentifier { uri } |
934 | } |
935 | } |
936 | |
937 | /// An item to transfer a text document from the client to the server. |
938 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
939 | #[serde(rename_all = "camelCase" )] |
940 | pub struct TextDocumentItem { |
941 | /// The text document's URI. |
942 | pub uri: Url, |
943 | |
944 | /// The text document's language identifier. |
945 | pub language_id: String, |
946 | |
947 | /// The version number of this document (it will strictly increase after each |
948 | /// change, including undo/redo). |
949 | pub version: i32, |
950 | |
951 | /// The content of the opened text document. |
952 | pub text: String, |
953 | } |
954 | |
955 | impl TextDocumentItem { |
956 | pub fn new(uri: Url, language_id: String, version: i32, text: String) -> TextDocumentItem { |
957 | TextDocumentItem { |
958 | uri, |
959 | language_id, |
960 | version, |
961 | text, |
962 | } |
963 | } |
964 | } |
965 | |
966 | /// An identifier to denote a specific version of a text document. This information usually flows from the client to the server. |
967 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
968 | pub struct VersionedTextDocumentIdentifier { |
969 | // This field was "mixed-in" from TextDocumentIdentifier |
970 | /// The text document's URI. |
971 | pub uri: Url, |
972 | |
973 | /// The version number of this document. |
974 | /// |
975 | /// The version number of a document will increase after each change, |
976 | /// including undo/redo. The number doesn't need to be consecutive. |
977 | pub version: i32, |
978 | } |
979 | |
980 | impl VersionedTextDocumentIdentifier { |
981 | pub fn new(uri: Url, version: i32) -> VersionedTextDocumentIdentifier { |
982 | VersionedTextDocumentIdentifier { uri, version } |
983 | } |
984 | } |
985 | |
986 | /// An identifier which optionally denotes a specific version of a text document. This information usually flows from the server to the client |
987 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
988 | pub struct OptionalVersionedTextDocumentIdentifier { |
989 | // This field was "mixed-in" from TextDocumentIdentifier |
990 | /// The text document's URI. |
991 | pub uri: Url, |
992 | |
993 | /// The version number of this document. If an optional versioned text document |
994 | /// identifier is sent from the server to the client and the file is not |
995 | /// open in the editor (the server has not received an open notification |
996 | /// before) the server can send `null` to indicate that the version is |
997 | /// known and the content on disk is the master (as specified with document |
998 | /// content ownership). |
999 | /// |
1000 | /// The version number of a document will increase after each change, |
1001 | /// including undo/redo. The number doesn't need to be consecutive. |
1002 | pub version: Option<i32>, |
1003 | } |
1004 | |
1005 | impl OptionalVersionedTextDocumentIdentifier { |
1006 | pub fn new(uri: Url, version: i32) -> OptionalVersionedTextDocumentIdentifier { |
1007 | OptionalVersionedTextDocumentIdentifier { |
1008 | uri, |
1009 | version: Some(version), |
1010 | } |
1011 | } |
1012 | } |
1013 | |
1014 | /// A parameter literal used in requests to pass a text document and a position inside that document. |
1015 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
1016 | #[serde(rename_all = "camelCase" )] |
1017 | pub struct TextDocumentPositionParams { |
1018 | // !!!!!! Note: |
1019 | // In the spec ReferenceParams extends TextDocumentPositionParams |
1020 | // This modelled by "mixing-in" TextDocumentPositionParams in ReferenceParams, |
1021 | // so any changes to this type must be effected in sub-type as well. |
1022 | /// The text document. |
1023 | pub text_document: TextDocumentIdentifier, |
1024 | |
1025 | /// The position inside the text document. |
1026 | pub position: Position, |
1027 | } |
1028 | |
1029 | impl TextDocumentPositionParams { |
1030 | pub fn new( |
1031 | text_document: TextDocumentIdentifier, |
1032 | position: Position, |
1033 | ) -> TextDocumentPositionParams { |
1034 | TextDocumentPositionParams { |
1035 | text_document, |
1036 | position, |
1037 | } |
1038 | } |
1039 | } |
1040 | |
1041 | /// A document filter denotes a document through properties like language, schema or pattern. |
1042 | /// Examples are a filter that applies to TypeScript files on disk or a filter the applies to JSON |
1043 | /// files with name package.json: |
1044 | /// |
1045 | /// { language: 'typescript', scheme: 'file' } |
1046 | /// { language: 'json', pattern: '**/package.json' } |
1047 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
1048 | pub struct DocumentFilter { |
1049 | /// A language id, like `typescript`. |
1050 | #[serde(skip_serializing_if = "Option::is_none" )] |
1051 | pub language: Option<String>, |
1052 | |
1053 | /// A Uri [scheme](#Uri.scheme), like `file` or `untitled`. |
1054 | #[serde(skip_serializing_if = "Option::is_none" )] |
1055 | pub scheme: Option<String>, |
1056 | |
1057 | /// A glob pattern, like `*.{ts,js}`. |
1058 | #[serde(skip_serializing_if = "Option::is_none" )] |
1059 | pub pattern: Option<String>, |
1060 | } |
1061 | |
1062 | /// A document selector is the combination of one or many document filters. |
1063 | pub type DocumentSelector = Vec<DocumentFilter>; |
1064 | |
1065 | // ========================= Actual Protocol ========================= |
1066 | |
1067 | #[derive (Debug, PartialEq, Clone, Deserialize, Serialize, Default)] |
1068 | #[serde(rename_all = "camelCase" )] |
1069 | pub struct InitializeParams { |
1070 | /// The process Id of the parent process that started |
1071 | /// the server. Is null if the process has not been started by another process. |
1072 | /// If the parent process is not alive then the server should exit (see exit notification) its process. |
1073 | pub process_id: Option<u32>, |
1074 | |
1075 | /// The rootPath of the workspace. Is null |
1076 | /// if no folder is open. |
1077 | #[serde(skip_serializing_if = "Option::is_none" )] |
1078 | #[deprecated (note = "Use `root_uri` instead when possible" )] |
1079 | pub root_path: Option<String>, |
1080 | |
1081 | /// The rootUri of the workspace. Is null if no |
1082 | /// folder is open. If both `rootPath` and `rootUri` are set |
1083 | /// `rootUri` wins. |
1084 | #[serde(default)] |
1085 | #[deprecated (note = "Use `workspace_folders` instead when possible" )] |
1086 | pub root_uri: Option<Url>, |
1087 | |
1088 | /// User provided initialization options. |
1089 | #[serde(skip_serializing_if = "Option::is_none" )] |
1090 | pub initialization_options: Option<Value>, |
1091 | |
1092 | /// The capabilities provided by the client (editor or tool) |
1093 | pub capabilities: ClientCapabilities, |
1094 | |
1095 | /// The initial trace setting. If omitted trace is disabled ('off'). |
1096 | #[serde(default)] |
1097 | #[serde(skip_serializing_if = "Option::is_none" )] |
1098 | pub trace: Option<TraceValue>, |
1099 | |
1100 | /// The workspace folders configured in the client when the server starts. |
1101 | /// This property is only available if the client supports workspace folders. |
1102 | /// It can be `null` if the client supports workspace folders but none are |
1103 | /// configured. |
1104 | #[serde(skip_serializing_if = "Option::is_none" )] |
1105 | pub workspace_folders: Option<Vec<WorkspaceFolder>>, |
1106 | |
1107 | /// Information about the client. |
1108 | #[serde(skip_serializing_if = "Option::is_none" )] |
1109 | pub client_info: Option<ClientInfo>, |
1110 | |
1111 | /// The locale the client is currently showing the user interface |
1112 | /// in. This must not necessarily be the locale of the operating |
1113 | /// system. |
1114 | /// |
1115 | /// Uses IETF language tags as the value's syntax |
1116 | /// (See <https://en.wikipedia.org/wiki/IETF_language_tag>) |
1117 | /// |
1118 | /// @since 3.16.0 |
1119 | #[serde(skip_serializing_if = "Option::is_none" )] |
1120 | pub locale: Option<String>, |
1121 | |
1122 | /// The LSP server may report about initialization progress to the client |
1123 | /// by using the following work done token if it was passed by the client. |
1124 | #[serde(flatten)] |
1125 | pub work_done_progress_params: WorkDoneProgressParams, |
1126 | } |
1127 | |
1128 | #[derive (Debug, PartialEq, Clone, Deserialize, Serialize)] |
1129 | pub struct ClientInfo { |
1130 | /// The name of the client as defined by the client. |
1131 | pub name: String, |
1132 | /// The client's version as defined by the client. |
1133 | #[serde(skip_serializing_if = "Option::is_none" )] |
1134 | pub version: Option<String>, |
1135 | } |
1136 | |
1137 | #[derive (Debug, PartialEq, Clone, Copy, Deserialize, Serialize)] |
1138 | pub struct InitializedParams {} |
1139 | |
1140 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
1141 | pub struct GenericRegistrationOptions { |
1142 | #[serde(flatten)] |
1143 | pub text_document_registration_options: TextDocumentRegistrationOptions, |
1144 | |
1145 | #[serde(flatten)] |
1146 | pub options: GenericOptions, |
1147 | |
1148 | #[serde(flatten)] |
1149 | pub static_registration_options: StaticRegistrationOptions, |
1150 | } |
1151 | |
1152 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
1153 | pub struct GenericOptions { |
1154 | #[serde(flatten)] |
1155 | pub work_done_progress_options: WorkDoneProgressOptions, |
1156 | } |
1157 | |
1158 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
1159 | pub struct GenericParams { |
1160 | #[serde(flatten)] |
1161 | pub text_document_position_params: TextDocumentPositionParams, |
1162 | |
1163 | #[serde(flatten)] |
1164 | pub work_done_progress_params: WorkDoneProgressParams, |
1165 | |
1166 | #[serde(flatten)] |
1167 | pub partial_result_params: PartialResultParams, |
1168 | } |
1169 | |
1170 | #[derive (Debug, Eq, PartialEq, Clone, Copy, Default, Deserialize, Serialize)] |
1171 | #[serde(rename_all = "camelCase" )] |
1172 | pub struct DynamicRegistrationClientCapabilities { |
1173 | /// This capability supports dynamic registration. |
1174 | #[serde(skip_serializing_if = "Option::is_none" )] |
1175 | pub dynamic_registration: Option<bool>, |
1176 | } |
1177 | |
1178 | #[derive (Debug, Eq, PartialEq, Clone, Copy, Default, Deserialize, Serialize)] |
1179 | #[serde(rename_all = "camelCase" )] |
1180 | pub struct GotoCapability { |
1181 | #[serde(skip_serializing_if = "Option::is_none" )] |
1182 | pub dynamic_registration: Option<bool>, |
1183 | |
1184 | /// The client supports additional metadata in the form of definition links. |
1185 | #[serde(skip_serializing_if = "Option::is_none" )] |
1186 | pub link_support: Option<bool>, |
1187 | } |
1188 | |
1189 | #[derive (Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] |
1190 | #[serde(rename_all = "camelCase" )] |
1191 | pub struct WorkspaceEditClientCapabilities { |
1192 | /// The client supports versioned document changes in `WorkspaceEdit`s |
1193 | #[serde(skip_serializing_if = "Option::is_none" )] |
1194 | pub document_changes: Option<bool>, |
1195 | |
1196 | /// The resource operations the client supports. Clients should at least |
1197 | /// support 'create', 'rename' and 'delete' files and folders. |
1198 | #[serde(skip_serializing_if = "Option::is_none" )] |
1199 | pub resource_operations: Option<Vec<ResourceOperationKind>>, |
1200 | |
1201 | /// The failure handling strategy of a client if applying the workspace edit fails. |
1202 | #[serde(skip_serializing_if = "Option::is_none" )] |
1203 | pub failure_handling: Option<FailureHandlingKind>, |
1204 | |
1205 | /// Whether the client normalizes line endings to the client specific |
1206 | /// setting. |
1207 | /// If set to `true` the client will normalize line ending characters |
1208 | /// in a workspace edit to the client specific new line character(s). |
1209 | /// |
1210 | /// @since 3.16.0 |
1211 | #[serde(skip_serializing_if = "Option::is_none" )] |
1212 | pub normalizes_line_endings: Option<bool>, |
1213 | |
1214 | /// Whether the client in general supports change annotations on text edits, |
1215 | /// create file, rename file and delete file changes. |
1216 | /// |
1217 | /// @since 3.16.0 |
1218 | #[serde(skip_serializing_if = "Option::is_none" )] |
1219 | pub change_annotation_support: Option<ChangeAnnotationWorkspaceEditClientCapabilities>, |
1220 | } |
1221 | |
1222 | #[derive (Debug, Eq, PartialEq, Deserialize, Serialize, Copy, Clone)] |
1223 | #[serde(rename_all = "lowercase" )] |
1224 | pub enum ResourceOperationKind { |
1225 | Create, |
1226 | Rename, |
1227 | Delete, |
1228 | } |
1229 | |
1230 | #[derive (Debug, Eq, PartialEq, Deserialize, Serialize, Copy, Clone)] |
1231 | #[serde(rename_all = "camelCase" )] |
1232 | pub enum FailureHandlingKind { |
1233 | Abort, |
1234 | Transactional, |
1235 | TextOnlyTransactional, |
1236 | Undo, |
1237 | } |
1238 | |
1239 | /// A symbol kind. |
1240 | #[derive (Eq, PartialEq, Copy, Clone, Serialize, Deserialize)] |
1241 | #[serde(transparent)] |
1242 | pub struct SymbolKind(i32); |
1243 | lsp_enum! { |
1244 | impl SymbolKind { |
1245 | pub const FILE: SymbolKind = SymbolKind(1); |
1246 | pub const MODULE: SymbolKind = SymbolKind(2); |
1247 | pub const NAMESPACE: SymbolKind = SymbolKind(3); |
1248 | pub const PACKAGE: SymbolKind = SymbolKind(4); |
1249 | pub const CLASS: SymbolKind = SymbolKind(5); |
1250 | pub const METHOD: SymbolKind = SymbolKind(6); |
1251 | pub const PROPERTY: SymbolKind = SymbolKind(7); |
1252 | pub const FIELD: SymbolKind = SymbolKind(8); |
1253 | pub const CONSTRUCTOR: SymbolKind = SymbolKind(9); |
1254 | pub const ENUM: SymbolKind = SymbolKind(10); |
1255 | pub const INTERFACE: SymbolKind = SymbolKind(11); |
1256 | pub const FUNCTION: SymbolKind = SymbolKind(12); |
1257 | pub const VARIABLE: SymbolKind = SymbolKind(13); |
1258 | pub const CONSTANT: SymbolKind = SymbolKind(14); |
1259 | pub const STRING: SymbolKind = SymbolKind(15); |
1260 | pub const NUMBER: SymbolKind = SymbolKind(16); |
1261 | pub const BOOLEAN: SymbolKind = SymbolKind(17); |
1262 | pub const ARRAY: SymbolKind = SymbolKind(18); |
1263 | pub const OBJECT: SymbolKind = SymbolKind(19); |
1264 | pub const KEY: SymbolKind = SymbolKind(20); |
1265 | pub const NULL: SymbolKind = SymbolKind(21); |
1266 | pub const ENUM_MEMBER: SymbolKind = SymbolKind(22); |
1267 | pub const STRUCT: SymbolKind = SymbolKind(23); |
1268 | pub const EVENT: SymbolKind = SymbolKind(24); |
1269 | pub const OPERATOR: SymbolKind = SymbolKind(25); |
1270 | pub const TYPE_PARAMETER: SymbolKind = SymbolKind(26); |
1271 | } |
1272 | } |
1273 | |
1274 | /// Specific capabilities for the `SymbolKind` in the `workspace/symbol` request. |
1275 | #[derive (Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] |
1276 | #[serde(rename_all = "camelCase" )] |
1277 | pub struct SymbolKindCapability { |
1278 | /// The symbol kind values the client supports. When this |
1279 | /// property exists the client also guarantees that it will |
1280 | /// handle values outside its set gracefully and falls back |
1281 | /// to a default value when unknown. |
1282 | /// |
1283 | /// If this property is not present the client only supports |
1284 | /// the symbol kinds from `File` to `Array` as defined in |
1285 | /// the initial version of the protocol. |
1286 | pub value_set: Option<Vec<SymbolKind>>, |
1287 | } |
1288 | |
1289 | /// Workspace specific client capabilities. |
1290 | #[derive (Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] |
1291 | #[serde(rename_all = "camelCase" )] |
1292 | pub struct WorkspaceClientCapabilities { |
1293 | /// The client supports applying batch edits to the workspace by supporting |
1294 | /// the request 'workspace/applyEdit' |
1295 | #[serde(skip_serializing_if = "Option::is_none" )] |
1296 | pub apply_edit: Option<bool>, |
1297 | |
1298 | /// Capabilities specific to `WorkspaceEdit`s |
1299 | #[serde(skip_serializing_if = "Option::is_none" )] |
1300 | pub workspace_edit: Option<WorkspaceEditClientCapabilities>, |
1301 | |
1302 | /// Capabilities specific to the `workspace/didChangeConfiguration` notification. |
1303 | #[serde(skip_serializing_if = "Option::is_none" )] |
1304 | pub did_change_configuration: Option<DidChangeConfigurationClientCapabilities>, |
1305 | |
1306 | /// Capabilities specific to the `workspace/didChangeWatchedFiles` notification. |
1307 | #[serde(skip_serializing_if = "Option::is_none" )] |
1308 | pub did_change_watched_files: Option<DidChangeWatchedFilesClientCapabilities>, |
1309 | |
1310 | /// Capabilities specific to the `workspace/symbol` request. |
1311 | #[serde(skip_serializing_if = "Option::is_none" )] |
1312 | pub symbol: Option<WorkspaceSymbolClientCapabilities>, |
1313 | |
1314 | /// Capabilities specific to the `workspace/executeCommand` request. |
1315 | #[serde(skip_serializing_if = "Option::is_none" )] |
1316 | pub execute_command: Option<ExecuteCommandClientCapabilities>, |
1317 | |
1318 | /// The client has support for workspace folders. |
1319 | /// |
1320 | /// @since 3.6.0 |
1321 | #[serde(skip_serializing_if = "Option::is_none" )] |
1322 | pub workspace_folders: Option<bool>, |
1323 | |
1324 | /// The client supports `workspace/configuration` requests. |
1325 | /// |
1326 | /// @since 3.6.0 |
1327 | #[serde(skip_serializing_if = "Option::is_none" )] |
1328 | pub configuration: Option<bool>, |
1329 | |
1330 | /// Capabilities specific to the semantic token requests scoped to the workspace. |
1331 | /// |
1332 | /// @since 3.16.0 |
1333 | #[serde(skip_serializing_if = "Option::is_none" )] |
1334 | pub semantic_tokens: Option<SemanticTokensWorkspaceClientCapabilities>, |
1335 | |
1336 | /// Capabilities specific to the code lens requests scoped to the workspace. |
1337 | /// |
1338 | /// @since 3.16.0 |
1339 | #[serde(skip_serializing_if = "Option::is_none" )] |
1340 | pub code_lens: Option<CodeLensWorkspaceClientCapabilities>, |
1341 | |
1342 | /// The client has support for file requests/notifications. |
1343 | /// |
1344 | /// @since 3.16.0 |
1345 | #[serde(skip_serializing_if = "Option::is_none" )] |
1346 | pub file_operations: Option<WorkspaceFileOperationsClientCapabilities>, |
1347 | |
1348 | /// Client workspace capabilities specific to inline values. |
1349 | /// |
1350 | /// @since 3.17.0 |
1351 | #[serde(skip_serializing_if = "Option::is_none" )] |
1352 | pub inline_value: Option<InlineValueWorkspaceClientCapabilities>, |
1353 | |
1354 | /// Client workspace capabilities specific to inlay hints. |
1355 | /// |
1356 | /// @since 3.17.0 |
1357 | #[serde(skip_serializing_if = "Option::is_none" )] |
1358 | pub inlay_hint: Option<InlayHintWorkspaceClientCapabilities>, |
1359 | |
1360 | /// Client workspace capabilities specific to diagnostics. |
1361 | /// since 3.17.0 |
1362 | #[serde(skip_serializing_if = "Option::is_none" )] |
1363 | pub diagnostic: Option<DiagnosticWorkspaceClientCapabilities>, |
1364 | } |
1365 | |
1366 | #[derive (Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] |
1367 | #[serde(rename_all = "camelCase" )] |
1368 | pub struct TextDocumentSyncClientCapabilities { |
1369 | /// Whether text document synchronization supports dynamic registration. |
1370 | #[serde(skip_serializing_if = "Option::is_none" )] |
1371 | pub dynamic_registration: Option<bool>, |
1372 | |
1373 | /// The client supports sending will save notifications. |
1374 | #[serde(skip_serializing_if = "Option::is_none" )] |
1375 | pub will_save: Option<bool>, |
1376 | |
1377 | /// The client supports sending a will save request and |
1378 | /// waits for a response providing text edits which will |
1379 | /// be applied to the document before it is saved. |
1380 | #[serde(skip_serializing_if = "Option::is_none" )] |
1381 | pub will_save_wait_until: Option<bool>, |
1382 | |
1383 | /// The client supports did save notifications. |
1384 | #[serde(skip_serializing_if = "Option::is_none" )] |
1385 | pub did_save: Option<bool>, |
1386 | } |
1387 | |
1388 | #[derive (Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] |
1389 | #[serde(rename_all = "camelCase" )] |
1390 | pub struct PublishDiagnosticsClientCapabilities { |
1391 | /// Whether the clients accepts diagnostics with related information. |
1392 | #[serde(skip_serializing_if = "Option::is_none" )] |
1393 | pub related_information: Option<bool>, |
1394 | |
1395 | /// Client supports the tag property to provide meta data about a diagnostic. |
1396 | /// Clients supporting tags have to handle unknown tags gracefully. |
1397 | #[serde( |
1398 | default, |
1399 | skip_serializing_if = "Option::is_none" , |
1400 | deserialize_with = "TagSupport::deserialize_compat" |
1401 | )] |
1402 | pub tag_support: Option<TagSupport<DiagnosticTag>>, |
1403 | |
1404 | /// Whether the client interprets the version property of the |
1405 | /// `textDocument/publishDiagnostics` notification's parameter. |
1406 | /// |
1407 | /// @since 3.15.0 |
1408 | #[serde(skip_serializing_if = "Option::is_none" )] |
1409 | pub version_support: Option<bool>, |
1410 | |
1411 | /// Client supports a codeDescription property |
1412 | /// |
1413 | /// @since 3.16.0 |
1414 | #[serde(skip_serializing_if = "Option::is_none" )] |
1415 | pub code_description_support: Option<bool>, |
1416 | |
1417 | /// Whether code action supports the `data` property which is |
1418 | /// preserved between a `textDocument/publishDiagnostics` and |
1419 | /// `textDocument/codeAction` request. |
1420 | /// |
1421 | /// @since 3.16.0 |
1422 | #[serde(skip_serializing_if = "Option::is_none" )] |
1423 | pub data_support: Option<bool>, |
1424 | } |
1425 | |
1426 | #[derive (Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] |
1427 | #[serde(rename_all = "camelCase" )] |
1428 | pub struct TagSupport<T> { |
1429 | /// The tags supported by the client. |
1430 | pub value_set: Vec<T>, |
1431 | } |
1432 | |
1433 | impl<T> TagSupport<T> { |
1434 | /// Support for deserializing a boolean tag Support, in case it's present. |
1435 | /// |
1436 | /// This is currently the case for vscode 1.41.1 |
1437 | fn deserialize_compat<'de, S>(serializer: S) -> Result<Option<TagSupport<T>>, S::Error> |
1438 | where |
1439 | S: serde::Deserializer<'de>, |
1440 | T: serde::Deserialize<'de>, |
1441 | { |
1442 | Ok( |
1443 | match Option::<Value>::deserialize(serializer).map_err(op:serde::de::Error::custom)? { |
1444 | Some(Value::Bool(false)) => None, |
1445 | Some(Value::Bool(true)) => Some(TagSupport { value_set: vec![] }), |
1446 | Some(other: Value) => { |
1447 | Some(TagSupport::<T>::deserialize(other).map_err(serde::de::Error::custom)?) |
1448 | } |
1449 | None => None, |
1450 | }, |
1451 | ) |
1452 | } |
1453 | } |
1454 | |
1455 | /// Text document specific client capabilities. |
1456 | #[derive (Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] |
1457 | #[serde(rename_all = "camelCase" )] |
1458 | pub struct TextDocumentClientCapabilities { |
1459 | #[serde(skip_serializing_if = "Option::is_none" )] |
1460 | pub synchronization: Option<TextDocumentSyncClientCapabilities>, |
1461 | /// Capabilities specific to the `textDocument/completion` |
1462 | #[serde(skip_serializing_if = "Option::is_none" )] |
1463 | pub completion: Option<CompletionClientCapabilities>, |
1464 | |
1465 | /// Capabilities specific to the `textDocument/hover` |
1466 | #[serde(skip_serializing_if = "Option::is_none" )] |
1467 | pub hover: Option<HoverClientCapabilities>, |
1468 | |
1469 | /// Capabilities specific to the `textDocument/signatureHelp` |
1470 | #[serde(skip_serializing_if = "Option::is_none" )] |
1471 | pub signature_help: Option<SignatureHelpClientCapabilities>, |
1472 | |
1473 | /// Capabilities specific to the `textDocument/references` |
1474 | #[serde(skip_serializing_if = "Option::is_none" )] |
1475 | pub references: Option<ReferenceClientCapabilities>, |
1476 | |
1477 | /// Capabilities specific to the `textDocument/documentHighlight` |
1478 | #[serde(skip_serializing_if = "Option::is_none" )] |
1479 | pub document_highlight: Option<DocumentHighlightClientCapabilities>, |
1480 | |
1481 | /// Capabilities specific to the `textDocument/documentSymbol` |
1482 | #[serde(skip_serializing_if = "Option::is_none" )] |
1483 | pub document_symbol: Option<DocumentSymbolClientCapabilities>, |
1484 | /// Capabilities specific to the `textDocument/formatting` |
1485 | #[serde(skip_serializing_if = "Option::is_none" )] |
1486 | pub formatting: Option<DocumentFormattingClientCapabilities>, |
1487 | |
1488 | /// Capabilities specific to the `textDocument/rangeFormatting` |
1489 | #[serde(skip_serializing_if = "Option::is_none" )] |
1490 | pub range_formatting: Option<DocumentRangeFormattingClientCapabilities>, |
1491 | |
1492 | /// Capabilities specific to the `textDocument/onTypeFormatting` |
1493 | #[serde(skip_serializing_if = "Option::is_none" )] |
1494 | pub on_type_formatting: Option<DocumentOnTypeFormattingClientCapabilities>, |
1495 | |
1496 | /// Capabilities specific to the `textDocument/declaration` |
1497 | #[serde(skip_serializing_if = "Option::is_none" )] |
1498 | pub declaration: Option<GotoCapability>, |
1499 | |
1500 | /// Capabilities specific to the `textDocument/definition` |
1501 | #[serde(skip_serializing_if = "Option::is_none" )] |
1502 | pub definition: Option<GotoCapability>, |
1503 | |
1504 | /// Capabilities specific to the `textDocument/typeDefinition` |
1505 | #[serde(skip_serializing_if = "Option::is_none" )] |
1506 | pub type_definition: Option<GotoCapability>, |
1507 | |
1508 | /// Capabilities specific to the `textDocument/implementation` |
1509 | #[serde(skip_serializing_if = "Option::is_none" )] |
1510 | pub implementation: Option<GotoCapability>, |
1511 | |
1512 | /// Capabilities specific to the `textDocument/codeAction` |
1513 | #[serde(skip_serializing_if = "Option::is_none" )] |
1514 | pub code_action: Option<CodeActionClientCapabilities>, |
1515 | |
1516 | /// Capabilities specific to the `textDocument/codeLens` |
1517 | #[serde(skip_serializing_if = "Option::is_none" )] |
1518 | pub code_lens: Option<CodeLensClientCapabilities>, |
1519 | |
1520 | /// Capabilities specific to the `textDocument/documentLink` |
1521 | #[serde(skip_serializing_if = "Option::is_none" )] |
1522 | pub document_link: Option<DocumentLinkClientCapabilities>, |
1523 | |
1524 | /// Capabilities specific to the `textDocument/documentColor` and the |
1525 | /// `textDocument/colorPresentation` request. |
1526 | #[serde(skip_serializing_if = "Option::is_none" )] |
1527 | pub color_provider: Option<DocumentColorClientCapabilities>, |
1528 | |
1529 | /// Capabilities specific to the `textDocument/rename` |
1530 | #[serde(skip_serializing_if = "Option::is_none" )] |
1531 | pub rename: Option<RenameClientCapabilities>, |
1532 | |
1533 | /// Capabilities specific to `textDocument/publishDiagnostics`. |
1534 | #[serde(skip_serializing_if = "Option::is_none" )] |
1535 | pub publish_diagnostics: Option<PublishDiagnosticsClientCapabilities>, |
1536 | |
1537 | /// Capabilities specific to `textDocument/foldingRange` requests. |
1538 | #[serde(skip_serializing_if = "Option::is_none" )] |
1539 | pub folding_range: Option<FoldingRangeClientCapabilities>, |
1540 | |
1541 | /// Capabilities specific to the `textDocument/selectionRange` request. |
1542 | /// |
1543 | /// @since 3.15.0 |
1544 | #[serde(skip_serializing_if = "Option::is_none" )] |
1545 | pub selection_range: Option<SelectionRangeClientCapabilities>, |
1546 | |
1547 | /// Capabilities specific to `textDocument/linkedEditingRange` requests. |
1548 | /// |
1549 | /// @since 3.16.0 |
1550 | #[serde(skip_serializing_if = "Option::is_none" )] |
1551 | pub linked_editing_range: Option<LinkedEditingRangeClientCapabilities>, |
1552 | |
1553 | /// Capabilities specific to the various call hierarchy requests. |
1554 | /// |
1555 | /// @since 3.16.0 |
1556 | #[serde(skip_serializing_if = "Option::is_none" )] |
1557 | pub call_hierarchy: Option<CallHierarchyClientCapabilities>, |
1558 | |
1559 | /// Capabilities specific to the `textDocument/semanticTokens/*` requests. |
1560 | #[serde(skip_serializing_if = "Option::is_none" )] |
1561 | pub semantic_tokens: Option<SemanticTokensClientCapabilities>, |
1562 | |
1563 | /// Capabilities specific to the `textDocument/moniker` request. |
1564 | /// |
1565 | /// @since 3.16.0 |
1566 | #[serde(skip_serializing_if = "Option::is_none" )] |
1567 | pub moniker: Option<MonikerClientCapabilities>, |
1568 | |
1569 | /// Capabilities specific to the various type hierarchy requests. |
1570 | /// |
1571 | /// @since 3.17.0 |
1572 | #[serde(skip_serializing_if = "Option::is_none" )] |
1573 | pub type_hierarchy: Option<TypeHierarchyClientCapabilities>, |
1574 | |
1575 | /// Capabilities specific to the `textDocument/inlineValue` request. |
1576 | /// |
1577 | /// @since 3.17.0 |
1578 | #[serde(skip_serializing_if = "Option::is_none" )] |
1579 | pub inline_value: Option<InlineValueClientCapabilities>, |
1580 | |
1581 | /// Capabilities specific to the `textDocument/inlayHint` request. |
1582 | /// |
1583 | /// @since 3.17.0 |
1584 | #[serde(skip_serializing_if = "Option::is_none" )] |
1585 | pub inlay_hint: Option<InlayHintClientCapabilities>, |
1586 | |
1587 | /// Capabilities specific to the diagnostic pull model. |
1588 | /// |
1589 | /// @since 3.17.0 |
1590 | #[serde(skip_serializing_if = "Option::is_none" )] |
1591 | pub diagnostic: Option<DiagnosticClientCapabilities>, |
1592 | |
1593 | /// Capabilities specific to the `textDocument/inlineCompletion` request. |
1594 | /// |
1595 | /// @since 3.18.0 |
1596 | #[serde(skip_serializing_if = "Option::is_none" )] |
1597 | #[cfg (feature = "proposed" )] |
1598 | pub inline_completion: Option<InlineCompletionClientCapabilities>, |
1599 | } |
1600 | |
1601 | /// Where ClientCapabilities are currently empty: |
1602 | #[derive (Debug, PartialEq, Clone, Default, Deserialize, Serialize)] |
1603 | #[serde(rename_all = "camelCase" )] |
1604 | pub struct ClientCapabilities { |
1605 | /// Workspace specific client capabilities. |
1606 | #[serde(skip_serializing_if = "Option::is_none" )] |
1607 | pub workspace: Option<WorkspaceClientCapabilities>, |
1608 | |
1609 | /// Text document specific client capabilities. |
1610 | #[serde(skip_serializing_if = "Option::is_none" )] |
1611 | pub text_document: Option<TextDocumentClientCapabilities>, |
1612 | |
1613 | /// Window specific client capabilities. |
1614 | #[serde(skip_serializing_if = "Option::is_none" )] |
1615 | pub window: Option<WindowClientCapabilities>, |
1616 | |
1617 | /// General client capabilities. |
1618 | #[serde(skip_serializing_if = "Option::is_none" )] |
1619 | pub general: Option<GeneralClientCapabilities>, |
1620 | |
1621 | /// Unofficial UT8-offsets extension. |
1622 | /// |
1623 | /// See https://clangd.llvm.org/extensions.html#utf-8-offsets. |
1624 | #[serde(skip_serializing_if = "Option::is_none" )] |
1625 | #[cfg (feature = "proposed" )] |
1626 | pub offset_encoding: Option<Vec<String>>, |
1627 | |
1628 | /// Experimental client capabilities. |
1629 | #[serde(skip_serializing_if = "Option::is_none" )] |
1630 | pub experimental: Option<Value>, |
1631 | } |
1632 | |
1633 | #[derive (Debug, PartialEq, Clone, Default, Deserialize, Serialize)] |
1634 | #[serde(rename_all = "camelCase" )] |
1635 | pub struct GeneralClientCapabilities { |
1636 | /// Client capabilities specific to regular expressions. |
1637 | /// |
1638 | /// @since 3.16.0 |
1639 | #[serde(skip_serializing_if = "Option::is_none" )] |
1640 | pub regular_expressions: Option<RegularExpressionsClientCapabilities>, |
1641 | |
1642 | /// Client capabilities specific to the client's markdown parser. |
1643 | /// |
1644 | /// @since 3.16.0 |
1645 | #[serde(skip_serializing_if = "Option::is_none" )] |
1646 | pub markdown: Option<MarkdownClientCapabilities>, |
1647 | |
1648 | /// Client capability that signals how the client handles stale requests (e.g. a request for |
1649 | /// which the client will not process the response anymore since the information is outdated). |
1650 | /// |
1651 | /// @since 3.17.0 |
1652 | #[serde(skip_serializing_if = "Option::is_none" )] |
1653 | pub stale_request_support: Option<StaleRequestSupportClientCapabilities>, |
1654 | |
1655 | /// The position encodings supported by the client. Client and server |
1656 | /// have to agree on the same position encoding to ensure that offsets |
1657 | /// (e.g. character position in a line) are interpreted the same on both |
1658 | /// side. |
1659 | /// |
1660 | /// To keep the protocol backwards compatible the following applies: if |
1661 | /// the value 'utf-16' is missing from the array of position encodings |
1662 | /// servers can assume that the client supports UTF-16. UTF-16 is |
1663 | /// therefore a mandatory encoding. |
1664 | /// |
1665 | /// If omitted it defaults to ['utf-16']. |
1666 | /// |
1667 | /// Implementation considerations: since the conversion from one encoding |
1668 | /// into another requires the content of the file / line the conversion |
1669 | /// is best done where the file is read which is usually on the server |
1670 | /// side. |
1671 | /// |
1672 | /// @since 3.17.0 |
1673 | #[serde(skip_serializing_if = "Option::is_none" )] |
1674 | pub position_encodings: Option<Vec<PositionEncodingKind>>, |
1675 | } |
1676 | |
1677 | /// Client capability that signals how the client |
1678 | /// handles stale requests (e.g. a request |
1679 | /// for which the client will not process the response |
1680 | /// anymore since the information is outdated). |
1681 | /// |
1682 | /// @since 3.17.0 |
1683 | #[derive (Debug, PartialEq, Clone, Default, Deserialize, Serialize)] |
1684 | #[serde(rename_all = "camelCase" )] |
1685 | pub struct StaleRequestSupportClientCapabilities { |
1686 | /// The client will actively cancel the request. |
1687 | pub cancel: bool, |
1688 | |
1689 | /// The list of requests for which the client |
1690 | /// will retry the request if it receives a |
1691 | /// response with error code `ContentModified`` |
1692 | pub retry_on_content_modified: Vec<String>, |
1693 | } |
1694 | |
1695 | #[derive (Debug, PartialEq, Clone, Default, Deserialize, Serialize)] |
1696 | #[serde(rename_all = "camelCase" )] |
1697 | pub struct RegularExpressionsClientCapabilities { |
1698 | /// The engine's name. |
1699 | pub engine: String, |
1700 | |
1701 | /// The engine's version |
1702 | #[serde(skip_serializing_if = "Option::is_none" )] |
1703 | pub version: Option<String>, |
1704 | } |
1705 | |
1706 | #[derive (Debug, PartialEq, Clone, Default, Deserialize, Serialize)] |
1707 | #[serde(rename_all = "camelCase" )] |
1708 | pub struct MarkdownClientCapabilities { |
1709 | /// The name of the parser. |
1710 | pub parser: String, |
1711 | |
1712 | /// The version of the parser. |
1713 | #[serde(skip_serializing_if = "Option::is_none" )] |
1714 | pub version: Option<String>, |
1715 | |
1716 | /// A list of HTML tags that the client allows / supports in |
1717 | /// Markdown. |
1718 | /// |
1719 | /// @since 3.17.0 |
1720 | #[serde(skip_serializing_if = "Option::is_none" )] |
1721 | pub allowed_tags: Option<Vec<String>>, |
1722 | } |
1723 | |
1724 | #[derive (Debug, PartialEq, Clone, Default, Deserialize, Serialize)] |
1725 | #[serde(rename_all = "camelCase" )] |
1726 | pub struct InitializeResult { |
1727 | /// The capabilities the language server provides. |
1728 | pub capabilities: ServerCapabilities, |
1729 | |
1730 | /// Information about the server. |
1731 | #[serde(skip_serializing_if = "Option::is_none" )] |
1732 | pub server_info: Option<ServerInfo>, |
1733 | |
1734 | /// Unofficial UT8-offsets extension. |
1735 | /// |
1736 | /// See https://clangd.llvm.org/extensions.html#utf-8-offsets. |
1737 | #[serde(skip_serializing_if = "Option::is_none" )] |
1738 | #[cfg (feature = "proposed" )] |
1739 | pub offset_encoding: Option<String>, |
1740 | } |
1741 | |
1742 | #[derive (Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] |
1743 | pub struct ServerInfo { |
1744 | /// The name of the server as defined by the server. |
1745 | pub name: String, |
1746 | /// The servers's version as defined by the server. |
1747 | #[serde(skip_serializing_if = "Option::is_none" )] |
1748 | pub version: Option<String>, |
1749 | } |
1750 | |
1751 | #[derive (Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] |
1752 | pub struct InitializeError { |
1753 | /// Indicates whether the client execute the following retry logic: |
1754 | /// |
1755 | /// - (1) show the message provided by the ResponseError to the user |
1756 | /// - (2) user selects retry or cancel |
1757 | /// - (3) if user selected retry the initialize method is sent again. |
1758 | pub retry: bool, |
1759 | } |
1760 | |
1761 | // The server can signal the following capabilities: |
1762 | |
1763 | /// Defines how the host (editor) should sync document changes to the language server. |
1764 | #[derive (Eq, PartialEq, Clone, Copy, Deserialize, Serialize)] |
1765 | #[serde(transparent)] |
1766 | pub struct TextDocumentSyncKind(i32); |
1767 | lsp_enum! { |
1768 | impl TextDocumentSyncKind { |
1769 | /// Documents should not be synced at all. |
1770 | pub const NONE: TextDocumentSyncKind = TextDocumentSyncKind(0); |
1771 | |
1772 | /// Documents are synced by always sending the full content of the document. |
1773 | pub const FULL: TextDocumentSyncKind = TextDocumentSyncKind(1); |
1774 | |
1775 | /// Documents are synced by sending the full content on open. After that only |
1776 | /// incremental updates to the document are sent. |
1777 | pub const INCREMENTAL: TextDocumentSyncKind = TextDocumentSyncKind(2); |
1778 | } |
1779 | } |
1780 | |
1781 | pub type ExecuteCommandClientCapabilities = DynamicRegistrationClientCapabilities; |
1782 | |
1783 | /// Execute command options. |
1784 | #[derive (Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] |
1785 | pub struct ExecuteCommandOptions { |
1786 | /// The commands to be executed on the server |
1787 | pub commands: Vec<String>, |
1788 | |
1789 | #[serde(flatten)] |
1790 | pub work_done_progress_options: WorkDoneProgressOptions, |
1791 | } |
1792 | |
1793 | /// Save options. |
1794 | #[derive (Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] |
1795 | #[serde(rename_all = "camelCase" )] |
1796 | pub struct SaveOptions { |
1797 | /// The client is supposed to include the content on save. |
1798 | #[serde(skip_serializing_if = "Option::is_none" )] |
1799 | pub include_text: Option<bool>, |
1800 | } |
1801 | |
1802 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
1803 | #[serde(untagged)] |
1804 | pub enum TextDocumentSyncSaveOptions { |
1805 | Supported(bool), |
1806 | SaveOptions(SaveOptions), |
1807 | } |
1808 | |
1809 | impl From<SaveOptions> for TextDocumentSyncSaveOptions { |
1810 | fn from(from: SaveOptions) -> Self { |
1811 | Self::SaveOptions(from) |
1812 | } |
1813 | } |
1814 | |
1815 | impl From<bool> for TextDocumentSyncSaveOptions { |
1816 | fn from(from: bool) -> Self { |
1817 | Self::Supported(from) |
1818 | } |
1819 | } |
1820 | |
1821 | #[derive (Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] |
1822 | #[serde(rename_all = "camelCase" )] |
1823 | pub struct TextDocumentSyncOptions { |
1824 | /// Open and close notifications are sent to the server. |
1825 | #[serde(skip_serializing_if = "Option::is_none" )] |
1826 | pub open_close: Option<bool>, |
1827 | |
1828 | /// Change notifications are sent to the server. See TextDocumentSyncKind.None, TextDocumentSyncKind.Full |
1829 | /// and TextDocumentSyncKindIncremental. |
1830 | #[serde(skip_serializing_if = "Option::is_none" )] |
1831 | pub change: Option<TextDocumentSyncKind>, |
1832 | |
1833 | /// Will save notifications are sent to the server. |
1834 | #[serde(skip_serializing_if = "Option::is_none" )] |
1835 | pub will_save: Option<bool>, |
1836 | |
1837 | /// Will save wait until requests are sent to the server. |
1838 | #[serde(skip_serializing_if = "Option::is_none" )] |
1839 | pub will_save_wait_until: Option<bool>, |
1840 | |
1841 | /// Save notifications are sent to the server. |
1842 | #[serde(skip_serializing_if = "Option::is_none" )] |
1843 | pub save: Option<TextDocumentSyncSaveOptions>, |
1844 | } |
1845 | |
1846 | #[derive (Debug, Eq, PartialEq, Ord, PartialOrd, Clone, Deserialize, Serialize)] |
1847 | #[serde(untagged)] |
1848 | pub enum OneOf<A, B> { |
1849 | Left(A), |
1850 | Right(B), |
1851 | } |
1852 | |
1853 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
1854 | #[serde(untagged)] |
1855 | pub enum TextDocumentSyncCapability { |
1856 | Kind(TextDocumentSyncKind), |
1857 | Options(TextDocumentSyncOptions), |
1858 | } |
1859 | |
1860 | impl From<TextDocumentSyncOptions> for TextDocumentSyncCapability { |
1861 | fn from(from: TextDocumentSyncOptions) -> Self { |
1862 | Self::Options(from) |
1863 | } |
1864 | } |
1865 | |
1866 | impl From<TextDocumentSyncKind> for TextDocumentSyncCapability { |
1867 | fn from(from: TextDocumentSyncKind) -> Self { |
1868 | Self::Kind(from) |
1869 | } |
1870 | } |
1871 | |
1872 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
1873 | #[serde(untagged)] |
1874 | pub enum ImplementationProviderCapability { |
1875 | Simple(bool), |
1876 | Options(StaticTextDocumentRegistrationOptions), |
1877 | } |
1878 | |
1879 | impl From<StaticTextDocumentRegistrationOptions> for ImplementationProviderCapability { |
1880 | fn from(from: StaticTextDocumentRegistrationOptions) -> Self { |
1881 | Self::Options(from) |
1882 | } |
1883 | } |
1884 | |
1885 | impl From<bool> for ImplementationProviderCapability { |
1886 | fn from(from: bool) -> Self { |
1887 | Self::Simple(from) |
1888 | } |
1889 | } |
1890 | |
1891 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
1892 | #[serde(untagged)] |
1893 | pub enum TypeDefinitionProviderCapability { |
1894 | Simple(bool), |
1895 | Options(StaticTextDocumentRegistrationOptions), |
1896 | } |
1897 | |
1898 | impl From<StaticTextDocumentRegistrationOptions> for TypeDefinitionProviderCapability { |
1899 | fn from(from: StaticTextDocumentRegistrationOptions) -> Self { |
1900 | Self::Options(from) |
1901 | } |
1902 | } |
1903 | |
1904 | impl From<bool> for TypeDefinitionProviderCapability { |
1905 | fn from(from: bool) -> Self { |
1906 | Self::Simple(from) |
1907 | } |
1908 | } |
1909 | |
1910 | #[derive (Debug, PartialEq, Clone, Default, Deserialize, Serialize)] |
1911 | #[serde(rename_all = "camelCase" )] |
1912 | pub struct ServerCapabilities { |
1913 | /// The position encoding the server picked from the encodings offered |
1914 | /// by the client via the client capability `general.positionEncodings`. |
1915 | /// |
1916 | /// If the client didn't provide any position encodings the only valid |
1917 | /// value that a server can return is 'utf-16'. |
1918 | /// |
1919 | /// If omitted it defaults to 'utf-16'. |
1920 | /// |
1921 | /// @since 3.17.0 |
1922 | #[serde(skip_serializing_if = "Option::is_none" )] |
1923 | pub position_encoding: Option<PositionEncodingKind>, |
1924 | |
1925 | /// Defines how text documents are synced. |
1926 | #[serde(skip_serializing_if = "Option::is_none" )] |
1927 | pub text_document_sync: Option<TextDocumentSyncCapability>, |
1928 | |
1929 | /// Capabilities specific to `textDocument/selectionRange` requests. |
1930 | #[serde(skip_serializing_if = "Option::is_none" )] |
1931 | pub selection_range_provider: Option<SelectionRangeProviderCapability>, |
1932 | |
1933 | /// The server provides hover support. |
1934 | #[serde(skip_serializing_if = "Option::is_none" )] |
1935 | pub hover_provider: Option<HoverProviderCapability>, |
1936 | |
1937 | /// The server provides completion support. |
1938 | #[serde(skip_serializing_if = "Option::is_none" )] |
1939 | pub completion_provider: Option<CompletionOptions>, |
1940 | |
1941 | /// The server provides signature help support. |
1942 | #[serde(skip_serializing_if = "Option::is_none" )] |
1943 | pub signature_help_provider: Option<SignatureHelpOptions>, |
1944 | |
1945 | /// The server provides goto definition support. |
1946 | #[serde(skip_serializing_if = "Option::is_none" )] |
1947 | pub definition_provider: Option<OneOf<bool, DefinitionOptions>>, |
1948 | |
1949 | /// The server provides goto type definition support. |
1950 | #[serde(skip_serializing_if = "Option::is_none" )] |
1951 | pub type_definition_provider: Option<TypeDefinitionProviderCapability>, |
1952 | |
1953 | /// The server provides goto implementation support. |
1954 | #[serde(skip_serializing_if = "Option::is_none" )] |
1955 | pub implementation_provider: Option<ImplementationProviderCapability>, |
1956 | |
1957 | /// The server provides find references support. |
1958 | #[serde(skip_serializing_if = "Option::is_none" )] |
1959 | pub references_provider: Option<OneOf<bool, ReferencesOptions>>, |
1960 | |
1961 | /// The server provides document highlight support. |
1962 | #[serde(skip_serializing_if = "Option::is_none" )] |
1963 | pub document_highlight_provider: Option<OneOf<bool, DocumentHighlightOptions>>, |
1964 | |
1965 | /// The server provides document symbol support. |
1966 | #[serde(skip_serializing_if = "Option::is_none" )] |
1967 | pub document_symbol_provider: Option<OneOf<bool, DocumentSymbolOptions>>, |
1968 | |
1969 | /// The server provides workspace symbol support. |
1970 | #[serde(skip_serializing_if = "Option::is_none" )] |
1971 | pub workspace_symbol_provider: Option<OneOf<bool, WorkspaceSymbolOptions>>, |
1972 | |
1973 | /// The server provides code actions. |
1974 | #[serde(skip_serializing_if = "Option::is_none" )] |
1975 | pub code_action_provider: Option<CodeActionProviderCapability>, |
1976 | |
1977 | /// The server provides code lens. |
1978 | #[serde(skip_serializing_if = "Option::is_none" )] |
1979 | pub code_lens_provider: Option<CodeLensOptions>, |
1980 | |
1981 | /// The server provides document formatting. |
1982 | #[serde(skip_serializing_if = "Option::is_none" )] |
1983 | pub document_formatting_provider: Option<OneOf<bool, DocumentFormattingOptions>>, |
1984 | |
1985 | /// The server provides document range formatting. |
1986 | #[serde(skip_serializing_if = "Option::is_none" )] |
1987 | pub document_range_formatting_provider: Option<OneOf<bool, DocumentRangeFormattingOptions>>, |
1988 | |
1989 | /// The server provides document formatting on typing. |
1990 | #[serde(skip_serializing_if = "Option::is_none" )] |
1991 | pub document_on_type_formatting_provider: Option<DocumentOnTypeFormattingOptions>, |
1992 | |
1993 | /// The server provides rename support. |
1994 | #[serde(skip_serializing_if = "Option::is_none" )] |
1995 | pub rename_provider: Option<OneOf<bool, RenameOptions>>, |
1996 | |
1997 | /// The server provides document link support. |
1998 | #[serde(skip_serializing_if = "Option::is_none" )] |
1999 | pub document_link_provider: Option<DocumentLinkOptions>, |
2000 | |
2001 | /// The server provides color provider support. |
2002 | #[serde(skip_serializing_if = "Option::is_none" )] |
2003 | pub color_provider: Option<ColorProviderCapability>, |
2004 | |
2005 | /// The server provides folding provider support. |
2006 | #[serde(skip_serializing_if = "Option::is_none" )] |
2007 | pub folding_range_provider: Option<FoldingRangeProviderCapability>, |
2008 | |
2009 | /// The server provides go to declaration support. |
2010 | #[serde(skip_serializing_if = "Option::is_none" )] |
2011 | pub declaration_provider: Option<DeclarationCapability>, |
2012 | |
2013 | /// The server provides execute command support. |
2014 | #[serde(skip_serializing_if = "Option::is_none" )] |
2015 | pub execute_command_provider: Option<ExecuteCommandOptions>, |
2016 | |
2017 | /// Workspace specific server capabilities |
2018 | #[serde(skip_serializing_if = "Option::is_none" )] |
2019 | pub workspace: Option<WorkspaceServerCapabilities>, |
2020 | |
2021 | /// Call hierarchy provider capabilities. |
2022 | #[serde(skip_serializing_if = "Option::is_none" )] |
2023 | pub call_hierarchy_provider: Option<CallHierarchyServerCapability>, |
2024 | |
2025 | /// Semantic tokens server capabilities. |
2026 | #[serde(skip_serializing_if = "Option::is_none" )] |
2027 | pub semantic_tokens_provider: Option<SemanticTokensServerCapabilities>, |
2028 | |
2029 | /// Whether server provides moniker support. |
2030 | #[serde(skip_serializing_if = "Option::is_none" )] |
2031 | pub moniker_provider: Option<OneOf<bool, MonikerServerCapabilities>>, |
2032 | |
2033 | /// The server provides linked editing range support. |
2034 | /// |
2035 | /// @since 3.16.0 |
2036 | #[serde(skip_serializing_if = "Option::is_none" )] |
2037 | pub linked_editing_range_provider: Option<LinkedEditingRangeServerCapabilities>, |
2038 | |
2039 | /// The server provides inline values. |
2040 | /// |
2041 | /// @since 3.17.0 |
2042 | #[serde(skip_serializing_if = "Option::is_none" )] |
2043 | pub inline_value_provider: Option<OneOf<bool, InlineValueServerCapabilities>>, |
2044 | |
2045 | /// The server provides inlay hints. |
2046 | /// |
2047 | /// @since 3.17.0 |
2048 | #[serde(skip_serializing_if = "Option::is_none" )] |
2049 | pub inlay_hint_provider: Option<OneOf<bool, InlayHintServerCapabilities>>, |
2050 | |
2051 | /// The server has support for pull model diagnostics. |
2052 | /// |
2053 | /// @since 3.17.0 |
2054 | #[serde(skip_serializing_if = "Option::is_none" )] |
2055 | pub diagnostic_provider: Option<DiagnosticServerCapabilities>, |
2056 | |
2057 | /// The server provides inline completions. |
2058 | /// |
2059 | /// @since 3.18.0 |
2060 | #[serde(skip_serializing_if = "Option::is_none" )] |
2061 | #[cfg (feature = "proposed" )] |
2062 | pub inline_completion_provider: Option<OneOf<bool, InlineCompletionOptions>>, |
2063 | |
2064 | /// Experimental server capabilities. |
2065 | #[serde(skip_serializing_if = "Option::is_none" )] |
2066 | pub experimental: Option<Value>, |
2067 | } |
2068 | |
2069 | #[derive (Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] |
2070 | #[serde(rename_all = "camelCase" )] |
2071 | pub struct WorkspaceServerCapabilities { |
2072 | /// The server supports workspace folder. |
2073 | #[serde(skip_serializing_if = "Option::is_none" )] |
2074 | pub workspace_folders: Option<WorkspaceFoldersServerCapabilities>, |
2075 | |
2076 | #[serde(skip_serializing_if = "Option::is_none" )] |
2077 | pub file_operations: Option<WorkspaceFileOperationsServerCapabilities>, |
2078 | } |
2079 | |
2080 | /// General parameters to to register for a capability. |
2081 | #[derive (Debug, PartialEq, Clone, Deserialize, Serialize)] |
2082 | #[serde(rename_all = "camelCase" )] |
2083 | pub struct Registration { |
2084 | /// The id used to register the request. The id can be used to deregister |
2085 | /// the request again. |
2086 | pub id: String, |
2087 | |
2088 | /// The method / capability to register for. |
2089 | pub method: String, |
2090 | |
2091 | /// Options necessary for the registration. |
2092 | #[serde(skip_serializing_if = "Option::is_none" )] |
2093 | pub register_options: Option<Value>, |
2094 | } |
2095 | |
2096 | #[derive (Debug, PartialEq, Clone, Deserialize, Serialize)] |
2097 | pub struct RegistrationParams { |
2098 | pub registrations: Vec<Registration>, |
2099 | } |
2100 | |
2101 | /// Since most of the registration options require to specify a document selector there is a base |
2102 | /// interface that can be used. |
2103 | #[derive (Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] |
2104 | #[serde(rename_all = "camelCase" )] |
2105 | pub struct TextDocumentRegistrationOptions { |
2106 | /// A document selector to identify the scope of the registration. If set to null |
2107 | /// the document selector provided on the client side will be used. |
2108 | pub document_selector: Option<DocumentSelector>, |
2109 | } |
2110 | |
2111 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2112 | #[serde(untagged)] |
2113 | pub enum DeclarationCapability { |
2114 | Simple(bool), |
2115 | RegistrationOptions(DeclarationRegistrationOptions), |
2116 | Options(DeclarationOptions), |
2117 | } |
2118 | |
2119 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2120 | #[serde(rename_all = "camelCase" )] |
2121 | pub struct DeclarationRegistrationOptions { |
2122 | #[serde(flatten)] |
2123 | pub declaration_options: DeclarationOptions, |
2124 | |
2125 | #[serde(flatten)] |
2126 | pub text_document_registration_options: TextDocumentRegistrationOptions, |
2127 | |
2128 | #[serde(flatten)] |
2129 | pub static_registration_options: StaticRegistrationOptions, |
2130 | } |
2131 | |
2132 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2133 | #[serde(rename_all = "camelCase" )] |
2134 | pub struct DeclarationOptions { |
2135 | #[serde(flatten)] |
2136 | pub work_done_progress_options: WorkDoneProgressOptions, |
2137 | } |
2138 | |
2139 | #[derive (Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] |
2140 | #[serde(rename_all = "camelCase" )] |
2141 | pub struct StaticRegistrationOptions { |
2142 | #[serde(skip_serializing_if = "Option::is_none" )] |
2143 | pub id: Option<String>, |
2144 | } |
2145 | |
2146 | #[derive (Debug, Default, Eq, PartialEq, Clone, Deserialize, Serialize, Copy)] |
2147 | #[serde(rename_all = "camelCase" )] |
2148 | pub struct WorkDoneProgressOptions { |
2149 | #[serde(skip_serializing_if = "Option::is_none" )] |
2150 | pub work_done_progress: Option<bool>, |
2151 | } |
2152 | |
2153 | #[derive (Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] |
2154 | #[serde(rename_all = "camelCase" )] |
2155 | pub struct DocumentFormattingOptions { |
2156 | #[serde(flatten)] |
2157 | pub work_done_progress_options: WorkDoneProgressOptions, |
2158 | } |
2159 | |
2160 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2161 | #[serde(rename_all = "camelCase" )] |
2162 | pub struct DocumentRangeFormattingOptions { |
2163 | #[serde(flatten)] |
2164 | pub work_done_progress_options: WorkDoneProgressOptions, |
2165 | } |
2166 | |
2167 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2168 | #[serde(rename_all = "camelCase" )] |
2169 | pub struct DefinitionOptions { |
2170 | #[serde(flatten)] |
2171 | pub work_done_progress_options: WorkDoneProgressOptions, |
2172 | } |
2173 | |
2174 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2175 | #[serde(rename_all = "camelCase" )] |
2176 | pub struct DocumentSymbolOptions { |
2177 | /// A human-readable string that is shown when multiple outlines trees are |
2178 | /// shown for the same document. |
2179 | /// |
2180 | /// @since 3.16.0 |
2181 | #[serde(skip_serializing_if = "Option::is_none" )] |
2182 | pub label: Option<String>, |
2183 | |
2184 | #[serde(flatten)] |
2185 | pub work_done_progress_options: WorkDoneProgressOptions, |
2186 | } |
2187 | |
2188 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2189 | #[serde(rename_all = "camelCase" )] |
2190 | pub struct ReferencesOptions { |
2191 | #[serde(flatten)] |
2192 | pub work_done_progress_options: WorkDoneProgressOptions, |
2193 | } |
2194 | |
2195 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2196 | #[serde(rename_all = "camelCase" )] |
2197 | pub struct DocumentHighlightOptions { |
2198 | #[serde(flatten)] |
2199 | pub work_done_progress_options: WorkDoneProgressOptions, |
2200 | } |
2201 | |
2202 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2203 | #[serde(rename_all = "camelCase" )] |
2204 | pub struct WorkspaceSymbolOptions { |
2205 | #[serde(flatten)] |
2206 | pub work_done_progress_options: WorkDoneProgressOptions, |
2207 | |
2208 | /// The server provides support to resolve additional |
2209 | /// information for a workspace symbol. |
2210 | /// |
2211 | /// @since 3.17.0 |
2212 | #[serde(skip_serializing_if = "Option::is_none" )] |
2213 | pub resolve_provider: Option<bool>, |
2214 | } |
2215 | |
2216 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2217 | #[serde(rename_all = "camelCase" )] |
2218 | pub struct StaticTextDocumentRegistrationOptions { |
2219 | /// A document selector to identify the scope of the registration. If set to null |
2220 | /// the document selector provided on the client side will be used. |
2221 | pub document_selector: Option<DocumentSelector>, |
2222 | |
2223 | #[serde(skip_serializing_if = "Option::is_none" )] |
2224 | pub id: Option<String>, |
2225 | } |
2226 | |
2227 | /// General parameters to unregister a capability. |
2228 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2229 | pub struct Unregistration { |
2230 | /// The id used to unregister the request or notification. Usually an id |
2231 | /// provided during the register request. |
2232 | pub id: String, |
2233 | |
2234 | /// The method / capability to unregister for. |
2235 | pub method: String, |
2236 | } |
2237 | |
2238 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2239 | pub struct UnregistrationParams { |
2240 | pub unregisterations: Vec<Unregistration>, |
2241 | } |
2242 | |
2243 | #[derive (Debug, PartialEq, Clone, Deserialize, Serialize)] |
2244 | pub struct DidChangeConfigurationParams { |
2245 | /// The actual changed settings |
2246 | pub settings: Value, |
2247 | } |
2248 | |
2249 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2250 | #[serde(rename_all = "camelCase" )] |
2251 | pub struct DidOpenTextDocumentParams { |
2252 | /// The document that was opened. |
2253 | pub text_document: TextDocumentItem, |
2254 | } |
2255 | |
2256 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2257 | #[serde(rename_all = "camelCase" )] |
2258 | pub struct DidChangeTextDocumentParams { |
2259 | /// The document that did change. The version number points |
2260 | /// to the version after all provided content changes have |
2261 | /// been applied. |
2262 | pub text_document: VersionedTextDocumentIdentifier, |
2263 | /// The actual content changes. |
2264 | pub content_changes: Vec<TextDocumentContentChangeEvent>, |
2265 | } |
2266 | |
2267 | /// An event describing a change to a text document. If range and rangeLength are omitted |
2268 | /// the new text is considered to be the full content of the document. |
2269 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2270 | #[serde(rename_all = "camelCase" )] |
2271 | pub struct TextDocumentContentChangeEvent { |
2272 | /// The range of the document that changed. |
2273 | #[serde(skip_serializing_if = "Option::is_none" )] |
2274 | pub range: Option<Range>, |
2275 | |
2276 | /// The length of the range that got replaced. |
2277 | /// |
2278 | /// Deprecated: Use range instead |
2279 | #[serde(skip_serializing_if = "Option::is_none" )] |
2280 | pub range_length: Option<u32>, |
2281 | |
2282 | /// The new text of the document. |
2283 | pub text: String, |
2284 | } |
2285 | |
2286 | /// Describe options to be used when registering for text document change events. |
2287 | /// |
2288 | /// Extends TextDocumentRegistrationOptions |
2289 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2290 | #[serde(rename_all = "camelCase" )] |
2291 | pub struct TextDocumentChangeRegistrationOptions { |
2292 | /// A document selector to identify the scope of the registration. If set to null |
2293 | /// the document selector provided on the client side will be used. |
2294 | pub document_selector: Option<DocumentSelector>, |
2295 | |
2296 | /// How documents are synced to the server. See TextDocumentSyncKind.Full |
2297 | /// and TextDocumentSyncKindIncremental. |
2298 | pub sync_kind: i32, |
2299 | } |
2300 | |
2301 | /// The parameters send in a will save text document notification. |
2302 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2303 | #[serde(rename_all = "camelCase" )] |
2304 | pub struct WillSaveTextDocumentParams { |
2305 | /// The document that will be saved. |
2306 | pub text_document: TextDocumentIdentifier, |
2307 | |
2308 | /// The 'TextDocumentSaveReason'. |
2309 | pub reason: TextDocumentSaveReason, |
2310 | } |
2311 | |
2312 | /// Represents reasons why a text document is saved. |
2313 | #[derive (Copy, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2314 | #[serde(transparent)] |
2315 | pub struct TextDocumentSaveReason(i32); |
2316 | lsp_enum! { |
2317 | impl TextDocumentSaveReason { |
2318 | /// Manually triggered, e.g. by the user pressing save, by starting debugging, |
2319 | /// or by an API call. |
2320 | pub const MANUAL: TextDocumentSaveReason = TextDocumentSaveReason(1); |
2321 | |
2322 | /// Automatic after a delay. |
2323 | pub const AFTER_DELAY: TextDocumentSaveReason = TextDocumentSaveReason(2); |
2324 | |
2325 | /// When the editor lost focus. |
2326 | pub const FOCUS_OUT: TextDocumentSaveReason = TextDocumentSaveReason(3); |
2327 | } |
2328 | } |
2329 | |
2330 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2331 | #[serde(rename_all = "camelCase" )] |
2332 | pub struct DidCloseTextDocumentParams { |
2333 | /// The document that was closed. |
2334 | pub text_document: TextDocumentIdentifier, |
2335 | } |
2336 | |
2337 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2338 | #[serde(rename_all = "camelCase" )] |
2339 | pub struct DidSaveTextDocumentParams { |
2340 | /// The document that was saved. |
2341 | pub text_document: TextDocumentIdentifier, |
2342 | |
2343 | /// Optional the content when saved. Depends on the includeText value |
2344 | /// when the save notification was requested. |
2345 | #[serde(skip_serializing_if = "Option::is_none" )] |
2346 | pub text: Option<String>, |
2347 | } |
2348 | |
2349 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2350 | #[serde(rename_all = "camelCase" )] |
2351 | pub struct TextDocumentSaveRegistrationOptions { |
2352 | /// The client is supposed to include the content on save. |
2353 | #[serde(skip_serializing_if = "Option::is_none" )] |
2354 | pub include_text: Option<bool>, |
2355 | |
2356 | #[serde(flatten)] |
2357 | pub text_document_registration_options: TextDocumentRegistrationOptions, |
2358 | } |
2359 | |
2360 | #[derive (Debug, Eq, PartialEq, Clone, Copy, Default, Deserialize, Serialize)] |
2361 | #[serde(rename_all = "camelCase" )] |
2362 | pub struct DidChangeWatchedFilesClientCapabilities { |
2363 | /// Did change watched files notification supports dynamic registration. |
2364 | /// Please note that the current protocol doesn't support static |
2365 | /// configuration for file changes from the server side. |
2366 | #[serde(skip_serializing_if = "Option::is_none" )] |
2367 | pub dynamic_registration: Option<bool>, |
2368 | |
2369 | /// Whether the client has support for relative patterns |
2370 | /// or not. |
2371 | /// |
2372 | /// @since 3.17.0 |
2373 | #[serde(skip_serializing_if = "Option::is_none" )] |
2374 | pub relative_pattern_support: Option<bool>, |
2375 | } |
2376 | |
2377 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2378 | pub struct DidChangeWatchedFilesParams { |
2379 | /// The actual file events. |
2380 | pub changes: Vec<FileEvent>, |
2381 | } |
2382 | |
2383 | /// The file event type. |
2384 | #[derive (Eq, PartialEq, Hash, Copy, Clone, Deserialize, Serialize)] |
2385 | #[serde(transparent)] |
2386 | pub struct FileChangeType(i32); |
2387 | lsp_enum! { |
2388 | impl FileChangeType { |
2389 | /// The file got created. |
2390 | pub const CREATED: FileChangeType = FileChangeType(1); |
2391 | |
2392 | /// The file got changed. |
2393 | pub const CHANGED: FileChangeType = FileChangeType(2); |
2394 | |
2395 | /// The file got deleted. |
2396 | pub const DELETED: FileChangeType = FileChangeType(3); |
2397 | } |
2398 | } |
2399 | |
2400 | /// An event describing a file change. |
2401 | #[derive (Debug, Eq, Hash, PartialEq, Clone, Deserialize, Serialize)] |
2402 | pub struct FileEvent { |
2403 | /// The file's URI. |
2404 | pub uri: Url, |
2405 | |
2406 | /// The change type. |
2407 | #[serde(rename = "type" )] |
2408 | pub typ: FileChangeType, |
2409 | } |
2410 | |
2411 | impl FileEvent { |
2412 | pub fn new(uri: Url, typ: FileChangeType) -> FileEvent { |
2413 | FileEvent { uri, typ } |
2414 | } |
2415 | } |
2416 | |
2417 | /// Describe options to be used when registered for text document change events. |
2418 | #[derive (Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Deserialize, Serialize)] |
2419 | pub struct DidChangeWatchedFilesRegistrationOptions { |
2420 | /// The watchers to register. |
2421 | pub watchers: Vec<FileSystemWatcher>, |
2422 | } |
2423 | |
2424 | #[derive (Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Deserialize, Serialize)] |
2425 | #[serde(rename_all = "camelCase" )] |
2426 | pub struct FileSystemWatcher { |
2427 | /// The glob pattern to watch. See {@link GlobPattern glob pattern} |
2428 | /// for more detail. |
2429 | /// |
2430 | /// @since 3.17.0 support for relative patterns. |
2431 | pub glob_pattern: GlobPattern, |
2432 | |
2433 | /// The kind of events of interest. If omitted it defaults to WatchKind.Create | |
2434 | /// WatchKind.Change | WatchKind.Delete which is 7. |
2435 | #[serde(skip_serializing_if = "Option::is_none" )] |
2436 | pub kind: Option<WatchKind>, |
2437 | } |
2438 | |
2439 | /// The glob pattern. Either a string pattern or a relative pattern. |
2440 | /// |
2441 | /// @since 3.17.0 |
2442 | #[derive (Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Deserialize, Serialize)] |
2443 | #[serde(untagged)] |
2444 | pub enum GlobPattern { |
2445 | String(Pattern), |
2446 | Relative(RelativePattern), |
2447 | } |
2448 | |
2449 | impl From<Pattern> for GlobPattern { |
2450 | #[inline ] |
2451 | fn from(from: Pattern) -> Self { |
2452 | Self::String(from) |
2453 | } |
2454 | } |
2455 | |
2456 | impl From<RelativePattern> for GlobPattern { |
2457 | #[inline ] |
2458 | fn from(from: RelativePattern) -> Self { |
2459 | Self::Relative(from) |
2460 | } |
2461 | } |
2462 | |
2463 | /// A relative pattern is a helper to construct glob patterns that are matched |
2464 | /// relatively to a base URI. The common value for a `baseUri` is a workspace |
2465 | /// folder root, but it can be another absolute URI as well. |
2466 | /// |
2467 | /// @since 3.17.0 |
2468 | #[derive (Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Deserialize, Serialize)] |
2469 | #[serde(rename_all = "camelCase" )] |
2470 | pub struct RelativePattern { |
2471 | /// A workspace folder or a base URI to which this pattern will be matched |
2472 | /// against relatively. |
2473 | pub base_uri: OneOf<WorkspaceFolder, Url>, |
2474 | |
2475 | /// The actual glob pattern. |
2476 | pub pattern: Pattern, |
2477 | } |
2478 | |
2479 | /// The glob pattern to watch relative to the base path. Glob patterns can have |
2480 | /// the following syntax: |
2481 | /// - `*` to match one or more characters in a path segment |
2482 | /// - `?` to match on one character in a path segment |
2483 | /// - `**` to match any number of path segments, including none |
2484 | /// - `{}` to group conditions (e.g. `**/*.{ts,js}` matches all TypeScript |
2485 | /// and JavaScript files) |
2486 | /// - `[]` to declare a range of characters to match in a path segment |
2487 | /// (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …) |
2488 | /// - `[!...]` to negate a range of characters to match in a path segment |
2489 | /// (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, |
2490 | /// but not `example.0`) |
2491 | /// |
2492 | /// @since 3.17.0 |
2493 | pub type Pattern = String; |
2494 | |
2495 | bitflags! { |
2496 | pub struct WatchKind: u8 { |
2497 | /// Interested in create events. |
2498 | const Create = 1; |
2499 | /// Interested in change events |
2500 | const Change = 2; |
2501 | /// Interested in delete events |
2502 | const Delete = 4; |
2503 | } |
2504 | } |
2505 | |
2506 | impl<'de> serde::Deserialize<'de> for WatchKind { |
2507 | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> |
2508 | where |
2509 | D: serde::Deserializer<'de>, |
2510 | { |
2511 | let i: u8 = u8::deserialize(deserializer)?; |
2512 | WatchKind::from_bits(i).ok_or_else(|| { |
2513 | D::Error::invalid_value(unexp:de::Unexpected::Unsigned(u64::from(i)), &"Unknown flag" ) |
2514 | }) |
2515 | } |
2516 | } |
2517 | |
2518 | impl serde::Serialize for WatchKind { |
2519 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> |
2520 | where |
2521 | S: serde::Serializer, |
2522 | { |
2523 | serializer.serialize_u8(self.bits()) |
2524 | } |
2525 | } |
2526 | |
2527 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2528 | pub struct PublishDiagnosticsParams { |
2529 | /// The URI for which diagnostic information is reported. |
2530 | pub uri: Url, |
2531 | |
2532 | /// An array of diagnostic information items. |
2533 | pub diagnostics: Vec<Diagnostic>, |
2534 | |
2535 | /// Optional the version number of the document the diagnostics are published for. |
2536 | #[serde(skip_serializing_if = "Option::is_none" )] |
2537 | pub version: Option<i32>, |
2538 | } |
2539 | |
2540 | impl PublishDiagnosticsParams { |
2541 | pub fn new( |
2542 | uri: Url, |
2543 | diagnostics: Vec<Diagnostic>, |
2544 | version: Option<i32>, |
2545 | ) -> PublishDiagnosticsParams { |
2546 | PublishDiagnosticsParams { |
2547 | uri, |
2548 | diagnostics, |
2549 | version, |
2550 | } |
2551 | } |
2552 | } |
2553 | |
2554 | #[derive (Debug, Eq, PartialEq, Deserialize, Serialize, Clone)] |
2555 | #[serde(untagged)] |
2556 | pub enum Documentation { |
2557 | String(String), |
2558 | MarkupContent(MarkupContent), |
2559 | } |
2560 | |
2561 | /// MarkedString can be used to render human readable text. It is either a |
2562 | /// markdown string or a code-block that provides a language and a code snippet. |
2563 | /// The language identifier is semantically equal to the optional language |
2564 | /// identifier in fenced code blocks in GitHub issues. |
2565 | /// |
2566 | /// The pair of a language and a value is an equivalent to markdown: |
2567 | /// |
2568 | /// ```${language} |
2569 | /// ${value} |
2570 | /// ``` |
2571 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2572 | #[serde(untagged)] |
2573 | pub enum MarkedString { |
2574 | String(String), |
2575 | LanguageString(LanguageString), |
2576 | } |
2577 | |
2578 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2579 | pub struct LanguageString { |
2580 | pub language: String, |
2581 | pub value: String, |
2582 | } |
2583 | |
2584 | impl MarkedString { |
2585 | pub fn from_markdown(markdown: String) -> MarkedString { |
2586 | MarkedString::String(markdown) |
2587 | } |
2588 | |
2589 | pub fn from_language_code(language: String, code_block: String) -> MarkedString { |
2590 | MarkedString::LanguageString(LanguageString { |
2591 | language, |
2592 | value: code_block, |
2593 | }) |
2594 | } |
2595 | } |
2596 | |
2597 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2598 | #[serde(rename_all = "camelCase" )] |
2599 | pub struct GotoDefinitionParams { |
2600 | #[serde(flatten)] |
2601 | pub text_document_position_params: TextDocumentPositionParams, |
2602 | |
2603 | #[serde(flatten)] |
2604 | pub work_done_progress_params: WorkDoneProgressParams, |
2605 | |
2606 | #[serde(flatten)] |
2607 | pub partial_result_params: PartialResultParams, |
2608 | } |
2609 | |
2610 | /// GotoDefinition response can be single location, or multiple Locations or a link. |
2611 | #[derive (Debug, PartialEq, Serialize, Deserialize, Clone)] |
2612 | #[serde(untagged)] |
2613 | pub enum GotoDefinitionResponse { |
2614 | Scalar(Location), |
2615 | Array(Vec<Location>), |
2616 | Link(Vec<LocationLink>), |
2617 | } |
2618 | |
2619 | impl From<Location> for GotoDefinitionResponse { |
2620 | fn from(location: Location) -> Self { |
2621 | GotoDefinitionResponse::Scalar(location) |
2622 | } |
2623 | } |
2624 | |
2625 | impl From<Vec<Location>> for GotoDefinitionResponse { |
2626 | fn from(locations: Vec<Location>) -> Self { |
2627 | GotoDefinitionResponse::Array(locations) |
2628 | } |
2629 | } |
2630 | |
2631 | impl From<Vec<LocationLink>> for GotoDefinitionResponse { |
2632 | fn from(locations: Vec<LocationLink>) -> Self { |
2633 | GotoDefinitionResponse::Link(locations) |
2634 | } |
2635 | } |
2636 | |
2637 | #[derive (Debug, PartialEq, Clone, Default, Deserialize, Serialize)] |
2638 | pub struct ExecuteCommandParams { |
2639 | /// The identifier of the actual command handler. |
2640 | pub command: String, |
2641 | /// Arguments that the command should be invoked with. |
2642 | #[serde(default)] |
2643 | pub arguments: Vec<Value>, |
2644 | |
2645 | #[serde(flatten)] |
2646 | pub work_done_progress_params: WorkDoneProgressParams, |
2647 | } |
2648 | |
2649 | /// Execute command registration options. |
2650 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2651 | pub struct ExecuteCommandRegistrationOptions { |
2652 | /// The commands to be executed on the server |
2653 | pub commands: Vec<String>, |
2654 | |
2655 | #[serde(flatten)] |
2656 | pub execute_command_options: ExecuteCommandOptions, |
2657 | } |
2658 | |
2659 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2660 | #[serde(rename_all = "camelCase" )] |
2661 | pub struct ApplyWorkspaceEditParams { |
2662 | /// An optional label of the workspace edit. This label is |
2663 | /// presented in the user interface for example on an undo |
2664 | /// stack to undo the workspace edit. |
2665 | #[serde(skip_serializing_if = "Option::is_none" )] |
2666 | pub label: Option<String>, |
2667 | |
2668 | /// The edits to apply. |
2669 | pub edit: WorkspaceEdit, |
2670 | } |
2671 | |
2672 | #[derive (Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] |
2673 | #[serde(rename_all = "camelCase" )] |
2674 | pub struct ApplyWorkspaceEditResponse { |
2675 | /// Indicates whether the edit was applied or not. |
2676 | pub applied: bool, |
2677 | |
2678 | /// An optional textual description for why the edit was not applied. |
2679 | /// This may be used may be used by the server for diagnostic |
2680 | /// logging or to provide a suitable error for a request that |
2681 | /// triggered the edit |
2682 | #[serde(skip_serializing_if = "Option::is_none" )] |
2683 | pub failure_reason: Option<String>, |
2684 | |
2685 | /// Depending on the client's failure handling strategy `failedChange` might |
2686 | /// contain the index of the change that failed. This property is only available |
2687 | /// if the client signals a `failureHandlingStrategy` in its client capabilities. |
2688 | #[serde(skip_serializing_if = "Option::is_none" )] |
2689 | pub failed_change: Option<u32>, |
2690 | } |
2691 | |
2692 | /// Describes the content type that a client supports in various |
2693 | /// result literals like `Hover`, `ParameterInfo` or `CompletionItem`. |
2694 | /// |
2695 | /// Please note that `MarkupKinds` must not start with a `$`. This kinds |
2696 | /// are reserved for internal usage. |
2697 | #[derive (Debug, Eq, PartialEq, Deserialize, Serialize, Clone)] |
2698 | #[serde(rename_all = "lowercase" )] |
2699 | pub enum MarkupKind { |
2700 | /// Plain text is supported as a content format |
2701 | PlainText, |
2702 | /// Markdown is supported as a content format |
2703 | Markdown, |
2704 | } |
2705 | |
2706 | /// A `MarkupContent` literal represents a string value which content can be represented in different formats. |
2707 | /// Currently `plaintext` and `markdown` are supported formats. A `MarkupContent` is usually used in |
2708 | /// documentation properties of result literals like `CompletionItem` or `SignatureInformation`. |
2709 | /// If the format is `markdown` the content should follow the [GitHub Flavored Markdown Specification](https://github.github.com/gfm/). |
2710 | /// |
2711 | /// Here is an example how such a string can be constructed using JavaScript / TypeScript: |
2712 | /// |
2713 | /// ```ignore |
2714 | /// let markdown: MarkupContent = { |
2715 | /// kind: MarkupKind::Markdown, |
2716 | /// value: [ |
2717 | /// "# Header" , |
2718 | /// "Some text" , |
2719 | /// "```typescript", |
2720 | /// "someCode();", |
2721 | /// "```" |
2722 | /// ] |
2723 | /// .join("\n"), |
2724 | /// }; |
2725 | /// ``` |
2726 | /// |
2727 | /// Please *Note* that clients might sanitize the return markdown. A client could decide to |
2728 | /// remove HTML from the markdown to avoid script execution. |
2729 | #[derive (Debug, Eq, PartialEq, Deserialize, Serialize, Clone)] |
2730 | pub struct MarkupContent { |
2731 | pub kind: MarkupKind, |
2732 | pub value: String, |
2733 | } |
2734 | |
2735 | /// A parameter literal used to pass a partial result token. |
2736 | #[derive (Debug, Eq, PartialEq, Default, Deserialize, Serialize, Clone)] |
2737 | #[serde(rename_all = "camelCase" )] |
2738 | pub struct PartialResultParams { |
2739 | #[serde(skip_serializing_if = "Option::is_none" )] |
2740 | pub partial_result_token: Option<ProgressToken>, |
2741 | } |
2742 | |
2743 | /// Symbol tags are extra annotations that tweak the rendering of a symbol. |
2744 | /// |
2745 | /// @since 3.16.0 |
2746 | #[derive (Eq, PartialEq, Clone, Deserialize, Serialize)] |
2747 | #[serde(transparent)] |
2748 | pub struct SymbolTag(i32); |
2749 | lsp_enum! { |
2750 | impl SymbolTag { |
2751 | /// Render a symbol as obsolete, usually using a strike-out. |
2752 | pub const DEPRECATED: SymbolTag = SymbolTag(1); |
2753 | } |
2754 | } |
2755 | |
2756 | #[cfg (test)] |
2757 | mod tests { |
2758 | use serde::{Deserialize, Serialize}; |
2759 | |
2760 | use super::*; |
2761 | |
2762 | pub(crate) fn test_serialization<SER>(ms: &SER, expected: &str) |
2763 | where |
2764 | SER: Serialize + for<'de> Deserialize<'de> + PartialEq + std::fmt::Debug, |
2765 | { |
2766 | let json_str = serde_json::to_string(ms).unwrap(); |
2767 | assert_eq!(&json_str, expected); |
2768 | let deserialized: SER = serde_json::from_str(&json_str).unwrap(); |
2769 | assert_eq!(&deserialized, ms); |
2770 | } |
2771 | |
2772 | pub(crate) fn test_deserialization<T>(json: &str, expected: &T) |
2773 | where |
2774 | T: for<'de> Deserialize<'de> + PartialEq + std::fmt::Debug, |
2775 | { |
2776 | let value = serde_json::from_str::<T>(json).unwrap(); |
2777 | assert_eq!(&value, expected); |
2778 | } |
2779 | |
2780 | #[test ] |
2781 | fn one_of() { |
2782 | test_serialization(&OneOf::<bool, ()>::Left(true), r#"true"# ); |
2783 | test_serialization(&OneOf::<String, ()>::Left("abcd" .into()), r#""abcd""# ); |
2784 | test_serialization( |
2785 | &OneOf::<String, WorkDoneProgressOptions>::Right(WorkDoneProgressOptions { |
2786 | work_done_progress: Some(false), |
2787 | }), |
2788 | r#"{"workDoneProgress":false}"# , |
2789 | ); |
2790 | } |
2791 | |
2792 | #[test ] |
2793 | fn number_or_string() { |
2794 | test_serialization(&NumberOrString::Number(123), r#"123"# ); |
2795 | |
2796 | test_serialization(&NumberOrString::String("abcd" .into()), r#""abcd""# ); |
2797 | } |
2798 | |
2799 | #[test ] |
2800 | fn marked_string() { |
2801 | test_serialization(&MarkedString::from_markdown("xxx" .into()), r#""xxx""# ); |
2802 | |
2803 | test_serialization( |
2804 | &MarkedString::from_language_code("lang" .into(), "code" .into()), |
2805 | r#"{"language":"lang","value":"code"}"# , |
2806 | ); |
2807 | } |
2808 | |
2809 | #[test ] |
2810 | fn language_string() { |
2811 | test_serialization( |
2812 | &LanguageString { |
2813 | language: "LL" .into(), |
2814 | value: "VV" .into(), |
2815 | }, |
2816 | r#"{"language":"LL","value":"VV"}"# , |
2817 | ); |
2818 | } |
2819 | |
2820 | #[test ] |
2821 | fn workspace_edit() { |
2822 | test_serialization( |
2823 | &WorkspaceEdit { |
2824 | changes: Some(vec![].into_iter().collect()), |
2825 | document_changes: None, |
2826 | ..Default::default() |
2827 | }, |
2828 | r#"{"changes":{}}"# , |
2829 | ); |
2830 | |
2831 | test_serialization( |
2832 | &WorkspaceEdit { |
2833 | changes: None, |
2834 | document_changes: None, |
2835 | ..Default::default() |
2836 | }, |
2837 | r#"{}"# , |
2838 | ); |
2839 | |
2840 | test_serialization( |
2841 | &WorkspaceEdit { |
2842 | changes: Some( |
2843 | vec![(Url::parse("file://test" ).unwrap(), vec![])] |
2844 | .into_iter() |
2845 | .collect(), |
2846 | ), |
2847 | document_changes: None, |
2848 | ..Default::default() |
2849 | }, |
2850 | r#"{"changes":{"file://test/":[]}}"# , |
2851 | ); |
2852 | } |
2853 | |
2854 | #[test ] |
2855 | fn root_uri_can_be_missing() { |
2856 | serde_json::from_str::<InitializeParams>(r#"{ "capabilities": {} }"# ).unwrap(); |
2857 | } |
2858 | |
2859 | #[test ] |
2860 | fn test_watch_kind() { |
2861 | test_serialization(&WatchKind::Create, "1" ); |
2862 | test_serialization(&(WatchKind::Create | WatchKind::Change), "3" ); |
2863 | test_serialization( |
2864 | &(WatchKind::Create | WatchKind::Change | WatchKind::Delete), |
2865 | "7" , |
2866 | ); |
2867 | } |
2868 | |
2869 | #[test ] |
2870 | fn test_resource_operation_kind() { |
2871 | test_serialization( |
2872 | &vec![ |
2873 | ResourceOperationKind::Create, |
2874 | ResourceOperationKind::Rename, |
2875 | ResourceOperationKind::Delete, |
2876 | ], |
2877 | r#"["create","rename","delete"]"# , |
2878 | ); |
2879 | } |
2880 | } |
2881 | |