tokio_lsp/types/
initialization.rs

1//! LSP initialization types and structures.
2//!
3//! This module contains types related to the initialization handshake
4//! between client and server as defined by the LSP specification.
5
6use crate::types::DocumentUri;
7use serde::{Deserialize, Serialize};
8
9/// Capabilities that the client supports.
10#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11pub struct ClientCapabilities {
12    /// Workspace-specific client capabilities.
13    #[serde(skip_serializing_if = "Option::is_none")]
14    pub workspace: Option<WorkspaceClientCapabilities>,
15
16    /// Text document-specific client capabilities.
17    #[serde(skip_serializing_if = "Option::is_none")]
18    pub text_document: Option<TextDocumentClientCapabilities>,
19
20    /// Capabilities specific to the notebook document support.
21    #[serde(skip_serializing_if = "Option::is_none")]
22    pub notebook_document: Option<NotebookDocumentClientCapabilities>,
23
24    /// Window-specific client capabilities.
25    #[serde(skip_serializing_if = "Option::is_none")]
26    pub window: Option<WindowClientCapabilities>,
27
28    /// General client capabilities.
29    #[serde(skip_serializing_if = "Option::is_none")]
30    pub general: Option<GeneralClientCapabilities>,
31
32    /// Experimental client capabilities.
33    #[serde(skip_serializing_if = "Option::is_none")]
34    pub experimental: Option<serde_json::Value>,
35}
36
37impl Default for ClientCapabilities {
38    fn default() -> Self {
39        Self {
40            workspace: Some(WorkspaceClientCapabilities::default()),
41            text_document: Some(TextDocumentClientCapabilities::default()),
42            notebook_document: None,
43            window: Some(WindowClientCapabilities::default()),
44            general: Some(GeneralClientCapabilities::default()),
45            experimental: None,
46        }
47    }
48}
49
50/// Workspace-specific client capabilities.
51#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
52pub struct WorkspaceClientCapabilities {
53    /// The client supports applying batch edits to the workspace.
54    #[serde(skip_serializing_if = "Option::is_none")]
55    pub apply_edit: Option<bool>,
56
57    /// Capabilities specific to `WorkspaceEdit`s.
58    #[serde(skip_serializing_if = "Option::is_none")]
59    pub workspace_edit: Option<WorkspaceEditClientCapabilities>,
60
61    /// Capabilities specific to the `workspace/didChangeConfiguration` notification.
62    #[serde(skip_serializing_if = "Option::is_none")]
63    pub did_change_configuration: Option<DidChangeConfigurationClientCapabilities>,
64
65    /// Capabilities specific to the `workspace/didChangeWatchedFiles` notification.
66    #[serde(skip_serializing_if = "Option::is_none")]
67    pub did_change_watched_files: Option<DidChangeWatchedFilesClientCapabilities>,
68
69    /// Capabilities specific to the `workspace/symbol` request.
70    #[serde(skip_serializing_if = "Option::is_none")]
71    pub symbol: Option<WorkspaceSymbolClientCapabilities>,
72
73    /// Capabilities specific to the `workspace/executeCommand` request.
74    #[serde(skip_serializing_if = "Option::is_none")]
75    pub execute_command: Option<ExecuteCommandClientCapabilities>,
76
77    /// The client has support for workspace folders.
78    #[serde(skip_serializing_if = "Option::is_none")]
79    pub workspace_folders: Option<bool>,
80
81    /// The client supports `workspace/configuration` requests.
82    #[serde(skip_serializing_if = "Option::is_none")]
83    pub configuration: Option<bool>,
84}
85
86impl Default for WorkspaceClientCapabilities {
87    fn default() -> Self {
88        Self {
89            apply_edit: Some(true),
90            workspace_edit: Some(WorkspaceEditClientCapabilities::default()),
91            did_change_configuration: Some(DidChangeConfigurationClientCapabilities {
92                dynamic_registration: Some(false),
93            }),
94            did_change_watched_files: Some(DidChangeWatchedFilesClientCapabilities {
95                dynamic_registration: Some(false),
96            }),
97            symbol: None,
98            execute_command: Some(ExecuteCommandClientCapabilities {
99                dynamic_registration: Some(false),
100            }),
101            workspace_folders: Some(true),
102            configuration: Some(true),
103        }
104    }
105}
106
107/// Client capabilities for workspace edit.
108#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
109pub struct WorkspaceEditClientCapabilities {
110    /// The client supports versioned document changes in `WorkspaceEdit`s.
111    #[serde(skip_serializing_if = "Option::is_none")]
112    pub document_changes: Option<bool>,
113
114    /// The resource operations the client supports.
115    #[serde(skip_serializing_if = "Option::is_none")]
116    pub resource_operations: Option<Vec<ResourceOperationKind>>,
117
118    /// The failure handling strategy of a client.
119    #[serde(skip_serializing_if = "Option::is_none")]
120    pub failure_handling: Option<FailureHandlingKind>,
121
122    /// Whether the client normalizes line endings to the client specific setting.
123    #[serde(skip_serializing_if = "Option::is_none")]
124    pub normalizes_line_endings: Option<bool>,
125
126    /// Whether the client in general supports change annotations on text edits,
127    /// create file, rename file and delete file changes.
128    #[serde(skip_serializing_if = "Option::is_none")]
129    pub change_annotation_support: Option<ChangeAnnotationsSupportOptions>,
130}
131
132impl Default for WorkspaceEditClientCapabilities {
133    fn default() -> Self {
134        Self {
135            document_changes: Some(true),
136            resource_operations: Some(vec![
137                ResourceOperationKind::Create,
138                ResourceOperationKind::Rename,
139                ResourceOperationKind::Delete,
140            ]),
141            failure_handling: Some(FailureHandlingKind::Transactional),
142            normalizes_line_endings: Some(false),
143            change_annotation_support: None,
144        }
145    }
146}
147
148/// The kind of resource operations supported by the client.
149#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
150#[serde(rename_all = "lowercase")]
151pub enum ResourceOperationKind {
152    /// Supports creating new files and folders.
153    Create,
154    /// Supports renaming existing files and folders.
155    Rename,
156    /// Supports deleting existing files and folders.
157    Delete,
158}
159
160/// The failure handling strategy for workspace edits.
161#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
162#[serde(rename_all = "camelCase")]
163pub enum FailureHandlingKind {
164    /// Applying the workspace change is simply aborted if one of the changes
165    /// provided fails. All operations executed before the failing operation
166    /// stay executed.
167    Abort,
168    /// All operations are executed transactionally. That means they either all
169    /// succeed or no changes at all are applied to the workspace.
170    Transactional,
171    /// If the workspace edit contains only textual file changes they are executed
172    /// transactionally. If resource changes (create, rename or delete file) are part
173    /// of the change the failure handling strategy is abort.
174    TextOnlyTransactional,
175    /// The client tries to undo the operations already executed. But there is no
176    /// guarantee that this is succeeding.
177    Undo,
178}
179
180/// Change annotations support options.
181#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
182pub struct ChangeAnnotationsSupportOptions {
183    /// Whether the client groups edits with equal labels into tree nodes.
184    #[serde(skip_serializing_if = "Option::is_none")]
185    pub groups_on_label: Option<bool>,
186}
187
188/// Simple client capabilities with dynamic registration support.
189#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
190pub struct DidChangeConfigurationClientCapabilities {
191    /// Did change configuration notification supports dynamic registration.
192    #[serde(skip_serializing_if = "Option::is_none")]
193    pub dynamic_registration: Option<bool>,
194}
195
196/// Simple client capabilities with dynamic registration support.
197#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
198pub struct DidChangeWatchedFilesClientCapabilities {
199    /// Did change watched files notification supports dynamic registration.
200    #[serde(skip_serializing_if = "Option::is_none")]
201    pub dynamic_registration: Option<bool>,
202}
203
204/// Client capabilities for workspace symbol requests.
205#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
206pub struct WorkspaceSymbolClientCapabilities {
207    /// Symbol request supports dynamic registration.
208    #[serde(skip_serializing_if = "Option::is_none")]
209    pub dynamic_registration: Option<bool>,
210}
211
212/// Client capabilities for execute command requests.
213#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
214pub struct ExecuteCommandClientCapabilities {
215    /// Execute command supports dynamic registration.
216    #[serde(skip_serializing_if = "Option::is_none")]
217    pub dynamic_registration: Option<bool>,
218}
219
220/// Text document-specific client capabilities.
221#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
222pub struct TextDocumentClientCapabilities {
223    /// Defines which synchronization capabilities the client supports.
224    #[serde(skip_serializing_if = "Option::is_none")]
225    pub synchronization: Option<TextDocumentSyncClientCapabilities>,
226
227    /// Capabilities specific to the `textDocument/completion` request.
228    #[serde(skip_serializing_if = "Option::is_none")]
229    pub completion: Option<CompletionClientCapabilities>,
230
231    /// Capabilities specific to the `textDocument/hover` request.
232    #[serde(skip_serializing_if = "Option::is_none")]
233    pub hover: Option<HoverClientCapabilities>,
234}
235
236impl Default for TextDocumentClientCapabilities {
237    fn default() -> Self {
238        Self {
239            synchronization: Some(TextDocumentSyncClientCapabilities::default()),
240            completion: Some(CompletionClientCapabilities::default()),
241            hover: Some(HoverClientCapabilities::default()),
242        }
243    }
244}
245
246/// Text document synchronization client capabilities.
247#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
248pub struct TextDocumentSyncClientCapabilities {
249    /// Whether text document synchronization supports dynamic registration.
250    #[serde(skip_serializing_if = "Option::is_none")]
251    pub dynamic_registration: Option<bool>,
252
253    /// The client supports sending will save notifications.
254    #[serde(skip_serializing_if = "Option::is_none")]
255    pub will_save: Option<bool>,
256
257    /// The client supports sending a will save request and waits for a response
258    /// providing text edits which will be applied to the document before it is saved.
259    #[serde(skip_serializing_if = "Option::is_none")]
260    pub will_save_wait_until: Option<bool>,
261
262    /// The client supports did save notifications.
263    #[serde(skip_serializing_if = "Option::is_none")]
264    pub did_save: Option<bool>,
265}
266
267impl Default for TextDocumentSyncClientCapabilities {
268    fn default() -> Self {
269        Self {
270            dynamic_registration: Some(false),
271            will_save: Some(true),
272            will_save_wait_until: Some(true),
273            did_save: Some(true),
274        }
275    }
276}
277
278/// Completion client capabilities.
279#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
280pub struct CompletionClientCapabilities {
281    /// Whether completion supports dynamic registration.
282    #[serde(skip_serializing_if = "Option::is_none")]
283    pub dynamic_registration: Option<bool>,
284
285    /// The client supports the following `CompletionItem` specific capabilities.
286    #[serde(skip_serializing_if = "Option::is_none")]
287    pub completion_item: Option<CompletionItemClientCapabilities>,
288}
289
290impl Default for CompletionClientCapabilities {
291    fn default() -> Self {
292        Self {
293            dynamic_registration: Some(false),
294            completion_item: Some(CompletionItemClientCapabilities::default()),
295        }
296    }
297}
298
299/// Completion item client capabilities.
300#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
301pub struct CompletionItemClientCapabilities {
302    /// Client supports snippets as insert text.
303    #[serde(skip_serializing_if = "Option::is_none")]
304    pub snippet_support: Option<bool>,
305
306    /// Client supports commit characters on a completion item.
307    #[serde(skip_serializing_if = "Option::is_none")]
308    pub commit_characters_support: Option<bool>,
309
310    /// Client supports the following content formats for the documentation
311    /// property. The order describes the preferred format of the client.
312    #[serde(skip_serializing_if = "Option::is_none")]
313    pub documentation_format: Option<Vec<MarkupKind>>,
314}
315
316impl Default for CompletionItemClientCapabilities {
317    fn default() -> Self {
318        Self {
319            snippet_support: Some(true),
320            commit_characters_support: Some(true),
321            documentation_format: Some(vec![MarkupKind::Markdown, MarkupKind::PlainText]),
322        }
323    }
324}
325
326/// Hover client capabilities.
327#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
328pub struct HoverClientCapabilities {
329    /// Whether hover supports dynamic registration.
330    #[serde(skip_serializing_if = "Option::is_none")]
331    pub dynamic_registration: Option<bool>,
332
333    /// Client supports the following content formats for the content
334    /// property. The order describes the preferred format of the client.
335    #[serde(skip_serializing_if = "Option::is_none")]
336    pub content_format: Option<Vec<MarkupKind>>,
337}
338
339impl Default for HoverClientCapabilities {
340    fn default() -> Self {
341        Self {
342            dynamic_registration: Some(false),
343            content_format: Some(vec![MarkupKind::Markdown, MarkupKind::PlainText]),
344        }
345    }
346}
347
348/// Describes the content type that a client supports in various result types.
349#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
350#[serde(rename_all = "lowercase")]
351pub enum MarkupKind {
352    /// Plain text is supported as a content format.
353    PlainText,
354    /// Markdown is supported as a content format.
355    Markdown,
356}
357
358/// Notebook document client capabilities.
359#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
360pub struct NotebookDocumentClientCapabilities {
361    /// Capabilities specific to notebook document synchronization.
362    #[serde(skip_serializing_if = "Option::is_none")]
363    pub synchronization: Option<NotebookDocumentSyncClientCapabilities>,
364}
365
366/// Notebook document synchronization client capabilities.
367#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
368pub struct NotebookDocumentSyncClientCapabilities {
369    /// Whether implementation supports dynamic registration.
370    #[serde(skip_serializing_if = "Option::is_none")]
371    pub dynamic_registration: Option<bool>,
372
373    /// The client supports sending execution summary data per cell.
374    #[serde(skip_serializing_if = "Option::is_none")]
375    pub execution_summary_support: Option<bool>,
376}
377
378/// Window specific client capabilities.
379#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
380pub struct WindowClientCapabilities {
381    /// It indicates whether the client supports server initiated progress using the
382    /// `window/workDoneProgress/create` request.
383    #[serde(skip_serializing_if = "Option::is_none")]
384    pub work_done_progress: Option<bool>,
385
386    /// Capabilities specific to the showMessage request.
387    #[serde(skip_serializing_if = "Option::is_none")]
388    pub show_message: Option<ShowMessageRequestClientCapabilities>,
389
390    /// Capabilities specific to the showDocument request.
391    #[serde(skip_serializing_if = "Option::is_none")]
392    pub show_document: Option<ShowDocumentClientCapabilities>,
393}
394
395impl Default for WindowClientCapabilities {
396    fn default() -> Self {
397        Self {
398            work_done_progress: Some(true),
399            show_message: None,
400            show_document: None,
401        }
402    }
403}
404
405/// Show message request client capabilities.
406#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
407pub struct ShowMessageRequestClientCapabilities {
408    /// Capabilities specific to the `MessageActionItem` type.
409    #[serde(skip_serializing_if = "Option::is_none")]
410    pub message_action_item: Option<MessageActionItemClientCapabilities>,
411}
412
413/// Message action item client capabilities.
414#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
415pub struct MessageActionItemClientCapabilities {
416    /// Whether the client supports additional attributes which
417    /// are preserved and send back to the server in the
418    /// request's response.
419    #[serde(skip_serializing_if = "Option::is_none")]
420    pub additional_properties_support: Option<bool>,
421}
422
423/// Show document client capabilities.
424#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
425pub struct ShowDocumentClientCapabilities {
426    /// The client has support for the showDocument request.
427    pub support: bool,
428}
429
430/// General client capabilities.
431#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
432pub struct GeneralClientCapabilities {
433    /// Client capabilities specific to regular expressions.
434    #[serde(skip_serializing_if = "Option::is_none")]
435    pub regular_expressions: Option<RegularExpressionsClientCapabilities>,
436
437    /// Client capabilities specific to the client's markdown parser.
438    #[serde(skip_serializing_if = "Option::is_none")]
439    pub markdown: Option<MarkdownClientCapabilities>,
440}
441
442impl Default for GeneralClientCapabilities {
443    fn default() -> Self {
444        Self {
445            regular_expressions: Some(RegularExpressionsClientCapabilities {
446                engine: "ECMAScript".to_string(),
447                version: Some("ES2020".to_string()),
448            }),
449            markdown: Some(MarkdownClientCapabilities {
450                parser: "marked".to_string(),
451                version: Some("1.1.0".to_string()),
452            }),
453        }
454    }
455}
456
457/// Client capabilities specific to regular expressions.
458#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
459pub struct RegularExpressionsClientCapabilities {
460    /// The engine's name.
461    pub engine: String,
462
463    /// The engine's version.
464    #[serde(skip_serializing_if = "Option::is_none")]
465    pub version: Option<String>,
466}
467
468/// Client capabilities specific to the client's markdown parser.
469#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
470pub struct MarkdownClientCapabilities {
471    /// The name of the parser.
472    pub parser: String,
473
474    /// The version of the parser.
475    #[serde(skip_serializing_if = "Option::is_none")]
476    pub version: Option<String>,
477}
478
479/// Parameters for the initialize request.
480#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
481pub struct InitializeParams {
482    /// The process id of the parent process that started the server.
483    pub process_id: Option<u32>,
484
485    /// Information about the client.
486    #[serde(skip_serializing_if = "Option::is_none")]
487    pub client_info: Option<ClientInfo>,
488
489    /// The locale the client is currently showing the user interface in.
490    #[serde(skip_serializing_if = "Option::is_none")]
491    pub locale: Option<String>,
492
493    /// The rootPath of the workspace. Is null if no folder is open.
494    #[serde(skip_serializing_if = "Option::is_none")]
495    pub root_path: Option<String>,
496
497    /// The rootUri of the workspace. Is null if no folder is open.
498    pub root_uri: Option<DocumentUri>,
499
500    /// User provided initialization options.
501    #[serde(skip_serializing_if = "Option::is_none")]
502    pub initialization_options: Option<serde_json::Value>,
503
504    /// The capabilities provided by the client (editor or tool).
505    pub capabilities: ClientCapabilities,
506
507    /// The initial trace setting. If omitted trace is disabled ('off').
508    #[serde(skip_serializing_if = "Option::is_none")]
509    pub trace: Option<TraceValue>,
510
511    /// The workspace folders configured in the client when the server starts.
512    #[serde(skip_serializing_if = "Option::is_none")]
513    pub workspace_folders: Option<Vec<WorkspaceFolder>>,
514}
515
516/// Information about the client.
517#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
518pub struct ClientInfo {
519    /// The name of the client as defined by the client.
520    pub name: String,
521
522    /// The client's version as defined by the client.
523    #[serde(skip_serializing_if = "Option::is_none")]
524    pub version: Option<String>,
525}
526
527/// The trace setting for the server.
528#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
529#[serde(rename_all = "lowercase")]
530pub enum TraceValue {
531    /// Turn off tracing.
532    Off,
533    /// Trace messages only.
534    Messages,
535    /// Verbose message tracing.
536    Verbose,
537}
538
539/// A workspace folder.
540#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
541pub struct WorkspaceFolder {
542    /// The associated URI for this workspace folder.
543    pub uri: DocumentUri,
544
545    /// The name of the workspace folder.
546    pub name: String,
547}
548
549/// The initialize result returned from the server.
550#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
551pub struct InitializeResult {
552    /// The capabilities the language server provides.
553    pub capabilities: ServerCapabilities,
554
555    /// Information about the server.
556    #[serde(skip_serializing_if = "Option::is_none")]
557    pub server_info: Option<ServerInfo>,
558}
559
560/// Information about the server.
561#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
562pub struct ServerInfo {
563    /// The name of the server as defined by the server.
564    pub name: String,
565
566    /// The server's version as defined by the server.
567    #[serde(skip_serializing_if = "Option::is_none")]
568    pub version: Option<String>,
569}
570
571/// The capabilities the language server provides.
572#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
573pub struct ServerCapabilities {
574    /// Defines how text documents are synced.
575    #[serde(skip_serializing_if = "Option::is_none")]
576    pub text_document_sync: Option<TextDocumentSyncCapability>,
577
578    /// The server provides completion support.
579    #[serde(skip_serializing_if = "Option::is_none")]
580    pub completion_provider: Option<CompletionOptions>,
581
582    /// The server provides hover support.
583    #[serde(skip_serializing_if = "Option::is_none")]
584    pub hover_provider: Option<HoverProviderCapability>,
585}
586
587/// Text document sync capability.
588#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
589#[serde(untagged)]
590pub enum TextDocumentSyncCapability {
591    Kind(TextDocumentSyncKind),
592    Options(TextDocumentSyncOptions),
593}
594
595/// Text document sync kind.
596#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
597#[repr(u8)]
598pub enum TextDocumentSyncKind {
599    /// Documents should not be synced at all.
600    None = 0,
601    /// Documents are synced by always sending the full content of the document.
602    Full = 1,
603    /// Documents are synced by sending the full content on open.
604    Incremental = 2,
605}
606
607/// Text document sync options.
608#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
609pub struct TextDocumentSyncOptions {
610    /// Open and close notifications are sent to the server.
611    #[serde(skip_serializing_if = "Option::is_none")]
612    pub open_close: Option<bool>,
613
614    /// Change notifications are sent to the server.
615    #[serde(skip_serializing_if = "Option::is_none")]
616    pub change: Option<TextDocumentSyncKind>,
617
618    /// If present will save notifications are sent to the server.
619    #[serde(skip_serializing_if = "Option::is_none")]
620    pub will_save: Option<bool>,
621
622    /// If present will save wait until requests are sent to the server.
623    #[serde(skip_serializing_if = "Option::is_none")]
624    pub will_save_wait_until: Option<bool>,
625
626    /// If present save notifications are sent to the server.
627    #[serde(skip_serializing_if = "Option::is_none")]
628    pub save: Option<SaveOptions>,
629}
630
631/// Save options for text document sync.
632#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
633pub struct SaveOptions {
634    /// The client is supposed to include the content on save.
635    #[serde(skip_serializing_if = "Option::is_none")]
636    pub include_text: Option<bool>,
637}
638
639/// Completion options.
640#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
641pub struct CompletionOptions {
642    /// The server provides support to resolve additional information for a completion item.
643    #[serde(skip_serializing_if = "Option::is_none")]
644    pub resolve_provider: Option<bool>,
645
646    /// Most tools trigger completion request automatically without explicitly
647    /// requesting it using a keyboard shortcut (e.g. Ctrl+Space).
648    #[serde(skip_serializing_if = "Option::is_none")]
649    pub trigger_characters: Option<Vec<String>>,
650
651    /// The list of all possible characters that commit a completion.
652    #[serde(skip_serializing_if = "Option::is_none")]
653    pub all_commit_characters: Option<Vec<String>>,
654}
655
656/// Hover provider capability.
657#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
658#[serde(untagged)]
659pub enum HoverProviderCapability {
660    Simple(bool),
661    Options(HoverOptions),
662}
663
664/// Hover options.
665#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
666pub struct HoverOptions {
667    #[serde(skip_serializing_if = "Option::is_none")]
668    pub work_done_progress: Option<bool>,
669}
tokio_lsp/types/initialization.rs

tokio_lsp/types/
initialization.rs
