1use serde::{Deserialize, Serialize};
6
7pub type DocumentUri = String;
13
14#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
16pub struct Position {
17 pub line: u32,
19 pub character: u32,
21}
22
23impl Position {
24 pub fn new(line: u32, character: u32) -> Self {
25 Self { line, character }
26 }
27}
28
29#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
31pub struct Range {
32 pub start: Position,
33 pub end: Position,
34}
35
36impl Range {
37 pub fn new(start: Position, end: Position) -> Self {
38 Self { start, end }
39 }
40}
41
42#[derive(Debug, Clone, Serialize, Deserialize)]
44pub struct TextEdit {
45 pub range: Range,
46 pub new_text: String,
47}
48
49#[derive(Debug, Clone, Serialize, Deserialize)]
51pub struct Location {
52 pub uri: DocumentUri,
53 pub range: Range,
54}
55
56#[derive(Debug, Clone, Serialize, Deserialize)]
58pub struct LocationLink {
59 pub origin_selection_range: Option<Range>,
60 pub target_uri: DocumentUri,
61 pub target_range: Range,
62 pub target_selection_range: Range,
63}
64
65#[derive(Debug, Clone, Serialize, Deserialize)]
71pub struct TextDocumentContentChangeEvent {
72 #[serde(skip_serializing_if = "Option::is_none")]
73 pub range: Option<Range>,
74 #[serde(skip_serializing_if = "Option::is_none")]
75 pub range_length: Option<u32>,
76 pub text: String,
77}
78
79#[derive(Debug, Clone, Serialize, Deserialize)]
81pub struct TextDocumentItem {
82 pub uri: DocumentUri,
83 pub language_id: String,
84 pub version: i32,
85 pub text: String,
86}
87
88#[derive(Debug, Clone, Serialize, Deserialize)]
90pub struct TextDocumentIdentifier {
91 pub uri: DocumentUri,
92}
93
94#[derive(Debug, Clone, Serialize, Deserialize)]
96pub struct VersionedTextDocumentIdentifier {
97 pub uri: DocumentUri,
98 pub version: i32,
99}
100
101#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
107#[serde(rename_all = "camelCase")]
108pub enum DiagnosticSeverity {
109 Error = 1,
110 Warning = 2,
111 Information = 3,
112 Hint = 4,
113}
114
115#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
117#[serde(rename_all = "camelCase")]
118pub enum DiagnosticTag {
119 Unnecessary = 1,
120 Deprecated = 2,
121}
122
123#[derive(Debug, Clone, Serialize, Deserialize)]
125pub struct Diagnostic {
126 pub range: Range,
127 pub severity: Option<DiagnosticSeverity>,
128 pub code: Option<serde_json::Value>,
129 #[serde(skip_serializing_if = "Option::is_none")]
130 pub code_description: Option<CodeDescription>,
131 pub source: Option<String>,
132 pub message: String,
133 #[serde(skip_serializing_if = "Option::is_none")]
134 pub tags: Option<Vec<DiagnosticTag>>,
135 #[serde(skip_serializing_if = "Option::is_none")]
136 pub related_information: Option<Vec<DiagnosticRelatedInformation>>,
137 #[serde(skip_serializing_if = "Option::is_none")]
138 pub data: Option<serde_json::Value>,
139}
140
141#[derive(Debug, Clone, Serialize, Deserialize)]
143pub struct CodeDescription {
144 pub href: String,
145}
146
147#[derive(Debug, Clone, Serialize, Deserialize)]
149pub struct DiagnosticRelatedInformation {
150 pub location: Location,
151 pub message: String,
152}
153
154#[derive(Debug, Clone, Serialize, Deserialize)]
160pub struct MarkupContent {
161 pub kind: MarkupKind,
162 pub value: String,
163}
164
165#[derive(Debug, Clone, Serialize, Deserialize)]
167#[serde(rename_all = "camelCase")]
168pub enum MarkupKind {
169 PlainText,
170 Markdown,
171}
172
173#[derive(Debug, Clone, Serialize, Deserialize)]
175pub struct Hover {
176 pub contents: HoverContents,
177 #[serde(skip_serializing_if = "Option::is_none")]
178 pub range: Option<Range>,
179}
180
181#[derive(Debug, Clone, Serialize, Deserialize)]
183#[serde(untagged)]
184pub enum HoverContents {
185 Markup(MarkupContent),
186 String(String),
187 Array(Vec<MarkedString>),
188}
189
190#[derive(Debug, Clone, Serialize, Deserialize)]
192#[serde(untagged)]
193pub enum MarkedString {
194 String(String),
195 LanguageString(LanguageString),
196}
197
198#[derive(Debug, Clone, Serialize, Deserialize)]
200pub struct LanguageString {
201 pub language: String,
202 pub value: String,
203}
204
205#[derive(Debug, Clone, Serialize, Deserialize)]
211#[serde(untagged)]
212pub enum DefinitionResult {
213 Single(Location),
214 Multiple(Vec<Location>),
215 Link(LocationLink),
216 Links(Vec<LocationLink>),
217}
218
219impl DefinitionResult {
220 pub fn to_locations(&self) -> Vec<Location> {
222 match self {
223 DefinitionResult::Single(loc) => vec![loc.clone()],
224 DefinitionResult::Multiple(locs) => locs.clone(),
225 DefinitionResult::Link(link) => vec![Location {
226 uri: link.target_uri.clone(),
227 range: link.target_selection_range.clone(),
228 }],
229 DefinitionResult::Links(links) => links
230 .iter()
231 .map(|link| Location {
232 uri: link.target_uri.clone(),
233 range: link.target_selection_range.clone(),
234 })
235 .collect(),
236 }
237 }
238}
239
240#[derive(Debug, Clone, Serialize, Deserialize)]
242pub struct ReferenceContext {
243 pub include_declaration: bool,
245}
246
247pub type ReferenceResult = Vec<Location>;
249
250#[derive(Debug, Clone, Serialize, Deserialize)]
256pub struct WorkspaceEdit {
257 #[serde(skip_serializing_if = "Option::is_none")]
258 pub changes: Option<std::collections::HashMap<DocumentUri, Vec<TextEdit>>>,
259 #[serde(skip_serializing_if = "Option::is_none")]
260 pub document_changes: Option<Vec<DocumentChange>>,
261}
262
263#[derive(Debug, Clone, Serialize, Deserialize)]
265pub struct DocumentChange {
266 pub text_document: VersionedTextDocumentIdentifier,
267 pub edits: Vec<TextEdit>,
268}
269
270pub type RenameResult = WorkspaceEdit;
272
273#[derive(Debug, Clone, Serialize, Deserialize)]
275#[serde(untagged)]
276pub enum PrepareRenameResult {
277 Range(Range),
278 RangeWithPlaceholder { range: Range, placeholder: String },
279}
280
281#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
287#[serde(rename_all = "camelCase")]
288pub enum SymbolKind {
289 File = 1,
290 Module = 2,
291 Namespace = 3,
292 Package = 4,
293 Class = 5,
294 Method = 6,
295 Property = 7,
296 Field = 8,
297 Constructor = 9,
298 Enum = 10,
299 Interface = 11,
300 Function = 12,
301 Variable = 13,
302 Constant = 14,
303 String = 15,
304 Number = 16,
305 Boolean = 17,
306 Array = 18,
307 Object = 19,
308 Key = 20,
309 Null = 21,
310 EnumMember = 22,
311 Struct = 23,
312 Event = 24,
313 Operator = 25,
314 TypeParameter = 26,
315}
316
317#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
319#[serde(rename_all = "camelCase")]
320pub enum SymbolTag {
321 Deprecated = 1,
322}
323
324#[derive(Debug, Clone, Serialize, Deserialize)]
326pub struct DocumentSymbol {
327 pub name: String,
328 #[serde(skip_serializing_if = "Option::is_none")]
329 pub detail: Option<String>,
330 pub kind: SymbolKind,
331 #[serde(skip_serializing_if = "Option::is_none")]
332 pub tags: Option<Vec<SymbolTag>>,
333 pub deprecated: Option<bool>,
334 pub range: Range,
335 pub selection_range: Range,
336 #[serde(skip_serializing_if = "Option::is_none")]
337 pub children: Option<Vec<DocumentSymbol>>,
338}
339
340#[derive(Debug, Clone, Serialize, Deserialize)]
342pub struct SymbolInformation {
343 pub name: String,
344 pub kind: SymbolKind,
345 #[serde(skip_serializing_if = "Option::is_none")]
346 pub tags: Option<Vec<SymbolTag>>,
347 pub deprecated: Option<bool>,
348 pub location: Location,
349 #[serde(skip_serializing_if = "Option::is_none")]
350 pub container_name: Option<String>,
351}
352
353#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
359#[serde(rename_all = "camelCase")]
360pub enum CompletionItemKind {
361 Text = 1,
362 Method = 2,
363 Function = 3,
364 Constructor = 4,
365 Field = 5,
366 Variable = 6,
367 Class = 7,
368 Interface = 8,
369 Module = 9,
370 Property = 10,
371 Unit = 11,
372 Value = 12,
373 Enum = 13,
374 Keyword = 14,
375 Snippet = 15,
376 Color = 16,
377 File = 17,
378 Reference = 18,
379 Folder = 19,
380 EnumMember = 20,
381 Constant = 21,
382 Struct = 22,
383 Event = 23,
384 Operator = 24,
385 TypeParameter = 25,
386}
387
388#[derive(Debug, Clone, Serialize, Deserialize)]
390pub struct CompletionItem {
391 pub label: String,
392 #[serde(skip_serializing_if = "Option::is_none")]
393 pub kind: Option<CompletionItemKind>,
394 #[serde(skip_serializing_if = "Option::is_none")]
395 pub detail: Option<String>,
396 #[serde(skip_serializing_if = "Option::is_none")]
397 pub documentation: Option<MarkupContent>,
398 #[serde(skip_serializing_if = "Option::is_none")]
399 pub deprecated: Option<bool>,
400 #[serde(skip_serializing_if = "Option::is_none")]
401 pub insert_text: Option<String>,
402}
403
404#[derive(Debug, Clone, Serialize, Deserialize)]
406pub struct CompletionList {
407 pub is_incomplete: bool,
408 pub items: Vec<CompletionItem>,
409}
410
411#[derive(Debug, Clone, Serialize, Deserialize)]
413#[serde(untagged)]
414pub enum CompletionResult {
415 List(CompletionList),
416 Items(Vec<CompletionItem>),
417}
418
419#[derive(Debug, Clone, Default, Serialize, Deserialize)]
425pub struct ServerCapabilities {
426 #[serde(skip_serializing_if = "Option::is_none")]
427 pub text_document_sync: Option<TextDocumentSyncCapability>,
428 #[serde(skip_serializing_if = "Option::is_none")]
429 pub completion_provider: Option<CompletionOptions>,
430 #[serde(skip_serializing_if = "Option::is_none")]
431 pub hover_provider: Option<bool>,
432 #[serde(skip_serializing_if = "Option::is_none")]
433 pub definition_provider: Option<bool>,
434 #[serde(skip_serializing_if = "Option::is_none")]
435 pub references_provider: Option<bool>,
436 #[serde(skip_serializing_if = "Option::is_none")]
437 pub document_symbol_provider: Option<bool>,
438 #[serde(skip_serializing_if = "Option::is_none")]
439 pub rename_provider: Option<RenameOptions>,
440 #[serde(skip_serializing_if = "Option::is_none")]
441 pub workspace_symbol_provider: Option<bool>,
442 #[serde(skip_serializing_if = "Option::is_none")]
443 pub code_action_provider: Option<bool>,
444 #[serde(skip_serializing_if = "Option::is_none")]
445 pub signature_help_provider: Option<SignatureHelpOptions>,
446 #[serde(skip_serializing_if = "Option::is_none")]
447 pub document_formatting_provider: Option<bool>,
448 #[serde(skip_serializing_if = "Option::is_none")]
449 pub document_range_formatting_provider: Option<bool>,
450 #[serde(skip_serializing_if = "Option::is_none")]
451 pub document_highlight_provider: Option<bool>,
452 #[serde(skip_serializing_if = "Option::is_none")]
453 pub implementation_provider: Option<bool>,
454 #[serde(skip_serializing_if = "Option::is_none")]
455 pub type_definition_provider: Option<bool>,
456}
457
458#[derive(Debug, Clone, Serialize, Deserialize)]
460pub struct SignatureHelpOptions {
461 #[serde(skip_serializing_if = "Option::is_none")]
462 pub trigger_characters: Option<Vec<String>>,
463 #[serde(skip_serializing_if = "Option::is_none")]
464 pub retrigger_characters: Option<Vec<String>>,
465}
466
467#[derive(Debug, Clone, Serialize, Deserialize)]
469pub struct TextDocumentSyncCapability {
470 #[serde(skip_serializing_if = "Option::is_none")]
471 pub open_close: Option<bool>,
472 #[serde(skip_serializing_if = "Option::is_none")]
473 pub change: Option<i32>,
474 #[serde(skip_serializing_if = "Option::is_none")]
475 pub will_save: Option<bool>,
476 #[serde(skip_serializing_if = "Option::is_none")]
477 pub will_save_wait_until: Option<bool>,
478 #[serde(skip_serializing_if = "Option::is_none")]
479 pub save: Option<bool>,
480}
481
482#[derive(Debug, Clone, Serialize, Deserialize)]
484pub struct CompletionOptions {
485 #[serde(skip_serializing_if = "Option::is_none")]
486 pub trigger_characters: Option<Vec<String>>,
487 #[serde(skip_serializing_if = "Option::is_none")]
488 pub resolve_provider: Option<bool>,
489}
490
491#[derive(Debug, Clone, Serialize, Deserialize)]
493pub struct RenameOptions {
494 #[serde(skip_serializing_if = "Option::is_none")]
495 pub prepare_provider: Option<bool>,
496}
497
498#[derive(Debug, Clone, Serialize, Deserialize)]
500pub struct InitializeResult {
501 pub capabilities: ServerCapabilities,
502 #[serde(skip_serializing_if = "Option::is_none")]
503 pub server_info: Option<ServerInfo>,
504}
505
506#[derive(Debug, Clone, Serialize, Deserialize)]
508pub struct ServerInfo {
509 pub name: String,
510 #[serde(skip_serializing_if = "Option::is_none")]
511 pub version: Option<String>,
512}
513
514#[derive(Debug, Clone, Serialize, Deserialize)]
516pub struct InitializeParams {
517 pub process_id: Option<u32>,
518 pub client_info: Option<ClientInfo>,
519 pub root_uri: Option<DocumentUri>,
520 pub capabilities: ClientCapabilities,
521}
522
523#[derive(Debug, Clone, Serialize, Deserialize)]
525pub struct ClientInfo {
526 pub name: String,
527 #[serde(skip_serializing_if = "Option::is_none")]
528 pub version: Option<String>,
529}
530
531#[derive(Debug, Clone, Serialize, Deserialize)]
533pub struct ClientCapabilities {
534 #[serde(skip_serializing_if = "Option::is_none")]
535 pub text_document: Option<TextDocumentClientCapabilities>,
536}
537
538#[derive(Debug, Clone, Serialize, Deserialize)]
540pub struct TextDocumentClientCapabilities {
541 #[serde(skip_serializing_if = "Option::is_none")]
542 pub completion: Option<CompletionClientCapabilities>,
543 #[serde(skip_serializing_if = "Option::is_none")]
544 pub hover: Option<HoverClientCapabilities>,
545}
546
547#[derive(Debug, Clone, Serialize, Deserialize)]
549pub struct CompletionClientCapabilities {
550 #[serde(skip_serializing_if = "Option::is_none")]
551 pub completion_item: Option<CompletionItemCapability>,
552}
553
554#[derive(Debug, Clone, Serialize, Deserialize)]
556pub struct CompletionItemCapability {
557 #[serde(skip_serializing_if = "Option::is_none")]
558 pub documentation_format: Option<Vec<String>>,
559}
560
561#[derive(Debug, Clone, Serialize, Deserialize)]
563pub struct HoverClientCapabilities {
564 #[serde(skip_serializing_if = "Option::is_none")]
565 pub content_format: Option<Vec<String>>,
566}
567
568#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
574#[serde(rename_all = "camelCase")]
575pub enum CodeActionKind {
576 Empty,
577 QuickFix,
578 Refactor,
579 RefactorExtract,
580 RefactorInline,
581 RefactorRewrite,
582 Source,
583 SourceOrganizeImports,
584 SourceFixAll,
585}
586
587#[derive(Debug, Clone, Serialize, Deserialize)]
589pub struct CodeActionContext {
590 pub diagnostics: Vec<Diagnostic>,
591 #[serde(skip_serializing_if = "Option::is_none")]
592 pub only: Option<Vec<CodeActionKind>>,
593}
594
595#[derive(Debug, Clone, Serialize, Deserialize)]
597pub struct CodeAction {
598 pub title: String,
599 #[serde(skip_serializing_if = "Option::is_none")]
600 pub kind: Option<CodeActionKind>,
601 #[serde(skip_serializing_if = "Option::is_none")]
602 pub diagnostics: Option<Vec<Diagnostic>>,
603 #[serde(skip_serializing_if = "Option::is_none")]
604 pub edit: Option<WorkspaceEdit>,
605 #[serde(skip_serializing_if = "Option::is_none")]
606 pub command: Option<Command>,
607}
608
609#[derive(Debug, Clone, Serialize, Deserialize)]
611pub struct Command {
612 pub title: String,
613 pub command: String,
614 #[serde(skip_serializing_if = "Option::is_none")]
615 pub arguments: Option<Vec<serde_json::Value>>,
616}
617
618#[derive(Debug, Clone, Serialize, Deserialize)]
624pub struct SignatureInformation {
625 pub label: String,
626 #[serde(skip_serializing_if = "Option::is_none")]
627 pub documentation: Option<MarkupContent>,
628 #[serde(skip_serializing_if = "Option::is_none")]
629 pub parameters: Option<Vec<ParameterInformation>>,
630}
631
632#[derive(Debug, Clone, Serialize, Deserialize)]
634pub struct ParameterInformation {
635 pub label: ParameterLabel,
636 #[serde(skip_serializing_if = "Option::is_none")]
637 pub documentation: Option<MarkupContent>,
638}
639
640#[derive(Debug, Clone, Serialize, Deserialize)]
642#[serde(untagged)]
643pub enum ParameterLabel {
644 String(String),
645 Range([u32; 2]),
646}
647
648#[derive(Debug, Clone, Serialize, Deserialize)]
650pub struct SignatureHelp {
651 pub signatures: Vec<SignatureInformation>,
652 #[serde(skip_serializing_if = "Option::is_none")]
653 pub active_signature: Option<u32>,
654 #[serde(skip_serializing_if = "Option::is_none")]
655 pub active_parameter: Option<u32>,
656}
657
658#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
664#[serde(rename_all = "camelCase")]
665pub enum DocumentHighlightKind {
666 Text = 1,
667 Read = 2,
668 Write = 3,
669}
670
671#[derive(Debug, Clone, Serialize, Deserialize)]
673pub struct DocumentHighlight {
674 pub range: Range,
675 #[serde(skip_serializing_if = "Option::is_none")]
676 pub kind: Option<DocumentHighlightKind>,
677}
678
679#[derive(Debug, Clone, Serialize, Deserialize)]
685pub struct FormattingOptions {
686 pub tab_size: u32,
687 pub insert_spaces: bool,
688 #[serde(skip_serializing_if = "Option::is_none")]
689 pub trim_trailing_whitespace: Option<bool>,
690 #[serde(skip_serializing_if = "Option::is_none")]
691 pub insert_final_newline: Option<bool>,
692 #[serde(skip_serializing_if = "Option::is_none")]
693 pub trim_final_newlines: Option<bool>,
694}
695
696#[derive(Debug, Clone, Serialize, Deserialize)]
702pub struct PublishDiagnosticsParams {
703 pub uri: DocumentUri,
704 pub diagnostics: Vec<Diagnostic>,
705 #[serde(skip_serializing_if = "Option::is_none")]
706 pub version: Option<i32>,
707}