Unnamed repository; edit this file 'description' to name the repository.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
use Default::default;
use lsp_types::*;
use serde_json::json;
pub fn get(
    workspace: WorkspaceFolder,
    conf: &Option<serde_json::Value>,
    is_ra: bool,
) -> InitializeParams {
    // let sym = Some(if is_ra {
    //     SymbolKind::ALL.to_vec()
    // } else {
    //     (1..=26).map(SymbolKind).collect()
    // });
    InitializeParams {
        process_id: Some(std::process::id() as _),

        capabilities: ClientCapabilities {
            window: Some(WindowClientCapabilities {
                work_done_progress: Some(true),
                ..default()
            }),
            workspace: Some(WorkspaceClientCapabilities {
                symbol: Some(WorkspaceSymbolClientCapabilities {
                    // symbol_kind: Some(ClientSymbolKindOptions {
                    //     value_set: sym.clone(),
                    // }),
                    // tag_support: Some(ClientSymbolTagOptions {
                    //     value_set: SymbolTag::ALL.to_vec(),
                    // }),
                    resolve_support: Some(ClientSymbolResolveOptions {
                        properties: vec!["location".into()],
                    }),
                    ..default()
                }),
                diagnostics: Some(DiagnosticWorkspaceClientCapabilities {
                    refresh_support: Some(true),
                }),
                inlay_hint: Some(InlayHintWorkspaceClientCapabilities {
                    refresh_support: Some(true),
                }),
                workspace_edit: Some(WorkspaceEditClientCapabilities {
                    document_changes: Some(true),
                    resource_operations: Some(vec![
                        ResourceOperationKind::Create,
                        ResourceOperationKind::Rename,
                        ResourceOperationKind::Delete,
                    ]),
                    failure_handling: Some(FailureHandlingKind::Abort),
                    normalizes_line_endings: Some(false),
                    change_annotation_support: Some(
                        ChangeAnnotationsSupportOptions {
                            groups_on_label: Some(false),
                        },
                    ),
                    metadata_support: None,
                    snippet_edit_support: Some(true),
                }),
                ..default()
            }),
            text_document: Some(TextDocumentClientCapabilities {
                on_type_formatting: Some(
                    DocumentOnTypeFormattingClientCapabilities {
                        dynamic_registration: Some(false),
                    },
                ),
                document_highlight: Some(default()),
                formatting: Some(DocumentFormattingClientCapabilities {
                    dynamic_registration: Some(false),
                }),
                inlay_hint: Some(InlayHintClientCapabilities {
                    dynamic_registration: None,
                    resolve_support: Some(ClientInlayHintResolveOptions {
                        properties: vec![
                            "textEdits".into(),
                            "tooltip".into(),
                            "label.tooltip".into(),
                            "label.command".into(),
                        ],
                    }),
                }),
                document_symbol: Some(DocumentSymbolClientCapabilities {
                    // tag_support: Some(ClientSymbolTagSupport {
                    //     value_set: SymbolTag::ALL.to_vec(),
                    // }),
                    // symbol_kind: Some(ClientSymbolKindOptions {
                    //     value_set: sym,
                    // }),
                    hierarchical_document_symbol_support: Some(true),
                    ..default()
                }),
                definition: Some(DefinitionClientCapabilities {
                    link_support: Some(true),
                    ..default()
                }),
                code_action: Some(CodeActionClientCapabilities {
                    data_support: Some(true),
                    resolve_support: Some(
                        ClientCodeActionResolveOptions {
                            properties: vec!["edit".to_string()],
                        },
                    ),
                    code_action_literal_support: Some(
                        ClientCodeActionLiteralOptions {
                            code_action_kind:
                                ClientCodeActionKindOptions {
                                    value_set: [
                                        "",
                                        "Empty",
                                        "QuickFix",
                                        "Refactor",
                                        "RefactorExtract",
                                        "RefactorInline",
                                        "RefactorRewrite",
                                        "Source",
                                        "SourceOrganizeImports",
                                        "quickfix",
                                        "refactor",
                                        "refactor.extract",
                                        "refactor.inline",
                                        "refactor.rewrite",
                                        "source",
                                        "source.organizeImports",
                                    ]
                                    .map(Into::into)
                                    .into(),
                                },
                        },
                    ),
                    ..default()
                }),
                rename: Some(RenameClientCapabilities {
                    prepare_support: Some(true),
                    prepare_support_default_behavior: Some(
                        PrepareSupportDefaultBehavior::Identifier, 
                    ),
                    honors_change_annotations: Some(false),
                    ..default()
                }),
                hover: Some(HoverClientCapabilities {
                    dynamic_registration: None,
                    content_format: Some(vec![
                        MarkupKind::PlainText,
                        MarkupKind::Markdown,
                    ]),
                }),
                diagnostic: Some(DiagnosticClientCapabilities {
                    dynamic_registration: None,
                    related_document_support: Some(true),
                    markup_message_support: None,
                    diagnostics_capabilities: default(),
                }),
                publish_diagnostics: Some(
                    PublishDiagnosticsClientCapabilities {
                        // related_information: Some(true),
                        // code_description_support: Some(true),
                        // data_support: Some(true),
                        ..default()
                    },
                ),
                signature_help: Some(SignatureHelpClientCapabilities {
                    dynamic_registration: None,
                    signature_information: Some(
                        ClientSignatureInformationOptions {
                            documentation_format: Some(vec![
                                MarkupKind::Markdown,
                                MarkupKind::PlainText,
                            ]),
                            parameter_information: Some(
                                ClientSignatureParameterInformationOptions  {
                                    label_offset_support: Some(true),
                                },
                            ),
                            active_parameter_support: Some(true),
                            no_active_parameter_support: Some(true),
                            
                        },
                    ),
                    context_support: Some(false),
                }),
                completion: Some(CompletionClientCapabilities {
                    dynamic_registration: Some(false),
                    completion_item: Some(ClientCompletionItemOptions {
                        snippet_support: Some(true),
                        commit_characters_support: Some(true),
                        documentation_format: Some(vec![
                            MarkupKind::Markdown,
                            MarkupKind::PlainText,
                        ]),
                        deprecated_support: None,
                        preselect_support: None,
                        tag_support: Some(CompletionItemTagOptions {
                            value_set: vec![CompletionItemTag::Deprecated], 
                        }),

                        resolve_support: Some(
                            ClientCompletionItemResolveOptions {
                                properties: vec![
                                    "additionalTextEdits".into(),
                                    "documentation".into(),
                                ],
                            },
                        ),
                        insert_replace_support: Some(false),
                        insert_text_mode_support: Some(
                            ClientCompletionItemInsertTextModeOptions {
                                value_set: vec![InsertTextMode::AsIs],
                            },
                        ),
                        label_details_support: Some(true),
                        ..default()
                    }),
                    completion_item_kind: Some(
                        ClientCompletionItemOptionsKind {
                            value_set: Some(vec![
                                CompletionItemKind::Text,          
                                CompletionItemKind::Method, 
                                CompletionItemKind::Function, 
                                CompletionItemKind::Constructor, 
                                CompletionItemKind::Field, 
                                CompletionItemKind::Variable, 
                                CompletionItemKind::Class, 
                                CompletionItemKind::Interface, 
                                CompletionItemKind::Module, 
                                CompletionItemKind::Property, 
                                CompletionItemKind::Unit,  
                                CompletionItemKind::Value, 
                                CompletionItemKind::Enum,  
                                CompletionItemKind::Keyword, 
                                CompletionItemKind::Snippet, 
                                CompletionItemKind::Color, 
                                CompletionItemKind::File,  
                                CompletionItemKind::Reference, 
                                CompletionItemKind::Folder, 
                                CompletionItemKind::EnumMember, 
                                CompletionItemKind::Constant, 
                                CompletionItemKind::Struct,   
                                CompletionItemKind::Event,    
                                CompletionItemKind::Operator, 
                                CompletionItemKind::TypeParameter, 
                            ]),
                        },
                    ),
                    context_support: None,
                    insert_text_mode: Some(InsertTextMode::AsIs), 
                    completion_list: Some(CompletionListCapabilities {
                        item_defaults: None,
                        apply_kind_support: None,
                    }),
                }),
                semantic_tokens: Some(SemanticTokensClientCapabilities {
                    dynamic_registration: Some(false),
                    requests: ClientSemanticTokensRequestOptions {
                        range: Some(true.into()),
                        full: Some(true.into()),
                    },
                    token_modifiers: [
                        "associated",
                        "attribute",
                        "callable",
                        "constant",
                        "consuming",
                        "controlFlow",
                        "crateRoot",
                        "injected",
                        "intraDocLink",
                        "library",
                        "macro",
                        "mutable",
                        "procMacro",
                        "public",
                        "reference",
                        "trait",
                        "unsafe",
                    ]
                    .map(|x| x.into())
                    .to_vec(),
                    overlapping_token_support: Some(true),
                    multiline_token_support: Some(true),
                    server_cancel_support: Some(false),
                    augments_syntax_tokens: Some(false),
                    ..default()
                }),
                ..default()
            }),

            general: Some(GeneralClientCapabilities {
                markdown: Some(MarkdownClientCapabilities {
                    version: Some("1.0.0".into()),
                    parser: "markdown".into(),
                    allowed_tags: Some(vec![]),
                }),
                position_encodings: Some(vec![PositionEncodingKind::UTF8]),
                ..default()
            }),
            experimental: Some(json! {{
                "matchingBrace": true,
                "snippetTextEdit": true,
                "colorDiagnosticOutput": true,
                "codeActionGroup": true,
                "serverStatusNotification": true,
                "hoverActions": true,
                "workspaceSymbolScopeKindFiltering": true,
                "onEnter": true,
                "localDocs": true,
            }}),
            ..default()
        },
        client_info: Some(ClientInfo {
            name: "gracilaria".into(),
            version: Some(env!("CARGO_PKG_VERSION").into()),
        }),
        initialization_options: conf.clone(),
        trace: None,
        workspace_folders_initialize_params:
            WorkspaceFoldersInitializeParams {
                workspace_folders: Some(vec![workspace].into()),
            },
        ..default()
    }
}