diff options
Diffstat (limited to 'crates')
-rw-r--r-- | crates/ra_ide/src/display/navigation_target.rs | 9 | ||||
-rw-r--r-- | crates/ra_text_edit/src/lib.rs | 1 | ||||
-rw-r--r-- | crates/rust-analyzer/src/conv.rs | 726 | ||||
-rw-r--r-- | crates/rust-analyzer/src/from_proto.rs | 42 | ||||
-rw-r--r-- | crates/rust-analyzer/src/lib.rs | 5 | ||||
-rw-r--r-- | crates/rust-analyzer/src/lsp_ext.rs (renamed from crates/rust-analyzer/src/req.rs) | 29 | ||||
-rw-r--r-- | crates/rust-analyzer/src/main_loop.rs | 176 | ||||
-rw-r--r-- | crates/rust-analyzer/src/main_loop/handlers.rs | 519 | ||||
-rw-r--r-- | crates/rust-analyzer/src/to_proto.rs | 592 | ||||
-rw-r--r-- | crates/rust-analyzer/tests/heavy_tests/main.rs | 17 | ||||
-rw-r--r-- | crates/rust-analyzer/tests/heavy_tests/support.rs | 6 |
11 files changed, 999 insertions, 1123 deletions
diff --git a/crates/ra_ide/src/display/navigation_target.rs b/crates/ra_ide/src/display/navigation_target.rs index de35c6711..5da28edd2 100644 --- a/crates/ra_ide/src/display/navigation_target.rs +++ b/crates/ra_ide/src/display/navigation_target.rs | |||
@@ -11,7 +11,7 @@ use ra_syntax::{ | |||
11 | TextRange, | 11 | TextRange, |
12 | }; | 12 | }; |
13 | 13 | ||
14 | use crate::FileSymbol; | 14 | use crate::{FileRange, FileSymbol}; |
15 | 15 | ||
16 | use super::short_label::ShortLabel; | 16 | use super::short_label::ShortLabel; |
17 | 17 | ||
@@ -22,10 +22,11 @@ use super::short_label::ShortLabel; | |||
22 | /// code, like a function or a struct, but this is not strictly required. | 22 | /// code, like a function or a struct, but this is not strictly required. |
23 | #[derive(Debug, Clone, PartialEq, Eq, Hash)] | 23 | #[derive(Debug, Clone, PartialEq, Eq, Hash)] |
24 | pub struct NavigationTarget { | 24 | pub struct NavigationTarget { |
25 | // FIXME: use FileRange? | ||
25 | file_id: FileId, | 26 | file_id: FileId, |
27 | full_range: TextRange, | ||
26 | name: SmolStr, | 28 | name: SmolStr, |
27 | kind: SyntaxKind, | 29 | kind: SyntaxKind, |
28 | full_range: TextRange, | ||
29 | focus_range: Option<TextRange>, | 30 | focus_range: Option<TextRange>, |
30 | container_name: Option<SmolStr>, | 31 | container_name: Option<SmolStr>, |
31 | description: Option<String>, | 32 | description: Option<String>, |
@@ -63,6 +64,10 @@ impl NavigationTarget { | |||
63 | self.file_id | 64 | self.file_id |
64 | } | 65 | } |
65 | 66 | ||
67 | pub fn file_range(&self) -> FileRange { | ||
68 | FileRange { file_id: self.file_id, range: self.full_range } | ||
69 | } | ||
70 | |||
66 | pub fn full_range(&self) -> TextRange { | 71 | pub fn full_range(&self) -> TextRange { |
67 | self.full_range | 72 | self.full_range |
68 | } | 73 | } |
diff --git a/crates/ra_text_edit/src/lib.rs b/crates/ra_text_edit/src/lib.rs index 3409713ff..37f77cc47 100644 --- a/crates/ra_text_edit/src/lib.rs +++ b/crates/ra_text_edit/src/lib.rs | |||
@@ -75,6 +75,7 @@ impl TextEdit { | |||
75 | self.indels.is_empty() | 75 | self.indels.is_empty() |
76 | } | 76 | } |
77 | 77 | ||
78 | // FXME: impl IntoIter instead | ||
78 | pub fn as_indels(&self) -> &[Indel] { | 79 | pub fn as_indels(&self) -> &[Indel] { |
79 | &self.indels | 80 | &self.indels |
80 | } | 81 | } |
diff --git a/crates/rust-analyzer/src/conv.rs b/crates/rust-analyzer/src/conv.rs deleted file mode 100644 index f64c90b5b..000000000 --- a/crates/rust-analyzer/src/conv.rs +++ /dev/null | |||
@@ -1,726 +0,0 @@ | |||
1 | //! Convenience module responsible for translating between rust-analyzer's types | ||
2 | //! and LSP types. | ||
3 | |||
4 | use lsp_types::{ | ||
5 | self, CreateFile, DiagnosticSeverity, DocumentChangeOperation, DocumentChanges, Documentation, | ||
6 | Location, LocationLink, MarkupContent, MarkupKind, ParameterInformation, ParameterLabel, | ||
7 | Position, Range, RenameFile, ResourceOp, SemanticTokenModifier, SemanticTokenType, | ||
8 | SignatureInformation, SymbolKind, TextDocumentEdit, TextDocumentIdentifier, TextDocumentItem, | ||
9 | TextDocumentPositionParams, Url, VersionedTextDocumentIdentifier, WorkspaceEdit, | ||
10 | }; | ||
11 | use ra_ide::{ | ||
12 | translate_offset_with_edit, CompletionItem, CompletionItemKind, FileId, FilePosition, | ||
13 | FileRange, FileSystemEdit, Fold, FoldKind, Highlight, HighlightModifier, HighlightTag, | ||
14 | InlayHint, InlayKind, InsertTextFormat, LineCol, LineIndex, NavigationTarget, RangeInfo, | ||
15 | ReferenceAccess, Severity, SourceChange, SourceFileEdit, | ||
16 | }; | ||
17 | use ra_syntax::{SyntaxKind, TextRange, TextSize}; | ||
18 | use ra_text_edit::{Indel, TextEdit}; | ||
19 | use ra_vfs::LineEndings; | ||
20 | |||
21 | use crate::{ | ||
22 | req, | ||
23 | semantic_tokens::{self, ModifierSet, CONSTANT, CONTROL_FLOW, MUTABLE, UNSAFE}, | ||
24 | world::WorldSnapshot, | ||
25 | Result, | ||
26 | }; | ||
27 | use semantic_tokens::{ | ||
28 | ATTRIBUTE, BUILTIN_TYPE, ENUM_MEMBER, FORMAT_SPECIFIER, LIFETIME, TYPE_ALIAS, UNION, | ||
29 | UNRESOLVED_REFERENCE, | ||
30 | }; | ||
31 | |||
32 | pub trait Conv { | ||
33 | type Output; | ||
34 | fn conv(self) -> Self::Output; | ||
35 | } | ||
36 | |||
37 | pub trait ConvWith<CTX> { | ||
38 | type Output; | ||
39 | fn conv_with(self, ctx: CTX) -> Self::Output; | ||
40 | } | ||
41 | |||
42 | pub trait TryConvWith<CTX> { | ||
43 | type Output; | ||
44 | fn try_conv_with(self, ctx: CTX) -> Result<Self::Output>; | ||
45 | } | ||
46 | |||
47 | impl Conv for SyntaxKind { | ||
48 | type Output = SymbolKind; | ||
49 | |||
50 | fn conv(self) -> <Self as Conv>::Output { | ||
51 | match self { | ||
52 | SyntaxKind::FN_DEF => SymbolKind::Function, | ||
53 | SyntaxKind::STRUCT_DEF => SymbolKind::Struct, | ||
54 | SyntaxKind::ENUM_DEF => SymbolKind::Enum, | ||
55 | SyntaxKind::ENUM_VARIANT => SymbolKind::EnumMember, | ||
56 | SyntaxKind::TRAIT_DEF => SymbolKind::Interface, | ||
57 | SyntaxKind::MACRO_CALL => SymbolKind::Function, | ||
58 | SyntaxKind::MODULE => SymbolKind::Module, | ||
59 | SyntaxKind::TYPE_ALIAS_DEF => SymbolKind::TypeParameter, | ||
60 | SyntaxKind::RECORD_FIELD_DEF => SymbolKind::Field, | ||
61 | SyntaxKind::STATIC_DEF => SymbolKind::Constant, | ||
62 | SyntaxKind::CONST_DEF => SymbolKind::Constant, | ||
63 | SyntaxKind::IMPL_DEF => SymbolKind::Object, | ||
64 | _ => SymbolKind::Variable, | ||
65 | } | ||
66 | } | ||
67 | } | ||
68 | |||
69 | impl Conv for ReferenceAccess { | ||
70 | type Output = ::lsp_types::DocumentHighlightKind; | ||
71 | |||
72 | fn conv(self) -> Self::Output { | ||
73 | use lsp_types::DocumentHighlightKind; | ||
74 | match self { | ||
75 | ReferenceAccess::Read => DocumentHighlightKind::Read, | ||
76 | ReferenceAccess::Write => DocumentHighlightKind::Write, | ||
77 | } | ||
78 | } | ||
79 | } | ||
80 | |||
81 | impl Conv for CompletionItemKind { | ||
82 | type Output = ::lsp_types::CompletionItemKind; | ||
83 | |||
84 | fn conv(self) -> <Self as Conv>::Output { | ||
85 | use lsp_types::CompletionItemKind::*; | ||
86 | match self { | ||
87 | CompletionItemKind::Keyword => Keyword, | ||
88 | CompletionItemKind::Snippet => Snippet, | ||
89 | CompletionItemKind::Module => Module, | ||
90 | CompletionItemKind::Function => Function, | ||
91 | CompletionItemKind::Struct => Struct, | ||
92 | CompletionItemKind::Enum => Enum, | ||
93 | CompletionItemKind::EnumVariant => EnumMember, | ||
94 | CompletionItemKind::BuiltinType => Struct, | ||
95 | CompletionItemKind::Binding => Variable, | ||
96 | CompletionItemKind::Field => Field, | ||
97 | CompletionItemKind::Trait => Interface, | ||
98 | CompletionItemKind::TypeAlias => Struct, | ||
99 | CompletionItemKind::Const => Constant, | ||
100 | CompletionItemKind::Static => Value, | ||
101 | CompletionItemKind::Method => Method, | ||
102 | CompletionItemKind::TypeParam => TypeParameter, | ||
103 | CompletionItemKind::Macro => Method, | ||
104 | CompletionItemKind::Attribute => EnumMember, | ||
105 | } | ||
106 | } | ||
107 | } | ||
108 | |||
109 | impl Conv for Severity { | ||
110 | type Output = DiagnosticSeverity; | ||
111 | fn conv(self) -> DiagnosticSeverity { | ||
112 | match self { | ||
113 | Severity::Error => DiagnosticSeverity::Error, | ||
114 | Severity::WeakWarning => DiagnosticSeverity::Hint, | ||
115 | } | ||
116 | } | ||
117 | } | ||
118 | |||
119 | impl ConvWith<(&LineIndex, LineEndings)> for CompletionItem { | ||
120 | type Output = ::lsp_types::CompletionItem; | ||
121 | |||
122 | fn conv_with(self, ctx: (&LineIndex, LineEndings)) -> ::lsp_types::CompletionItem { | ||
123 | let mut additional_text_edits = Vec::new(); | ||
124 | let mut text_edit = None; | ||
125 | // LSP does not allow arbitrary edits in completion, so we have to do a | ||
126 | // non-trivial mapping here. | ||
127 | for indel in self.text_edit().as_indels() { | ||
128 | if indel.delete.contains_range(self.source_range()) { | ||
129 | text_edit = Some(if indel.delete == self.source_range() { | ||
130 | indel.conv_with((ctx.0, ctx.1)) | ||
131 | } else { | ||
132 | assert!(self.source_range().end() == indel.delete.end()); | ||
133 | let range1 = TextRange::new(indel.delete.start(), self.source_range().start()); | ||
134 | let range2 = self.source_range(); | ||
135 | let edit1 = Indel::replace(range1, String::new()); | ||
136 | let edit2 = Indel::replace(range2, indel.insert.clone()); | ||
137 | additional_text_edits.push(edit1.conv_with((ctx.0, ctx.1))); | ||
138 | edit2.conv_with((ctx.0, ctx.1)) | ||
139 | }) | ||
140 | } else { | ||
141 | assert!(self.source_range().intersect(indel.delete).is_none()); | ||
142 | additional_text_edits.push(indel.conv_with((ctx.0, ctx.1))); | ||
143 | } | ||
144 | } | ||
145 | let text_edit = text_edit.unwrap(); | ||
146 | |||
147 | let mut res = lsp_types::CompletionItem { | ||
148 | label: self.label().to_string(), | ||
149 | detail: self.detail().map(|it| it.to_string()), | ||
150 | filter_text: Some(self.lookup().to_string()), | ||
151 | kind: self.kind().map(|it| it.conv()), | ||
152 | text_edit: Some(text_edit.into()), | ||
153 | additional_text_edits: Some(additional_text_edits), | ||
154 | documentation: self.documentation().map(|it| it.conv()), | ||
155 | deprecated: Some(self.deprecated()), | ||
156 | command: if self.trigger_call_info() { | ||
157 | let cmd = lsp_types::Command { | ||
158 | title: "triggerParameterHints".into(), | ||
159 | command: "editor.action.triggerParameterHints".into(), | ||
160 | arguments: None, | ||
161 | }; | ||
162 | Some(cmd) | ||
163 | } else { | ||
164 | None | ||
165 | }, | ||
166 | ..Default::default() | ||
167 | }; | ||
168 | |||
169 | if self.score().is_some() { | ||
170 | res.preselect = Some(true) | ||
171 | } | ||
172 | |||
173 | if self.deprecated() { | ||
174 | res.tags = Some(vec![lsp_types::CompletionItemTag::Deprecated]) | ||
175 | } | ||
176 | |||
177 | res.insert_text_format = Some(match self.insert_text_format() { | ||
178 | InsertTextFormat::Snippet => lsp_types::InsertTextFormat::Snippet, | ||
179 | InsertTextFormat::PlainText => lsp_types::InsertTextFormat::PlainText, | ||
180 | }); | ||
181 | |||
182 | res | ||
183 | } | ||
184 | } | ||
185 | |||
186 | impl ConvWith<&LineIndex> for Position { | ||
187 | type Output = TextSize; | ||
188 | |||
189 | fn conv_with(self, line_index: &LineIndex) -> TextSize { | ||
190 | let line_col = LineCol { line: self.line as u32, col_utf16: self.character as u32 }; | ||
191 | line_index.offset(line_col) | ||
192 | } | ||
193 | } | ||
194 | |||
195 | impl ConvWith<&LineIndex> for TextSize { | ||
196 | type Output = Position; | ||
197 | |||
198 | fn conv_with(self, line_index: &LineIndex) -> Position { | ||
199 | let line_col = line_index.line_col(self); | ||
200 | Position::new(u64::from(line_col.line), u64::from(line_col.col_utf16)) | ||
201 | } | ||
202 | } | ||
203 | |||
204 | impl ConvWith<&LineIndex> for TextRange { | ||
205 | type Output = Range; | ||
206 | |||
207 | fn conv_with(self, line_index: &LineIndex) -> Range { | ||
208 | Range::new(self.start().conv_with(line_index), self.end().conv_with(line_index)) | ||
209 | } | ||
210 | } | ||
211 | |||
212 | impl ConvWith<&LineIndex> for Range { | ||
213 | type Output = TextRange; | ||
214 | |||
215 | fn conv_with(self, line_index: &LineIndex) -> TextRange { | ||
216 | TextRange::new(self.start.conv_with(line_index), self.end.conv_with(line_index)) | ||
217 | } | ||
218 | } | ||
219 | |||
220 | impl Conv for ra_ide::Documentation { | ||
221 | type Output = lsp_types::Documentation; | ||
222 | fn conv(self) -> Documentation { | ||
223 | Documentation::MarkupContent(MarkupContent { | ||
224 | kind: MarkupKind::Markdown, | ||
225 | value: crate::markdown::format_docs(self.as_str()), | ||
226 | }) | ||
227 | } | ||
228 | } | ||
229 | |||
230 | impl ConvWith<bool> for ra_ide::FunctionSignature { | ||
231 | type Output = lsp_types::SignatureInformation; | ||
232 | fn conv_with(self, concise: bool) -> Self::Output { | ||
233 | let (label, documentation, params) = if concise { | ||
234 | let mut params = self.parameters; | ||
235 | if self.has_self_param { | ||
236 | params.remove(0); | ||
237 | } | ||
238 | (params.join(", "), None, params) | ||
239 | } else { | ||
240 | (self.to_string(), self.doc.map(|it| it.conv()), self.parameters) | ||
241 | }; | ||
242 | |||
243 | let parameters: Vec<ParameterInformation> = params | ||
244 | .into_iter() | ||
245 | .map(|param| ParameterInformation { | ||
246 | label: ParameterLabel::Simple(param), | ||
247 | documentation: None, | ||
248 | }) | ||
249 | .collect(); | ||
250 | |||
251 | SignatureInformation { label, documentation, parameters: Some(parameters) } | ||
252 | } | ||
253 | } | ||
254 | |||
255 | impl ConvWith<(&LineIndex, LineEndings)> for TextEdit { | ||
256 | type Output = Vec<lsp_types::TextEdit>; | ||
257 | |||
258 | fn conv_with(self, ctx: (&LineIndex, LineEndings)) -> Vec<lsp_types::TextEdit> { | ||
259 | self.as_indels().iter().map_conv_with(ctx).collect() | ||
260 | } | ||
261 | } | ||
262 | |||
263 | impl ConvWith<(&LineIndex, LineEndings)> for &Indel { | ||
264 | type Output = lsp_types::TextEdit; | ||
265 | |||
266 | fn conv_with( | ||
267 | self, | ||
268 | (line_index, line_endings): (&LineIndex, LineEndings), | ||
269 | ) -> lsp_types::TextEdit { | ||
270 | let mut new_text = self.insert.clone(); | ||
271 | if line_endings == LineEndings::Dos { | ||
272 | new_text = new_text.replace('\n', "\r\n"); | ||
273 | } | ||
274 | lsp_types::TextEdit { range: self.delete.conv_with(line_index), new_text } | ||
275 | } | ||
276 | } | ||
277 | |||
278 | pub(crate) struct FoldConvCtx<'a> { | ||
279 | pub(crate) text: &'a str, | ||
280 | pub(crate) line_index: &'a LineIndex, | ||
281 | pub(crate) line_folding_only: bool, | ||
282 | } | ||
283 | |||
284 | impl ConvWith<&FoldConvCtx<'_>> for Fold { | ||
285 | type Output = lsp_types::FoldingRange; | ||
286 | |||
287 | fn conv_with(self, ctx: &FoldConvCtx) -> lsp_types::FoldingRange { | ||
288 | let kind = match self.kind { | ||
289 | FoldKind::Comment => Some(lsp_types::FoldingRangeKind::Comment), | ||
290 | FoldKind::Imports => Some(lsp_types::FoldingRangeKind::Imports), | ||
291 | FoldKind::Mods => None, | ||
292 | FoldKind::Block => None, | ||
293 | }; | ||
294 | |||
295 | let range = self.range.conv_with(&ctx.line_index); | ||
296 | |||
297 | if ctx.line_folding_only { | ||
298 | // Clients with line_folding_only == true (such as VSCode) will fold the whole end line | ||
299 | // even if it contains text not in the folding range. To prevent that we exclude | ||
300 | // range.end.line from the folding region if there is more text after range.end | ||
301 | // on the same line. | ||
302 | let has_more_text_on_end_line = ctx.text | ||
303 | [TextRange::new(self.range.end(), TextSize::of(ctx.text))] | ||
304 | .chars() | ||
305 | .take_while(|it| *it != '\n') | ||
306 | .any(|it| !it.is_whitespace()); | ||
307 | |||
308 | let end_line = if has_more_text_on_end_line { | ||
309 | range.end.line.saturating_sub(1) | ||
310 | } else { | ||
311 | range.end.line | ||
312 | }; | ||
313 | |||
314 | lsp_types::FoldingRange { | ||
315 | start_line: range.start.line, | ||
316 | start_character: None, | ||
317 | end_line, | ||
318 | end_character: None, | ||
319 | kind, | ||
320 | } | ||
321 | } else { | ||
322 | lsp_types::FoldingRange { | ||
323 | start_line: range.start.line, | ||
324 | start_character: Some(range.start.character), | ||
325 | end_line: range.end.line, | ||
326 | end_character: Some(range.end.character), | ||
327 | kind, | ||
328 | } | ||
329 | } | ||
330 | } | ||
331 | } | ||
332 | |||
333 | impl ConvWith<&LineIndex> for InlayHint { | ||
334 | type Output = req::InlayHint; | ||
335 | fn conv_with(self, line_index: &LineIndex) -> Self::Output { | ||
336 | req::InlayHint { | ||
337 | label: self.label.to_string(), | ||
338 | range: self.range.conv_with(line_index), | ||
339 | kind: match self.kind { | ||
340 | InlayKind::ParameterHint => req::InlayKind::ParameterHint, | ||
341 | InlayKind::TypeHint => req::InlayKind::TypeHint, | ||
342 | InlayKind::ChainingHint => req::InlayKind::ChainingHint, | ||
343 | }, | ||
344 | } | ||
345 | } | ||
346 | } | ||
347 | |||
348 | impl Conv for Highlight { | ||
349 | type Output = (u32, u32); | ||
350 | |||
351 | fn conv(self) -> Self::Output { | ||
352 | let mut mods = ModifierSet::default(); | ||
353 | let type_ = match self.tag { | ||
354 | HighlightTag::Struct => SemanticTokenType::STRUCT, | ||
355 | HighlightTag::Enum => SemanticTokenType::ENUM, | ||
356 | HighlightTag::Union => UNION, | ||
357 | HighlightTag::TypeAlias => TYPE_ALIAS, | ||
358 | HighlightTag::Trait => SemanticTokenType::INTERFACE, | ||
359 | HighlightTag::BuiltinType => BUILTIN_TYPE, | ||
360 | HighlightTag::SelfType => SemanticTokenType::TYPE, | ||
361 | HighlightTag::Field => SemanticTokenType::MEMBER, | ||
362 | HighlightTag::Function => SemanticTokenType::FUNCTION, | ||
363 | HighlightTag::Module => SemanticTokenType::NAMESPACE, | ||
364 | HighlightTag::Constant => { | ||
365 | mods |= CONSTANT; | ||
366 | mods |= SemanticTokenModifier::STATIC; | ||
367 | SemanticTokenType::VARIABLE | ||
368 | } | ||
369 | HighlightTag::Static => { | ||
370 | mods |= SemanticTokenModifier::STATIC; | ||
371 | SemanticTokenType::VARIABLE | ||
372 | } | ||
373 | HighlightTag::EnumVariant => ENUM_MEMBER, | ||
374 | HighlightTag::Macro => SemanticTokenType::MACRO, | ||
375 | HighlightTag::Local => SemanticTokenType::VARIABLE, | ||
376 | HighlightTag::TypeParam => SemanticTokenType::TYPE_PARAMETER, | ||
377 | HighlightTag::Lifetime => LIFETIME, | ||
378 | HighlightTag::ByteLiteral | HighlightTag::NumericLiteral => SemanticTokenType::NUMBER, | ||
379 | HighlightTag::CharLiteral | HighlightTag::StringLiteral => SemanticTokenType::STRING, | ||
380 | HighlightTag::Comment => SemanticTokenType::COMMENT, | ||
381 | HighlightTag::Attribute => ATTRIBUTE, | ||
382 | HighlightTag::Keyword => SemanticTokenType::KEYWORD, | ||
383 | HighlightTag::UnresolvedReference => UNRESOLVED_REFERENCE, | ||
384 | HighlightTag::FormatSpecifier => FORMAT_SPECIFIER, | ||
385 | }; | ||
386 | |||
387 | for modifier in self.modifiers.iter() { | ||
388 | let modifier = match modifier { | ||
389 | HighlightModifier::Definition => SemanticTokenModifier::DECLARATION, | ||
390 | HighlightModifier::ControlFlow => CONTROL_FLOW, | ||
391 | HighlightModifier::Mutable => MUTABLE, | ||
392 | HighlightModifier::Unsafe => UNSAFE, | ||
393 | }; | ||
394 | mods |= modifier; | ||
395 | } | ||
396 | |||
397 | (semantic_tokens::type_index(type_), mods.0) | ||
398 | } | ||
399 | } | ||
400 | |||
401 | impl<T: ConvWith<CTX>, CTX> ConvWith<CTX> for Option<T> { | ||
402 | type Output = Option<T::Output>; | ||
403 | |||
404 | fn conv_with(self, ctx: CTX) -> Self::Output { | ||
405 | self.map(|x| ConvWith::conv_with(x, ctx)) | ||
406 | } | ||
407 | } | ||
408 | |||
409 | impl TryConvWith<&WorldSnapshot> for &Url { | ||
410 | type Output = FileId; | ||
411 | fn try_conv_with(self, world: &WorldSnapshot) -> Result<FileId> { | ||
412 | world.uri_to_file_id(self) | ||
413 | } | ||
414 | } | ||
415 | |||
416 | impl TryConvWith<&WorldSnapshot> for FileId { | ||
417 | type Output = Url; | ||
418 | fn try_conv_with(self, world: &WorldSnapshot) -> Result<Url> { | ||
419 | world.file_id_to_uri(self) | ||
420 | } | ||
421 | } | ||
422 | |||
423 | impl TryConvWith<&WorldSnapshot> for &TextDocumentItem { | ||
424 | type Output = FileId; | ||
425 | fn try_conv_with(self, world: &WorldSnapshot) -> Result<FileId> { | ||
426 | self.uri.try_conv_with(world) | ||
427 | } | ||
428 | } | ||
429 | |||
430 | impl TryConvWith<&WorldSnapshot> for &VersionedTextDocumentIdentifier { | ||
431 | type Output = FileId; | ||
432 | fn try_conv_with(self, world: &WorldSnapshot) -> Result<FileId> { | ||
433 | self.uri.try_conv_with(world) | ||
434 | } | ||
435 | } | ||
436 | |||
437 | impl TryConvWith<&WorldSnapshot> for &TextDocumentIdentifier { | ||
438 | type Output = FileId; | ||
439 | fn try_conv_with(self, world: &WorldSnapshot) -> Result<FileId> { | ||
440 | world.uri_to_file_id(&self.uri) | ||
441 | } | ||
442 | } | ||
443 | |||
444 | impl TryConvWith<&WorldSnapshot> for &TextDocumentPositionParams { | ||
445 | type Output = FilePosition; | ||
446 | fn try_conv_with(self, world: &WorldSnapshot) -> Result<FilePosition> { | ||
447 | let file_id = self.text_document.try_conv_with(world)?; | ||
448 | let line_index = world.analysis().file_line_index(file_id)?; | ||
449 | let offset = self.position.conv_with(&line_index); | ||
450 | Ok(FilePosition { file_id, offset }) | ||
451 | } | ||
452 | } | ||
453 | |||
454 | impl TryConvWith<&WorldSnapshot> for (&TextDocumentIdentifier, Range) { | ||
455 | type Output = FileRange; | ||
456 | fn try_conv_with(self, world: &WorldSnapshot) -> Result<FileRange> { | ||
457 | let file_id = self.0.try_conv_with(world)?; | ||
458 | let line_index = world.analysis().file_line_index(file_id)?; | ||
459 | let range = self.1.conv_with(&line_index); | ||
460 | Ok(FileRange { file_id, range }) | ||
461 | } | ||
462 | } | ||
463 | |||
464 | impl<T: TryConvWith<CTX>, CTX: Copy> TryConvWith<CTX> for Vec<T> { | ||
465 | type Output = Vec<<T as TryConvWith<CTX>>::Output>; | ||
466 | fn try_conv_with(self, ctx: CTX) -> Result<Self::Output> { | ||
467 | let mut res = Vec::with_capacity(self.len()); | ||
468 | for item in self { | ||
469 | res.push(item.try_conv_with(ctx)?); | ||
470 | } | ||
471 | Ok(res) | ||
472 | } | ||
473 | } | ||
474 | |||
475 | impl TryConvWith<&WorldSnapshot> for SourceChange { | ||
476 | type Output = req::SourceChange; | ||
477 | fn try_conv_with(self, world: &WorldSnapshot) -> Result<req::SourceChange> { | ||
478 | let cursor_position = match self.cursor_position { | ||
479 | None => None, | ||
480 | Some(pos) => { | ||
481 | let line_index = world.analysis().file_line_index(pos.file_id)?; | ||
482 | let edit = self | ||
483 | .source_file_edits | ||
484 | .iter() | ||
485 | .find(|it| it.file_id == pos.file_id) | ||
486 | .map(|it| &it.edit); | ||
487 | let line_col = match edit { | ||
488 | Some(edit) => translate_offset_with_edit(&*line_index, pos.offset, edit), | ||
489 | None => line_index.line_col(pos.offset), | ||
490 | }; | ||
491 | let position = | ||
492 | Position::new(u64::from(line_col.line), u64::from(line_col.col_utf16)); | ||
493 | Some(TextDocumentPositionParams { | ||
494 | text_document: TextDocumentIdentifier::new(pos.file_id.try_conv_with(world)?), | ||
495 | position, | ||
496 | }) | ||
497 | } | ||
498 | }; | ||
499 | let mut document_changes: Vec<DocumentChangeOperation> = Vec::new(); | ||
500 | for resource_op in self.file_system_edits.try_conv_with(world)? { | ||
501 | document_changes.push(DocumentChangeOperation::Op(resource_op)); | ||
502 | } | ||
503 | for text_document_edit in self.source_file_edits.try_conv_with(world)? { | ||
504 | document_changes.push(DocumentChangeOperation::Edit(text_document_edit)); | ||
505 | } | ||
506 | let workspace_edit = WorkspaceEdit { | ||
507 | changes: None, | ||
508 | document_changes: Some(DocumentChanges::Operations(document_changes)), | ||
509 | }; | ||
510 | Ok(req::SourceChange { label: self.label, workspace_edit, cursor_position }) | ||
511 | } | ||
512 | } | ||
513 | |||
514 | impl TryConvWith<&WorldSnapshot> for SourceFileEdit { | ||
515 | type Output = TextDocumentEdit; | ||
516 | fn try_conv_with(self, world: &WorldSnapshot) -> Result<TextDocumentEdit> { | ||
517 | let text_document = VersionedTextDocumentIdentifier { | ||
518 | uri: self.file_id.try_conv_with(world)?, | ||
519 | version: None, | ||
520 | }; | ||
521 | let line_index = world.analysis().file_line_index(self.file_id)?; | ||
522 | let line_endings = world.file_line_endings(self.file_id); | ||
523 | let edits = | ||
524 | self.edit.as_indels().iter().map_conv_with((&line_index, line_endings)).collect(); | ||
525 | Ok(TextDocumentEdit { text_document, edits }) | ||
526 | } | ||
527 | } | ||
528 | |||
529 | impl TryConvWith<&WorldSnapshot> for FileSystemEdit { | ||
530 | type Output = ResourceOp; | ||
531 | fn try_conv_with(self, world: &WorldSnapshot) -> Result<ResourceOp> { | ||
532 | let res = match self { | ||
533 | FileSystemEdit::CreateFile { source_root, path } => { | ||
534 | let uri = world.path_to_uri(source_root, &path)?; | ||
535 | ResourceOp::Create(CreateFile { uri, options: None }) | ||
536 | } | ||
537 | FileSystemEdit::MoveFile { src, dst_source_root, dst_path } => { | ||
538 | let old_uri = world.file_id_to_uri(src)?; | ||
539 | let new_uri = world.path_to_uri(dst_source_root, &dst_path)?; | ||
540 | ResourceOp::Rename(RenameFile { old_uri, new_uri, options: None }) | ||
541 | } | ||
542 | }; | ||
543 | Ok(res) | ||
544 | } | ||
545 | } | ||
546 | |||
547 | impl TryConvWith<&WorldSnapshot> for &NavigationTarget { | ||
548 | type Output = Location; | ||
549 | fn try_conv_with(self, world: &WorldSnapshot) -> Result<Location> { | ||
550 | let line_index = world.analysis().file_line_index(self.file_id())?; | ||
551 | let range = self.range(); | ||
552 | to_location(self.file_id(), range, &world, &line_index) | ||
553 | } | ||
554 | } | ||
555 | |||
556 | impl TryConvWith<&WorldSnapshot> for (FileId, RangeInfo<NavigationTarget>) { | ||
557 | type Output = LocationLink; | ||
558 | fn try_conv_with(self, world: &WorldSnapshot) -> Result<LocationLink> { | ||
559 | let (src_file_id, target) = self; | ||
560 | |||
561 | let target_uri = target.info.file_id().try_conv_with(world)?; | ||
562 | let src_line_index = world.analysis().file_line_index(src_file_id)?; | ||
563 | let tgt_line_index = world.analysis().file_line_index(target.info.file_id())?; | ||
564 | |||
565 | let target_range = target.info.full_range().conv_with(&tgt_line_index); | ||
566 | |||
567 | let target_selection_range = target | ||
568 | .info | ||
569 | .focus_range() | ||
570 | .map(|it| it.conv_with(&tgt_line_index)) | ||
571 | .unwrap_or(target_range); | ||
572 | |||
573 | let res = LocationLink { | ||
574 | origin_selection_range: Some(target.range.conv_with(&src_line_index)), | ||
575 | target_uri, | ||
576 | target_range, | ||
577 | target_selection_range, | ||
578 | }; | ||
579 | Ok(res) | ||
580 | } | ||
581 | } | ||
582 | |||
583 | impl TryConvWith<&WorldSnapshot> for (FileId, RangeInfo<Vec<NavigationTarget>>) { | ||
584 | type Output = req::GotoDefinitionResponse; | ||
585 | fn try_conv_with(self, world: &WorldSnapshot) -> Result<req::GotoTypeDefinitionResponse> { | ||
586 | let (file_id, RangeInfo { range, info: navs }) = self; | ||
587 | let links = navs | ||
588 | .into_iter() | ||
589 | .map(|nav| (file_id, RangeInfo::new(range, nav))) | ||
590 | .try_conv_with_to_vec(world)?; | ||
591 | if world.config.client_caps.location_link { | ||
592 | Ok(links.into()) | ||
593 | } else { | ||
594 | let locations: Vec<Location> = links | ||
595 | .into_iter() | ||
596 | .map(|link| Location { uri: link.target_uri, range: link.target_selection_range }) | ||
597 | .collect(); | ||
598 | Ok(locations.into()) | ||
599 | } | ||
600 | } | ||
601 | } | ||
602 | |||
603 | pub fn to_call_hierarchy_item( | ||
604 | file_id: FileId, | ||
605 | range: TextRange, | ||
606 | world: &WorldSnapshot, | ||
607 | line_index: &LineIndex, | ||
608 | nav: NavigationTarget, | ||
609 | ) -> Result<lsp_types::CallHierarchyItem> { | ||
610 | Ok(lsp_types::CallHierarchyItem { | ||
611 | name: nav.name().to_string(), | ||
612 | kind: nav.kind().conv(), | ||
613 | tags: None, | ||
614 | detail: nav.description().map(|it| it.to_string()), | ||
615 | uri: file_id.try_conv_with(&world)?, | ||
616 | range: nav.range().conv_with(&line_index), | ||
617 | selection_range: range.conv_with(&line_index), | ||
618 | }) | ||
619 | } | ||
620 | |||
621 | pub fn to_location( | ||
622 | file_id: FileId, | ||
623 | range: TextRange, | ||
624 | world: &WorldSnapshot, | ||
625 | line_index: &LineIndex, | ||
626 | ) -> Result<Location> { | ||
627 | let url = file_id.try_conv_with(world)?; | ||
628 | let loc = Location::new(url, range.conv_with(line_index)); | ||
629 | Ok(loc) | ||
630 | } | ||
631 | |||
632 | pub trait MapConvWith<CTX>: Sized { | ||
633 | type Output; | ||
634 | |||
635 | fn map_conv_with(self, ctx: CTX) -> ConvWithIter<Self, CTX> { | ||
636 | ConvWithIter { iter: self, ctx } | ||
637 | } | ||
638 | } | ||
639 | |||
640 | impl<CTX, I> MapConvWith<CTX> for I | ||
641 | where | ||
642 | I: Iterator, | ||
643 | I::Item: ConvWith<CTX>, | ||
644 | { | ||
645 | type Output = <I::Item as ConvWith<CTX>>::Output; | ||
646 | } | ||
647 | |||
648 | pub struct ConvWithIter<I, CTX> { | ||
649 | iter: I, | ||
650 | ctx: CTX, | ||
651 | } | ||
652 | |||
653 | impl<I, CTX> Iterator for ConvWithIter<I, CTX> | ||
654 | where | ||
655 | I: Iterator, | ||
656 | I::Item: ConvWith<CTX>, | ||
657 | CTX: Copy, | ||
658 | { | ||
659 | type Item = <I::Item as ConvWith<CTX>>::Output; | ||
660 | |||
661 | fn next(&mut self) -> Option<Self::Item> { | ||
662 | self.iter.next().map(|item| item.conv_with(self.ctx)) | ||
663 | } | ||
664 | } | ||
665 | |||
666 | pub trait TryConvWithToVec<CTX>: Sized { | ||
667 | type Output; | ||
668 | |||
669 | fn try_conv_with_to_vec(self, ctx: CTX) -> Result<Vec<Self::Output>>; | ||
670 | } | ||
671 | |||
672 | impl<I, CTX> TryConvWithToVec<CTX> for I | ||
673 | where | ||
674 | I: Iterator, | ||
675 | I::Item: TryConvWith<CTX>, | ||
676 | CTX: Copy, | ||
677 | { | ||
678 | type Output = <I::Item as TryConvWith<CTX>>::Output; | ||
679 | |||
680 | fn try_conv_with_to_vec(self, ctx: CTX) -> Result<Vec<Self::Output>> { | ||
681 | self.map(|it| it.try_conv_with(ctx)).collect() | ||
682 | } | ||
683 | } | ||
684 | |||
685 | #[cfg(test)] | ||
686 | mod tests { | ||
687 | use super::*; | ||
688 | use test_utils::extract_ranges; | ||
689 | |||
690 | #[test] | ||
691 | fn conv_fold_line_folding_only_fixup() { | ||
692 | let text = r#"<fold>mod a; | ||
693 | mod b; | ||
694 | mod c;</fold> | ||
695 | |||
696 | fn main() <fold>{ | ||
697 | if cond <fold>{ | ||
698 | a::do_a(); | ||
699 | }</fold> else <fold>{ | ||
700 | b::do_b(); | ||
701 | }</fold> | ||
702 | }</fold>"#; | ||
703 | |||
704 | let (ranges, text) = extract_ranges(text, "fold"); | ||
705 | assert_eq!(ranges.len(), 4); | ||
706 | let folds = vec![ | ||
707 | Fold { range: ranges[0], kind: FoldKind::Mods }, | ||
708 | Fold { range: ranges[1], kind: FoldKind::Block }, | ||
709 | Fold { range: ranges[2], kind: FoldKind::Block }, | ||
710 | Fold { range: ranges[3], kind: FoldKind::Block }, | ||
711 | ]; | ||
712 | |||
713 | let line_index = LineIndex::new(&text); | ||
714 | let ctx = FoldConvCtx { text: &text, line_index: &line_index, line_folding_only: true }; | ||
715 | let converted: Vec<_> = folds.into_iter().map_conv_with(&ctx).collect(); | ||
716 | |||
717 | let expected_lines = [(0, 2), (4, 10), (5, 6), (7, 9)]; | ||
718 | assert_eq!(converted.len(), expected_lines.len()); | ||
719 | for (folding_range, (start_line, end_line)) in converted.iter().zip(expected_lines.iter()) { | ||
720 | assert_eq!(folding_range.start_line, *start_line); | ||
721 | assert_eq!(folding_range.start_character, None); | ||
722 | assert_eq!(folding_range.end_line, *end_line); | ||
723 | assert_eq!(folding_range.end_character, None); | ||
724 | } | ||
725 | } | ||
726 | } | ||
diff --git a/crates/rust-analyzer/src/from_proto.rs b/crates/rust-analyzer/src/from_proto.rs new file mode 100644 index 000000000..4bb16a496 --- /dev/null +++ b/crates/rust-analyzer/src/from_proto.rs | |||
@@ -0,0 +1,42 @@ | |||
1 | //! Conversion lsp_types types to rust-analyzer specific ones. | ||
2 | use ra_db::{FileId, FilePosition, FileRange}; | ||
3 | use ra_ide::{LineCol, LineIndex}; | ||
4 | use ra_syntax::{TextRange, TextSize}; | ||
5 | |||
6 | use crate::{world::WorldSnapshot, Result}; | ||
7 | |||
8 | pub(crate) fn offset(line_index: &LineIndex, position: lsp_types::Position) -> TextSize { | ||
9 | let line_col = LineCol { line: position.line as u32, col_utf16: position.character as u32 }; | ||
10 | line_index.offset(line_col) | ||
11 | } | ||
12 | |||
13 | pub(crate) fn text_range(line_index: &LineIndex, range: lsp_types::Range) -> TextRange { | ||
14 | let start = offset(line_index, range.start); | ||
15 | let end = offset(line_index, range.end); | ||
16 | TextRange::new(start, end) | ||
17 | } | ||
18 | |||
19 | pub(crate) fn file_id(world: &WorldSnapshot, url: &lsp_types::Url) -> Result<FileId> { | ||
20 | world.uri_to_file_id(url) | ||
21 | } | ||
22 | |||
23 | pub(crate) fn file_position( | ||
24 | world: &WorldSnapshot, | ||
25 | tdpp: lsp_types::TextDocumentPositionParams, | ||
26 | ) -> Result<FilePosition> { | ||
27 | let file_id = file_id(world, &tdpp.text_document.uri)?; | ||
28 | let line_index = world.analysis().file_line_index(file_id)?; | ||
29 | let offset = offset(&*line_index, tdpp.position); | ||
30 | Ok(FilePosition { file_id, offset }) | ||
31 | } | ||
32 | |||
33 | pub(crate) fn file_range( | ||
34 | world: &WorldSnapshot, | ||
35 | text_document_identifier: lsp_types::TextDocumentIdentifier, | ||
36 | range: lsp_types::Range, | ||
37 | ) -> Result<FileRange> { | ||
38 | let file_id = file_id(world, &text_document_identifier.uri)?; | ||
39 | let line_index = world.analysis().file_line_index(file_id)?; | ||
40 | let range = text_range(&line_index, range); | ||
41 | Ok(FileRange { file_id, range }) | ||
42 | } | ||
diff --git a/crates/rust-analyzer/src/lib.rs b/crates/rust-analyzer/src/lib.rs index 036bf62a7..57d0e9218 100644 --- a/crates/rust-analyzer/src/lib.rs +++ b/crates/rust-analyzer/src/lib.rs | |||
@@ -20,10 +20,11 @@ macro_rules! eprintln { | |||
20 | mod vfs_glob; | 20 | mod vfs_glob; |
21 | mod caps; | 21 | mod caps; |
22 | mod cargo_target_spec; | 22 | mod cargo_target_spec; |
23 | mod conv; | 23 | mod to_proto; |
24 | mod from_proto; | ||
24 | mod main_loop; | 25 | mod main_loop; |
25 | mod markdown; | 26 | mod markdown; |
26 | pub mod req; | 27 | pub mod lsp_ext; |
27 | pub mod config; | 28 | pub mod config; |
28 | mod world; | 29 | mod world; |
29 | mod diagnostics; | 30 | mod diagnostics; |
diff --git a/crates/rust-analyzer/src/req.rs b/crates/rust-analyzer/src/lsp_ext.rs index 0dae6bad4..313a8c769 100644 --- a/crates/rust-analyzer/src/req.rs +++ b/crates/rust-analyzer/src/lsp_ext.rs | |||
@@ -1,25 +1,12 @@ | |||
1 | //! Defines `rust-analyzer` specific custom messages. | 1 | //! rust-analyzer extensions to the LSP. |
2 | 2 | ||
3 | use std::path::PathBuf; | ||
4 | |||
5 | use lsp_types::request::Request; | ||
3 | use lsp_types::{Location, Position, Range, TextDocumentIdentifier}; | 6 | use lsp_types::{Location, Position, Range, TextDocumentIdentifier}; |
4 | use rustc_hash::FxHashMap; | 7 | use rustc_hash::FxHashMap; |
5 | use serde::{Deserialize, Serialize}; | 8 | use serde::{Deserialize, Serialize}; |
6 | 9 | ||
7 | pub use lsp_types::{ | ||
8 | notification::*, request::*, ApplyWorkspaceEditParams, CodeActionParams, CodeLens, | ||
9 | CodeLensParams, CompletionParams, CompletionResponse, ConfigurationItem, ConfigurationParams, | ||
10 | DiagnosticTag, DidChangeConfigurationParams, DidChangeWatchedFilesParams, | ||
11 | DidChangeWatchedFilesRegistrationOptions, DocumentHighlightParams, | ||
12 | DocumentOnTypeFormattingParams, DocumentSymbolParams, DocumentSymbolResponse, | ||
13 | FileSystemWatcher, GotoDefinitionParams, GotoDefinitionResponse, Hover, HoverParams, | ||
14 | InitializeResult, MessageType, PartialResultParams, ProgressParams, ProgressParamsValue, | ||
15 | ProgressToken, PublishDiagnosticsParams, ReferenceParams, Registration, RegistrationParams, | ||
16 | SelectionRange, SelectionRangeParams, SemanticTokensParams, SemanticTokensRangeParams, | ||
17 | SemanticTokensRangeResult, SemanticTokensResult, ServerCapabilities, ShowMessageParams, | ||
18 | SignatureHelp, SignatureHelpParams, SymbolKind, TextDocumentEdit, TextDocumentPositionParams, | ||
19 | TextEdit, WorkDoneProgressParams, WorkspaceEdit, WorkspaceSymbolParams, | ||
20 | }; | ||
21 | use std::path::PathBuf; | ||
22 | |||
23 | pub enum AnalyzerStatus {} | 10 | pub enum AnalyzerStatus {} |
24 | 11 | ||
25 | impl Request for AnalyzerStatus { | 12 | impl Request for AnalyzerStatus { |
@@ -91,7 +78,7 @@ pub struct FindMatchingBraceParams { | |||
91 | pub enum ParentModule {} | 78 | pub enum ParentModule {} |
92 | 79 | ||
93 | impl Request for ParentModule { | 80 | impl Request for ParentModule { |
94 | type Params = TextDocumentPositionParams; | 81 | type Params = lsp_types::TextDocumentPositionParams; |
95 | type Result = Vec<Location>; | 82 | type Result = Vec<Location>; |
96 | const METHOD: &'static str = "rust-analyzer/parentModule"; | 83 | const METHOD: &'static str = "rust-analyzer/parentModule"; |
97 | } | 84 | } |
@@ -114,7 +101,7 @@ pub struct JoinLinesParams { | |||
114 | pub enum OnEnter {} | 101 | pub enum OnEnter {} |
115 | 102 | ||
116 | impl Request for OnEnter { | 103 | impl Request for OnEnter { |
117 | type Params = TextDocumentPositionParams; | 104 | type Params = lsp_types::TextDocumentPositionParams; |
118 | type Result = Option<SourceChange>; | 105 | type Result = Option<SourceChange>; |
119 | const METHOD: &'static str = "rust-analyzer/onEnter"; | 106 | const METHOD: &'static str = "rust-analyzer/onEnter"; |
120 | } | 107 | } |
@@ -150,8 +137,8 @@ pub struct Runnable { | |||
150 | #[serde(rename_all = "camelCase")] | 137 | #[serde(rename_all = "camelCase")] |
151 | pub struct SourceChange { | 138 | pub struct SourceChange { |
152 | pub label: String, | 139 | pub label: String, |
153 | pub workspace_edit: WorkspaceEdit, | 140 | pub workspace_edit: lsp_types::WorkspaceEdit, |
154 | pub cursor_position: Option<TextDocumentPositionParams>, | 141 | pub cursor_position: Option<lsp_types::TextDocumentPositionParams>, |
155 | } | 142 | } |
156 | 143 | ||
157 | pub enum InlayHints {} | 144 | pub enum InlayHints {} |
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs index 17b0b95b9..fa72a9cc6 100644 --- a/crates/rust-analyzer/src/main_loop.rs +++ b/crates/rust-analyzer/src/main_loop.rs | |||
@@ -37,13 +37,12 @@ use threadpool::ThreadPool; | |||
37 | 37 | ||
38 | use crate::{ | 38 | use crate::{ |
39 | config::{Config, FilesWatcher}, | 39 | config::{Config, FilesWatcher}, |
40 | conv::{ConvWith, TryConvWith}, | ||
41 | diagnostics::DiagnosticTask, | 40 | diagnostics::DiagnosticTask, |
41 | from_proto, lsp_ext, | ||
42 | main_loop::{ | 42 | main_loop::{ |
43 | pending_requests::{PendingRequest, PendingRequests}, | 43 | pending_requests::{PendingRequest, PendingRequests}, |
44 | subscriptions::Subscriptions, | 44 | subscriptions::Subscriptions, |
45 | }, | 45 | }, |
46 | req, | ||
47 | world::{WorldSnapshot, WorldState}, | 46 | world::{WorldSnapshot, WorldState}, |
48 | Result, | 47 | Result, |
49 | }; | 48 | }; |
@@ -104,7 +103,7 @@ pub fn main_loop(ws_roots: Vec<PathBuf>, config: Config, connection: Connection) | |||
104 | 103 | ||
105 | if project_roots.is_empty() && config.notifications.cargo_toml_not_found { | 104 | if project_roots.is_empty() && config.notifications.cargo_toml_not_found { |
106 | show_message( | 105 | show_message( |
107 | req::MessageType::Error, | 106 | lsp_types::MessageType::Error, |
108 | format!( | 107 | format!( |
109 | "rust-analyzer failed to discover workspace, no Cargo.toml found, dirs searched: {}", | 108 | "rust-analyzer failed to discover workspace, no Cargo.toml found, dirs searched: {}", |
110 | ws_roots.iter().format_with(", ", |it, f| f(&it.display())) | 109 | ws_roots.iter().format_with(", ", |it, f| f(&it.display())) |
@@ -124,7 +123,7 @@ pub fn main_loop(ws_roots: Vec<PathBuf>, config: Config, connection: Connection) | |||
124 | .map_err(|err| { | 123 | .map_err(|err| { |
125 | log::error!("failed to load workspace: {:#}", err); | 124 | log::error!("failed to load workspace: {:#}", err); |
126 | show_message( | 125 | show_message( |
127 | req::MessageType::Error, | 126 | lsp_types::MessageType::Error, |
128 | format!("rust-analyzer failed to load workspace: {:#}", err), | 127 | format!("rust-analyzer failed to load workspace: {:#}", err), |
129 | &connection.sender, | 128 | &connection.sender, |
130 | ); | 129 | ); |
@@ -142,23 +141,25 @@ pub fn main_loop(ws_roots: Vec<PathBuf>, config: Config, connection: Connection) | |||
142 | .collect::<std::result::Result<Vec<_>, _>>()?; | 141 | .collect::<std::result::Result<Vec<_>, _>>()?; |
143 | 142 | ||
144 | if let FilesWatcher::Client = config.files.watcher { | 143 | if let FilesWatcher::Client = config.files.watcher { |
145 | let registration_options = req::DidChangeWatchedFilesRegistrationOptions { | 144 | let registration_options = lsp_types::DidChangeWatchedFilesRegistrationOptions { |
146 | watchers: workspaces | 145 | watchers: workspaces |
147 | .iter() | 146 | .iter() |
148 | .flat_map(ProjectWorkspace::to_roots) | 147 | .flat_map(ProjectWorkspace::to_roots) |
149 | .filter(PackageRoot::is_member) | 148 | .filter(PackageRoot::is_member) |
150 | .map(|root| format!("{}/**/*.rs", root.path().display())) | 149 | .map(|root| format!("{}/**/*.rs", root.path().display())) |
151 | .map(|glob_pattern| req::FileSystemWatcher { glob_pattern, kind: None }) | 150 | .map(|glob_pattern| lsp_types::FileSystemWatcher { glob_pattern, kind: None }) |
152 | .collect(), | 151 | .collect(), |
153 | }; | 152 | }; |
154 | let registration = req::Registration { | 153 | let registration = lsp_types::Registration { |
155 | id: "file-watcher".to_string(), | 154 | id: "file-watcher".to_string(), |
156 | method: "workspace/didChangeWatchedFiles".to_string(), | 155 | method: "workspace/didChangeWatchedFiles".to_string(), |
157 | register_options: Some(serde_json::to_value(registration_options).unwrap()), | 156 | register_options: Some(serde_json::to_value(registration_options).unwrap()), |
158 | }; | 157 | }; |
159 | let params = req::RegistrationParams { registrations: vec![registration] }; | 158 | let params = lsp_types::RegistrationParams { registrations: vec![registration] }; |
160 | let request = | 159 | let request = request_new::<lsp_types::request::RegisterCapability>( |
161 | request_new::<req::RegisterCapability>(loop_state.next_request_id(), params); | 160 | loop_state.next_request_id(), |
161 | params, | ||
162 | ); | ||
162 | connection.sender.send(request.into()).unwrap(); | 163 | connection.sender.send(request.into()).unwrap(); |
163 | } | 164 | } |
164 | 165 | ||
@@ -258,14 +259,14 @@ impl fmt::Debug for Event { | |||
258 | 259 | ||
259 | match self { | 260 | match self { |
260 | Event::Msg(Message::Notification(not)) => { | 261 | Event::Msg(Message::Notification(not)) => { |
261 | if notification_is::<req::DidOpenTextDocument>(not) | 262 | if notification_is::<lsp_types::notification::DidOpenTextDocument>(not) |
262 | || notification_is::<req::DidChangeTextDocument>(not) | 263 | || notification_is::<lsp_types::notification::DidChangeTextDocument>(not) |
263 | { | 264 | { |
264 | return debug_verbose_not(not, f); | 265 | return debug_verbose_not(not, f); |
265 | } | 266 | } |
266 | } | 267 | } |
267 | Event::Task(Task::Notify(not)) => { | 268 | Event::Task(Task::Notify(not)) => { |
268 | if notification_is::<req::PublishDiagnostics>(not) { | 269 | if notification_is::<lsp_types::notification::PublishDiagnostics>(not) { |
269 | return debug_verbose_not(not, f); | 270 | return debug_verbose_not(not, f); |
270 | } | 271 | } |
271 | } | 272 | } |
@@ -450,7 +451,7 @@ fn loop_turn( | |||
450 | log::error!("overly long loop turn: {:?}", loop_duration); | 451 | log::error!("overly long loop turn: {:?}", loop_duration); |
451 | if env::var("RA_PROFILE").is_ok() { | 452 | if env::var("RA_PROFILE").is_ok() { |
452 | show_message( | 453 | show_message( |
453 | req::MessageType::Error, | 454 | lsp_types::MessageType::Error, |
454 | format!("overly long loop turn: {:?}", loop_duration), | 455 | format!("overly long loop turn: {:?}", loop_duration), |
455 | &connection.sender, | 456 | &connection.sender, |
456 | ); | 457 | ); |
@@ -500,45 +501,51 @@ fn on_request( | |||
500 | request_received, | 501 | request_received, |
501 | }; | 502 | }; |
502 | pool_dispatcher | 503 | pool_dispatcher |
503 | .on_sync::<req::CollectGarbage>(|s, ()| Ok(s.collect_garbage()))? | 504 | .on_sync::<lsp_ext::CollectGarbage>(|s, ()| Ok(s.collect_garbage()))? |
504 | .on_sync::<req::JoinLines>(|s, p| handlers::handle_join_lines(s.snapshot(), p))? | 505 | .on_sync::<lsp_ext::JoinLines>(|s, p| handlers::handle_join_lines(s.snapshot(), p))? |
505 | .on_sync::<req::OnEnter>(|s, p| handlers::handle_on_enter(s.snapshot(), p))? | 506 | .on_sync::<lsp_ext::OnEnter>(|s, p| handlers::handle_on_enter(s.snapshot(), p))? |
506 | .on_sync::<req::SelectionRangeRequest>(|s, p| { | 507 | .on_sync::<lsp_types::request::SelectionRangeRequest>(|s, p| { |
507 | handlers::handle_selection_range(s.snapshot(), p) | 508 | handlers::handle_selection_range(s.snapshot(), p) |
508 | })? | 509 | })? |
509 | .on_sync::<req::FindMatchingBrace>(|s, p| { | 510 | .on_sync::<lsp_ext::FindMatchingBrace>(|s, p| { |
510 | handlers::handle_find_matching_brace(s.snapshot(), p) | 511 | handlers::handle_find_matching_brace(s.snapshot(), p) |
511 | })? | 512 | })? |
512 | .on::<req::AnalyzerStatus>(handlers::handle_analyzer_status)? | 513 | .on::<lsp_ext::AnalyzerStatus>(handlers::handle_analyzer_status)? |
513 | .on::<req::SyntaxTree>(handlers::handle_syntax_tree)? | 514 | .on::<lsp_ext::SyntaxTree>(handlers::handle_syntax_tree)? |
514 | .on::<req::ExpandMacro>(handlers::handle_expand_macro)? | 515 | .on::<lsp_ext::ExpandMacro>(handlers::handle_expand_macro)? |
515 | .on::<req::OnTypeFormatting>(handlers::handle_on_type_formatting)? | 516 | .on::<lsp_ext::ParentModule>(handlers::handle_parent_module)? |
516 | .on::<req::DocumentSymbolRequest>(handlers::handle_document_symbol)? | 517 | .on::<lsp_ext::Runnables>(handlers::handle_runnables)? |
517 | .on::<req::WorkspaceSymbol>(handlers::handle_workspace_symbol)? | 518 | .on::<lsp_ext::InlayHints>(handlers::handle_inlay_hints)? |
518 | .on::<req::GotoDefinition>(handlers::handle_goto_definition)? | 519 | .on::<lsp_types::request::OnTypeFormatting>(handlers::handle_on_type_formatting)? |
519 | .on::<req::GotoImplementation>(handlers::handle_goto_implementation)? | 520 | .on::<lsp_types::request::DocumentSymbolRequest>(handlers::handle_document_symbol)? |
520 | .on::<req::GotoTypeDefinition>(handlers::handle_goto_type_definition)? | 521 | .on::<lsp_types::request::WorkspaceSymbol>(handlers::handle_workspace_symbol)? |
521 | .on::<req::ParentModule>(handlers::handle_parent_module)? | 522 | .on::<lsp_types::request::GotoDefinition>(handlers::handle_goto_definition)? |
522 | .on::<req::Runnables>(handlers::handle_runnables)? | 523 | .on::<lsp_types::request::GotoImplementation>(handlers::handle_goto_implementation)? |
523 | .on::<req::Completion>(handlers::handle_completion)? | 524 | .on::<lsp_types::request::GotoTypeDefinition>(handlers::handle_goto_type_definition)? |
524 | .on::<req::CodeActionRequest>(handlers::handle_code_action)? | 525 | .on::<lsp_types::request::Completion>(handlers::handle_completion)? |
525 | .on::<req::CodeLensRequest>(handlers::handle_code_lens)? | 526 | .on::<lsp_types::request::CodeActionRequest>(handlers::handle_code_action)? |
526 | .on::<req::CodeLensResolve>(handlers::handle_code_lens_resolve)? | 527 | .on::<lsp_types::request::CodeLensRequest>(handlers::handle_code_lens)? |
527 | .on::<req::FoldingRangeRequest>(handlers::handle_folding_range)? | 528 | .on::<lsp_types::request::CodeLensResolve>(handlers::handle_code_lens_resolve)? |
528 | .on::<req::SignatureHelpRequest>(handlers::handle_signature_help)? | 529 | .on::<lsp_types::request::FoldingRangeRequest>(handlers::handle_folding_range)? |
529 | .on::<req::HoverRequest>(handlers::handle_hover)? | 530 | .on::<lsp_types::request::SignatureHelpRequest>(handlers::handle_signature_help)? |
530 | .on::<req::PrepareRenameRequest>(handlers::handle_prepare_rename)? | 531 | .on::<lsp_types::request::HoverRequest>(handlers::handle_hover)? |
531 | .on::<req::Rename>(handlers::handle_rename)? | 532 | .on::<lsp_types::request::PrepareRenameRequest>(handlers::handle_prepare_rename)? |
532 | .on::<req::References>(handlers::handle_references)? | 533 | .on::<lsp_types::request::Rename>(handlers::handle_rename)? |
533 | .on::<req::Formatting>(handlers::handle_formatting)? | 534 | .on::<lsp_types::request::References>(handlers::handle_references)? |
534 | .on::<req::DocumentHighlightRequest>(handlers::handle_document_highlight)? | 535 | .on::<lsp_types::request::Formatting>(handlers::handle_formatting)? |
535 | .on::<req::InlayHints>(handlers::handle_inlay_hints)? | 536 | .on::<lsp_types::request::DocumentHighlightRequest>(handlers::handle_document_highlight)? |
536 | .on::<req::CallHierarchyPrepare>(handlers::handle_call_hierarchy_prepare)? | 537 | .on::<lsp_types::request::CallHierarchyPrepare>(handlers::handle_call_hierarchy_prepare)? |
537 | .on::<req::CallHierarchyIncomingCalls>(handlers::handle_call_hierarchy_incoming)? | 538 | .on::<lsp_types::request::CallHierarchyIncomingCalls>( |
538 | .on::<req::CallHierarchyOutgoingCalls>(handlers::handle_call_hierarchy_outgoing)? | 539 | handlers::handle_call_hierarchy_incoming, |
539 | .on::<req::SemanticTokensRequest>(handlers::handle_semantic_tokens)? | 540 | )? |
540 | .on::<req::SemanticTokensRangeRequest>(handlers::handle_semantic_tokens_range)? | 541 | .on::<lsp_types::request::CallHierarchyOutgoingCalls>( |
541 | .on::<req::Ssr>(handlers::handle_ssr)? | 542 | handlers::handle_call_hierarchy_outgoing, |
543 | )? | ||
544 | .on::<lsp_types::request::SemanticTokensRequest>(handlers::handle_semantic_tokens)? | ||
545 | .on::<lsp_types::request::SemanticTokensRangeRequest>( | ||
546 | handlers::handle_semantic_tokens_range, | ||
547 | )? | ||
548 | .on::<lsp_ext::Ssr>(handlers::handle_ssr)? | ||
542 | .finish(); | 549 | .finish(); |
543 | Ok(()) | 550 | Ok(()) |
544 | } | 551 | } |
@@ -549,7 +556,7 @@ fn on_notification( | |||
549 | loop_state: &mut LoopState, | 556 | loop_state: &mut LoopState, |
550 | not: Notification, | 557 | not: Notification, |
551 | ) -> Result<()> { | 558 | ) -> Result<()> { |
552 | let not = match notification_cast::<req::Cancel>(not) { | 559 | let not = match notification_cast::<lsp_types::notification::Cancel>(not) { |
553 | Ok(params) => { | 560 | Ok(params) => { |
554 | let id: RequestId = match params.id { | 561 | let id: RequestId = match params.id { |
555 | NumberOrString::Number(id) => id.into(), | 562 | NumberOrString::Number(id) => id.into(), |
@@ -567,7 +574,7 @@ fn on_notification( | |||
567 | } | 574 | } |
568 | Err(not) => not, | 575 | Err(not) => not, |
569 | }; | 576 | }; |
570 | let not = match notification_cast::<req::DidOpenTextDocument>(not) { | 577 | let not = match notification_cast::<lsp_types::notification::DidOpenTextDocument>(not) { |
571 | Ok(params) => { | 578 | Ok(params) => { |
572 | let uri = params.text_document.uri; | 579 | let uri = params.text_document.uri; |
573 | let path = uri.to_file_path().map_err(|()| format!("invalid uri: {}", uri))?; | 580 | let path = uri.to_file_path().map_err(|()| format!("invalid uri: {}", uri))?; |
@@ -580,11 +587,11 @@ fn on_notification( | |||
580 | } | 587 | } |
581 | Err(not) => not, | 588 | Err(not) => not, |
582 | }; | 589 | }; |
583 | let not = match notification_cast::<req::DidChangeTextDocument>(not) { | 590 | let not = match notification_cast::<lsp_types::notification::DidChangeTextDocument>(not) { |
584 | Ok(params) => { | 591 | Ok(params) => { |
585 | let DidChangeTextDocumentParams { text_document, content_changes } = params; | 592 | let DidChangeTextDocumentParams { text_document, content_changes } = params; |
586 | let world = state.snapshot(); | 593 | let world = state.snapshot(); |
587 | let file_id = text_document.try_conv_with(&world)?; | 594 | let file_id = from_proto::file_id(&world, &text_document.uri)?; |
588 | let line_index = world.analysis().file_line_index(file_id)?; | 595 | let line_index = world.analysis().file_line_index(file_id)?; |
589 | let uri = text_document.uri; | 596 | let uri = text_document.uri; |
590 | let path = uri.to_file_path().map_err(|()| format!("invalid uri: {}", uri))?; | 597 | let path = uri.to_file_path().map_err(|()| format!("invalid uri: {}", uri))?; |
@@ -595,7 +602,7 @@ fn on_notification( | |||
595 | } | 602 | } |
596 | Err(not) => not, | 603 | Err(not) => not, |
597 | }; | 604 | }; |
598 | let not = match notification_cast::<req::DidSaveTextDocument>(not) { | 605 | let not = match notification_cast::<lsp_types::notification::DidSaveTextDocument>(not) { |
599 | Ok(_params) => { | 606 | Ok(_params) => { |
600 | if let Some(flycheck) = &state.flycheck { | 607 | if let Some(flycheck) = &state.flycheck { |
601 | flycheck.update(); | 608 | flycheck.update(); |
@@ -604,7 +611,7 @@ fn on_notification( | |||
604 | } | 611 | } |
605 | Err(not) => not, | 612 | Err(not) => not, |
606 | }; | 613 | }; |
607 | let not = match notification_cast::<req::DidCloseTextDocument>(not) { | 614 | let not = match notification_cast::<lsp_types::notification::DidCloseTextDocument>(not) { |
608 | Ok(params) => { | 615 | Ok(params) => { |
609 | let uri = params.text_document.uri; | 616 | let uri = params.text_document.uri; |
610 | let path = uri.to_file_path().map_err(|()| format!("invalid uri: {}", uri))?; | 617 | let path = uri.to_file_path().map_err(|()| format!("invalid uri: {}", uri))?; |
@@ -612,22 +619,22 @@ fn on_notification( | |||
612 | loop_state.subscriptions.remove_sub(FileId(file_id.0)); | 619 | loop_state.subscriptions.remove_sub(FileId(file_id.0)); |
613 | } | 620 | } |
614 | let params = | 621 | let params = |
615 | req::PublishDiagnosticsParams { uri, diagnostics: Vec::new(), version: None }; | 622 | lsp_types::PublishDiagnosticsParams { uri, diagnostics: Vec::new(), version: None }; |
616 | let not = notification_new::<req::PublishDiagnostics>(params); | 623 | let not = notification_new::<lsp_types::notification::PublishDiagnostics>(params); |
617 | msg_sender.send(not.into()).unwrap(); | 624 | msg_sender.send(not.into()).unwrap(); |
618 | return Ok(()); | 625 | return Ok(()); |
619 | } | 626 | } |
620 | Err(not) => not, | 627 | Err(not) => not, |
621 | }; | 628 | }; |
622 | let not = match notification_cast::<req::DidChangeConfiguration>(not) { | 629 | let not = match notification_cast::<lsp_types::notification::DidChangeConfiguration>(not) { |
623 | Ok(_) => { | 630 | Ok(_) => { |
624 | // As stated in https://github.com/microsoft/language-server-protocol/issues/676, | 631 | // As stated in https://github.com/microsoft/language-server-protocol/issues/676, |
625 | // this notification's parameters should be ignored and the actual config queried separately. | 632 | // this notification's parameters should be ignored and the actual config queried separately. |
626 | let request_id = loop_state.next_request_id(); | 633 | let request_id = loop_state.next_request_id(); |
627 | let request = request_new::<req::WorkspaceConfiguration>( | 634 | let request = request_new::<lsp_types::request::WorkspaceConfiguration>( |
628 | request_id.clone(), | 635 | request_id.clone(), |
629 | req::ConfigurationParams { | 636 | lsp_types::ConfigurationParams { |
630 | items: vec![req::ConfigurationItem { | 637 | items: vec![lsp_types::ConfigurationItem { |
631 | scope_uri: None, | 638 | scope_uri: None, |
632 | section: Some("rust-analyzer".to_string()), | 639 | section: Some("rust-analyzer".to_string()), |
633 | }], | 640 | }], |
@@ -640,7 +647,7 @@ fn on_notification( | |||
640 | } | 647 | } |
641 | Err(not) => not, | 648 | Err(not) => not, |
642 | }; | 649 | }; |
643 | let not = match notification_cast::<req::DidChangeWatchedFiles>(not) { | 650 | let not = match notification_cast::<lsp_types::notification::DidChangeWatchedFiles>(not) { |
644 | Ok(params) => { | 651 | Ok(params) => { |
645 | let mut vfs = state.vfs.write(); | 652 | let mut vfs = state.vfs.write(); |
646 | for change in params.changes { | 653 | for change in params.changes { |
@@ -694,7 +701,7 @@ fn apply_document_changes( | |||
694 | line_index = Cow::Owned(LineIndex::new(&old_text)); | 701 | line_index = Cow::Owned(LineIndex::new(&old_text)); |
695 | } | 702 | } |
696 | index_valid = IndexValid::UpToLineExclusive(range.start.line); | 703 | index_valid = IndexValid::UpToLineExclusive(range.start.line); |
697 | let range = range.conv_with(&line_index); | 704 | let range = from_proto::text_range(&line_index, range); |
698 | let mut text = old_text.to_owned(); | 705 | let mut text = old_text.to_owned(); |
699 | match std::panic::catch_unwind(move || { | 706 | match std::panic::catch_unwind(move || { |
700 | text.replace_range(Range::<usize>::from(range), &change.text); | 707 | text.replace_range(Range::<usize>::from(range), &change.text); |
@@ -742,11 +749,11 @@ fn on_check_task( | |||
742 | } | 749 | } |
743 | 750 | ||
744 | CheckTask::Status(progress) => { | 751 | CheckTask::Status(progress) => { |
745 | let params = req::ProgressParams { | 752 | let params = lsp_types::ProgressParams { |
746 | token: req::ProgressToken::String("rustAnalyzer/cargoWatcher".to_string()), | 753 | token: lsp_types::ProgressToken::String("rustAnalyzer/cargoWatcher".to_string()), |
747 | value: req::ProgressParamsValue::WorkDone(progress), | 754 | value: lsp_types::ProgressParamsValue::WorkDone(progress), |
748 | }; | 755 | }; |
749 | let not = notification_new::<req::Progress>(params); | 756 | let not = notification_new::<lsp_types::notification::Progress>(params); |
750 | task_sender.send(Task::Notify(not)).unwrap(); | 757 | task_sender.send(Task::Notify(not)).unwrap(); |
751 | } | 758 | } |
752 | }; | 759 | }; |
@@ -768,8 +775,8 @@ fn on_diagnostic_task(task: DiagnosticTask, msg_sender: &Sender<Message>, state: | |||
768 | }; | 775 | }; |
769 | 776 | ||
770 | let diagnostics = state.diagnostics.diagnostics_for(file_id).cloned().collect(); | 777 | let diagnostics = state.diagnostics.diagnostics_for(file_id).cloned().collect(); |
771 | let params = req::PublishDiagnosticsParams { uri, diagnostics, version: None }; | 778 | let params = lsp_types::PublishDiagnosticsParams { uri, diagnostics, version: None }; |
772 | let not = notification_new::<req::PublishDiagnostics>(params); | 779 | let not = notification_new::<lsp_types::notification::PublishDiagnostics>(params); |
773 | msg_sender.send(not.into()).unwrap(); | 780 | msg_sender.send(not.into()).unwrap(); |
774 | } | 781 | } |
775 | } | 782 | } |
@@ -782,10 +789,10 @@ fn send_startup_progress(sender: &Sender<Message>, loop_state: &mut LoopState) { | |||
782 | 789 | ||
783 | match (prev, loop_state.workspace_loaded) { | 790 | match (prev, loop_state.workspace_loaded) { |
784 | (None, false) => { | 791 | (None, false) => { |
785 | let work_done_progress_create = request_new::<req::WorkDoneProgressCreate>( | 792 | let work_done_progress_create = request_new::<lsp_types::request::WorkDoneProgressCreate>( |
786 | loop_state.next_request_id(), | 793 | loop_state.next_request_id(), |
787 | WorkDoneProgressCreateParams { | 794 | WorkDoneProgressCreateParams { |
788 | token: req::ProgressToken::String("rustAnalyzer/startup".into()), | 795 | token: lsp_types::ProgressToken::String("rustAnalyzer/startup".into()), |
789 | }, | 796 | }, |
790 | ); | 797 | ); |
791 | sender.send(work_done_progress_create.into()).unwrap(); | 798 | sender.send(work_done_progress_create.into()).unwrap(); |
@@ -817,10 +824,11 @@ fn send_startup_progress(sender: &Sender<Message>, loop_state: &mut LoopState) { | |||
817 | } | 824 | } |
818 | 825 | ||
819 | fn send_startup_progress_notif(sender: &Sender<Message>, work_done_progress: WorkDoneProgress) { | 826 | fn send_startup_progress_notif(sender: &Sender<Message>, work_done_progress: WorkDoneProgress) { |
820 | let notif = notification_new::<req::Progress>(req::ProgressParams { | 827 | let notif = |
821 | token: req::ProgressToken::String("rustAnalyzer/startup".into()), | 828 | notification_new::<lsp_types::notification::Progress>(lsp_types::ProgressParams { |
822 | value: req::ProgressParamsValue::WorkDone(work_done_progress), | 829 | token: lsp_types::ProgressToken::String("rustAnalyzer/startup".into()), |
823 | }); | 830 | value: lsp_types::ProgressParamsValue::WorkDone(work_done_progress), |
831 | }); | ||
824 | sender.send(notif.into()).unwrap(); | 832 | sender.send(notif.into()).unwrap(); |
825 | } | 833 | } |
826 | } | 834 | } |
@@ -842,7 +850,7 @@ impl<'a> PoolDispatcher<'a> { | |||
842 | f: fn(&mut WorldState, R::Params) -> Result<R::Result>, | 850 | f: fn(&mut WorldState, R::Params) -> Result<R::Result>, |
843 | ) -> Result<&mut Self> | 851 | ) -> Result<&mut Self> |
844 | where | 852 | where |
845 | R: req::Request + 'static, | 853 | R: lsp_types::request::Request + 'static, |
846 | R::Params: DeserializeOwned + panic::UnwindSafe + 'static, | 854 | R::Params: DeserializeOwned + panic::UnwindSafe + 'static, |
847 | R::Result: Serialize + 'static, | 855 | R::Result: Serialize + 'static, |
848 | { | 856 | { |
@@ -865,7 +873,7 @@ impl<'a> PoolDispatcher<'a> { | |||
865 | /// Dispatches the request onto thread pool | 873 | /// Dispatches the request onto thread pool |
866 | fn on<R>(&mut self, f: fn(WorldSnapshot, R::Params) -> Result<R::Result>) -> Result<&mut Self> | 874 | fn on<R>(&mut self, f: fn(WorldSnapshot, R::Params) -> Result<R::Result>) -> Result<&mut Self> |
867 | where | 875 | where |
868 | R: req::Request + 'static, | 876 | R: lsp_types::request::Request + 'static, |
869 | R::Params: DeserializeOwned + Send + 'static, | 877 | R::Params: DeserializeOwned + Send + 'static, |
870 | R::Result: Serialize + 'static, | 878 | R::Result: Serialize + 'static, |
871 | { | 879 | { |
@@ -891,7 +899,7 @@ impl<'a> PoolDispatcher<'a> { | |||
891 | 899 | ||
892 | fn parse<R>(&mut self) -> Option<(RequestId, R::Params)> | 900 | fn parse<R>(&mut self) -> Option<(RequestId, R::Params)> |
893 | where | 901 | where |
894 | R: req::Request + 'static, | 902 | R: lsp_types::request::Request + 'static, |
895 | R::Params: DeserializeOwned + 'static, | 903 | R::Params: DeserializeOwned + 'static, |
896 | { | 904 | { |
897 | let req = self.req.take()?; | 905 | let req = self.req.take()?; |
@@ -928,7 +936,7 @@ impl<'a> PoolDispatcher<'a> { | |||
928 | 936 | ||
929 | fn result_to_task<R>(id: RequestId, result: Result<R::Result>) -> Task | 937 | fn result_to_task<R>(id: RequestId, result: Result<R::Result>) -> Task |
930 | where | 938 | where |
931 | R: req::Request + 'static, | 939 | R: lsp_types::request::Request + 'static, |
932 | R::Params: DeserializeOwned + 'static, | 940 | R::Params: DeserializeOwned + 'static, |
933 | R::Result: Serialize + 'static, | 941 | R::Result: Serialize + 'static, |
934 | { | 942 | { |
@@ -984,10 +992,14 @@ fn update_file_notifications_on_threadpool( | |||
984 | } | 992 | } |
985 | } | 993 | } |
986 | 994 | ||
987 | pub fn show_message(typ: req::MessageType, message: impl Into<String>, sender: &Sender<Message>) { | 995 | pub fn show_message( |
996 | typ: lsp_types::MessageType, | ||
997 | message: impl Into<String>, | ||
998 | sender: &Sender<Message>, | ||
999 | ) { | ||
988 | let message = message.into(); | 1000 | let message = message.into(); |
989 | let params = req::ShowMessageParams { typ, message }; | 1001 | let params = lsp_types::ShowMessageParams { typ, message }; |
990 | let not = notification_new::<req::ShowMessage>(params); | 1002 | let not = notification_new::<lsp_types::notification::ShowMessage>(params); |
991 | sender.send(not.into()).unwrap(); | 1003 | sender.send(not.into()).unwrap(); |
992 | } | 1004 | } |
993 | 1005 | ||
diff --git a/crates/rust-analyzer/src/main_loop/handlers.rs b/crates/rust-analyzer/src/main_loop/handlers.rs index f4353af64..be8688bc3 100644 --- a/crates/rust-analyzer/src/main_loop/handlers.rs +++ b/crates/rust-analyzer/src/main_loop/handlers.rs | |||
@@ -22,6 +22,7 @@ use ra_ide::{ | |||
22 | Assist, FileId, FilePosition, FileRange, Query, RangeInfo, Runnable, RunnableKind, SearchScope, | 22 | Assist, FileId, FilePosition, FileRange, Query, RangeInfo, Runnable, RunnableKind, SearchScope, |
23 | }; | 23 | }; |
24 | use ra_prof::profile; | 24 | use ra_prof::profile; |
25 | use ra_project_model::TargetKind; | ||
25 | use ra_syntax::{AstNode, SyntaxKind, TextRange, TextSize}; | 26 | use ra_syntax::{AstNode, SyntaxKind, TextRange, TextSize}; |
26 | use rustc_hash::FxHashMap; | 27 | use rustc_hash::FxHashMap; |
27 | use serde::{Deserialize, Serialize}; | 28 | use serde::{Deserialize, Serialize}; |
@@ -31,18 +32,13 @@ use stdx::format_to; | |||
31 | use crate::{ | 32 | use crate::{ |
32 | cargo_target_spec::CargoTargetSpec, | 33 | cargo_target_spec::CargoTargetSpec, |
33 | config::RustfmtConfig, | 34 | config::RustfmtConfig, |
34 | conv::{ | ||
35 | to_call_hierarchy_item, to_location, Conv, ConvWith, FoldConvCtx, MapConvWith, TryConvWith, | ||
36 | TryConvWithToVec, | ||
37 | }, | ||
38 | diagnostics::DiagnosticTask, | 35 | diagnostics::DiagnosticTask, |
39 | from_json, | 36 | from_json, from_proto, |
40 | req::{self, InlayHint, InlayHintsParams}, | 37 | lsp_ext::{self, InlayHint, InlayHintsParams}, |
41 | semantic_tokens::SemanticTokensBuilder, | 38 | to_proto, |
42 | world::WorldSnapshot, | 39 | world::WorldSnapshot, |
43 | LspError, Result, | 40 | LspError, Result, |
44 | }; | 41 | }; |
45 | use ra_project_model::TargetKind; | ||
46 | 42 | ||
47 | pub fn handle_analyzer_status(world: WorldSnapshot, _: ()) -> Result<String> { | 43 | pub fn handle_analyzer_status(world: WorldSnapshot, _: ()) -> Result<String> { |
48 | let _p = profile("handle_analyzer_status"); | 44 | let _p = profile("handle_analyzer_status"); |
@@ -56,48 +52,51 @@ pub fn handle_analyzer_status(world: WorldSnapshot, _: ()) -> Result<String> { | |||
56 | Ok(buf) | 52 | Ok(buf) |
57 | } | 53 | } |
58 | 54 | ||
59 | pub fn handle_syntax_tree(world: WorldSnapshot, params: req::SyntaxTreeParams) -> Result<String> { | 55 | pub fn handle_syntax_tree( |
56 | world: WorldSnapshot, | ||
57 | params: lsp_ext::SyntaxTreeParams, | ||
58 | ) -> Result<String> { | ||
60 | let _p = profile("handle_syntax_tree"); | 59 | let _p = profile("handle_syntax_tree"); |
61 | let id = params.text_document.try_conv_with(&world)?; | 60 | let id = from_proto::file_id(&world, ¶ms.text_document.uri)?; |
62 | let line_index = world.analysis().file_line_index(id)?; | 61 | let line_index = world.analysis().file_line_index(id)?; |
63 | let text_range = params.range.map(|p| p.conv_with(&line_index)); | 62 | let text_range = params.range.map(|r| from_proto::text_range(&line_index, r)); |
64 | let res = world.analysis().syntax_tree(id, text_range)?; | 63 | let res = world.analysis().syntax_tree(id, text_range)?; |
65 | Ok(res) | 64 | Ok(res) |
66 | } | 65 | } |
67 | 66 | ||
68 | pub fn handle_expand_macro( | 67 | pub fn handle_expand_macro( |
69 | world: WorldSnapshot, | 68 | world: WorldSnapshot, |
70 | params: req::ExpandMacroParams, | 69 | params: lsp_ext::ExpandMacroParams, |
71 | ) -> Result<Option<req::ExpandedMacro>> { | 70 | ) -> Result<Option<lsp_ext::ExpandedMacro>> { |
72 | let _p = profile("handle_expand_macro"); | 71 | let _p = profile("handle_expand_macro"); |
73 | let file_id = params.text_document.try_conv_with(&world)?; | 72 | let file_id = from_proto::file_id(&world, ¶ms.text_document.uri)?; |
74 | let line_index = world.analysis().file_line_index(file_id)?; | 73 | let line_index = world.analysis().file_line_index(file_id)?; |
75 | let offset = params.position.map(|p| p.conv_with(&line_index)); | 74 | let offset = params.position.map(|p| from_proto::offset(&line_index, p)); |
76 | 75 | ||
77 | match offset { | 76 | match offset { |
78 | None => Ok(None), | 77 | None => Ok(None), |
79 | Some(offset) => { | 78 | Some(offset) => { |
80 | let res = world.analysis().expand_macro(FilePosition { file_id, offset })?; | 79 | let res = world.analysis().expand_macro(FilePosition { file_id, offset })?; |
81 | Ok(res.map(|it| req::ExpandedMacro { name: it.name, expansion: it.expansion })) | 80 | Ok(res.map(|it| lsp_ext::ExpandedMacro { name: it.name, expansion: it.expansion })) |
82 | } | 81 | } |
83 | } | 82 | } |
84 | } | 83 | } |
85 | 84 | ||
86 | pub fn handle_selection_range( | 85 | pub fn handle_selection_range( |
87 | world: WorldSnapshot, | 86 | world: WorldSnapshot, |
88 | params: req::SelectionRangeParams, | 87 | params: lsp_types::SelectionRangeParams, |
89 | ) -> Result<Option<Vec<req::SelectionRange>>> { | 88 | ) -> Result<Option<Vec<lsp_types::SelectionRange>>> { |
90 | let _p = profile("handle_selection_range"); | 89 | let _p = profile("handle_selection_range"); |
91 | let file_id = params.text_document.try_conv_with(&world)?; | 90 | let file_id = from_proto::file_id(&world, ¶ms.text_document.uri)?; |
92 | let line_index = world.analysis().file_line_index(file_id)?; | 91 | let line_index = world.analysis().file_line_index(file_id)?; |
93 | let res: Result<Vec<req::SelectionRange>> = params | 92 | let res: Result<Vec<lsp_types::SelectionRange>> = params |
94 | .positions | 93 | .positions |
95 | .into_iter() | 94 | .into_iter() |
96 | .map_conv_with(&line_index) | ||
97 | .map(|position| { | 95 | .map(|position| { |
96 | let offset = from_proto::offset(&line_index, position); | ||
98 | let mut ranges = Vec::new(); | 97 | let mut ranges = Vec::new(); |
99 | { | 98 | { |
100 | let mut range = TextRange::new(position, position); | 99 | let mut range = TextRange::new(offset, offset); |
101 | loop { | 100 | loop { |
102 | ranges.push(range); | 101 | ranges.push(range); |
103 | let frange = FileRange { file_id, range }; | 102 | let frange = FileRange { file_id, range }; |
@@ -109,13 +108,13 @@ pub fn handle_selection_range( | |||
109 | } | 108 | } |
110 | } | 109 | } |
111 | } | 110 | } |
112 | let mut range = req::SelectionRange { | 111 | let mut range = lsp_types::SelectionRange { |
113 | range: ranges.last().unwrap().conv_with(&line_index), | 112 | range: to_proto::range(&line_index, *ranges.last().unwrap()), |
114 | parent: None, | 113 | parent: None, |
115 | }; | 114 | }; |
116 | for r in ranges.iter().rev().skip(1) { | 115 | for &r in ranges.iter().rev().skip(1) { |
117 | range = req::SelectionRange { | 116 | range = lsp_types::SelectionRange { |
118 | range: r.conv_with(&line_index), | 117 | range: to_proto::range(&line_index, r), |
119 | parent: Some(Box::new(range)), | 118 | parent: Some(Box::new(range)), |
120 | } | 119 | } |
121 | } | 120 | } |
@@ -128,57 +127,55 @@ pub fn handle_selection_range( | |||
128 | 127 | ||
129 | pub fn handle_find_matching_brace( | 128 | pub fn handle_find_matching_brace( |
130 | world: WorldSnapshot, | 129 | world: WorldSnapshot, |
131 | params: req::FindMatchingBraceParams, | 130 | params: lsp_ext::FindMatchingBraceParams, |
132 | ) -> Result<Vec<Position>> { | 131 | ) -> Result<Vec<Position>> { |
133 | let _p = profile("handle_find_matching_brace"); | 132 | let _p = profile("handle_find_matching_brace"); |
134 | let file_id = params.text_document.try_conv_with(&world)?; | 133 | let file_id = from_proto::file_id(&world, ¶ms.text_document.uri)?; |
135 | let line_index = world.analysis().file_line_index(file_id)?; | 134 | let line_index = world.analysis().file_line_index(file_id)?; |
136 | let res = params | 135 | let res = params |
137 | .offsets | 136 | .offsets |
138 | .into_iter() | 137 | .into_iter() |
139 | .map_conv_with(&line_index) | 138 | .map(|position| { |
140 | .map(|offset| { | 139 | let offset = from_proto::offset(&line_index, position); |
141 | if let Ok(Some(matching_brace_offset)) = | 140 | let offset = match world.analysis().matching_brace(FilePosition { file_id, offset }) { |
142 | world.analysis().matching_brace(FilePosition { file_id, offset }) | 141 | Ok(Some(matching_brace_offset)) => matching_brace_offset, |
143 | { | 142 | Err(_) | Ok(None) => offset, |
144 | matching_brace_offset | 143 | }; |
145 | } else { | 144 | to_proto::position(&line_index, offset) |
146 | offset | ||
147 | } | ||
148 | }) | 145 | }) |
149 | .map_conv_with(&line_index) | ||
150 | .collect(); | 146 | .collect(); |
151 | Ok(res) | 147 | Ok(res) |
152 | } | 148 | } |
153 | 149 | ||
154 | pub fn handle_join_lines( | 150 | pub fn handle_join_lines( |
155 | world: WorldSnapshot, | 151 | world: WorldSnapshot, |
156 | params: req::JoinLinesParams, | 152 | params: lsp_ext::JoinLinesParams, |
157 | ) -> Result<req::SourceChange> { | 153 | ) -> Result<lsp_ext::SourceChange> { |
158 | let _p = profile("handle_join_lines"); | 154 | let _p = profile("handle_join_lines"); |
159 | let frange = (¶ms.text_document, params.range).try_conv_with(&world)?; | 155 | let frange = from_proto::file_range(&world, params.text_document, params.range)?; |
160 | world.analysis().join_lines(frange)?.try_conv_with(&world) | 156 | let source_change = world.analysis().join_lines(frange)?; |
157 | to_proto::source_change(&world, source_change) | ||
161 | } | 158 | } |
162 | 159 | ||
163 | pub fn handle_on_enter( | 160 | pub fn handle_on_enter( |
164 | world: WorldSnapshot, | 161 | world: WorldSnapshot, |
165 | params: req::TextDocumentPositionParams, | 162 | params: lsp_types::TextDocumentPositionParams, |
166 | ) -> Result<Option<req::SourceChange>> { | 163 | ) -> Result<Option<lsp_ext::SourceChange>> { |
167 | let _p = profile("handle_on_enter"); | 164 | let _p = profile("handle_on_enter"); |
168 | let position = params.try_conv_with(&world)?; | 165 | let position = from_proto::file_position(&world, params)?; |
169 | match world.analysis().on_enter(position)? { | 166 | match world.analysis().on_enter(position)? { |
170 | None => Ok(None), | 167 | None => Ok(None), |
171 | Some(edit) => Ok(Some(edit.try_conv_with(&world)?)), | 168 | Some(source_change) => to_proto::source_change(&world, source_change).map(Some), |
172 | } | 169 | } |
173 | } | 170 | } |
174 | 171 | ||
175 | // Don't forget to add new trigger characters to `ServerCapabilities` in `caps.rs`. | 172 | // Don't forget to add new trigger characters to `ServerCapabilities` in `caps.rs`. |
176 | pub fn handle_on_type_formatting( | 173 | pub fn handle_on_type_formatting( |
177 | world: WorldSnapshot, | 174 | world: WorldSnapshot, |
178 | params: req::DocumentOnTypeFormattingParams, | 175 | params: lsp_types::DocumentOnTypeFormattingParams, |
179 | ) -> Result<Option<Vec<TextEdit>>> { | 176 | ) -> Result<Option<Vec<TextEdit>>> { |
180 | let _p = profile("handle_on_type_formatting"); | 177 | let _p = profile("handle_on_type_formatting"); |
181 | let mut position = params.text_document_position.try_conv_with(&world)?; | 178 | let mut position = from_proto::file_position(&world, params.text_document_position)?; |
182 | let line_index = world.analysis().file_line_index(position.file_id)?; | 179 | let line_index = world.analysis().file_line_index(position.file_id)?; |
183 | let line_endings = world.file_line_endings(position.file_id); | 180 | let line_endings = world.file_line_endings(position.file_id); |
184 | 181 | ||
@@ -208,18 +205,17 @@ pub fn handle_on_type_formatting( | |||
208 | // This should be a single-file edit | 205 | // This should be a single-file edit |
209 | let edit = edit.source_file_edits.pop().unwrap(); | 206 | let edit = edit.source_file_edits.pop().unwrap(); |
210 | 207 | ||
211 | let change: Vec<TextEdit> = edit.edit.conv_with((&line_index, line_endings)); | 208 | let change = to_proto::text_edit_vec(&line_index, line_endings, edit.edit); |
212 | Ok(Some(change)) | 209 | Ok(Some(change)) |
213 | } | 210 | } |
214 | 211 | ||
215 | pub fn handle_document_symbol( | 212 | pub fn handle_document_symbol( |
216 | world: WorldSnapshot, | 213 | world: WorldSnapshot, |
217 | params: req::DocumentSymbolParams, | 214 | params: lsp_types::DocumentSymbolParams, |
218 | ) -> Result<Option<req::DocumentSymbolResponse>> { | 215 | ) -> Result<Option<lsp_types::DocumentSymbolResponse>> { |
219 | let _p = profile("handle_document_symbol"); | 216 | let _p = profile("handle_document_symbol"); |
220 | let file_id = params.text_document.try_conv_with(&world)?; | 217 | let file_id = from_proto::file_id(&world, ¶ms.text_document.uri)?; |
221 | let line_index = world.analysis().file_line_index(file_id)?; | 218 | let line_index = world.analysis().file_line_index(file_id)?; |
222 | let url = file_id.try_conv_with(&world)?; | ||
223 | 219 | ||
224 | let mut parents: Vec<(DocumentSymbol, Option<usize>)> = Vec::new(); | 220 | let mut parents: Vec<(DocumentSymbol, Option<usize>)> = Vec::new(); |
225 | 221 | ||
@@ -227,10 +223,10 @@ pub fn handle_document_symbol( | |||
227 | let doc_symbol = DocumentSymbol { | 223 | let doc_symbol = DocumentSymbol { |
228 | name: symbol.label, | 224 | name: symbol.label, |
229 | detail: symbol.detail, | 225 | detail: symbol.detail, |
230 | kind: symbol.kind.conv(), | 226 | kind: to_proto::symbol_kind(symbol.kind), |
231 | deprecated: Some(symbol.deprecated), | 227 | deprecated: Some(symbol.deprecated), |
232 | range: symbol.node_range.conv_with(&line_index), | 228 | range: to_proto::range(&line_index, symbol.node_range), |
233 | selection_range: symbol.navigation_range.conv_with(&line_index), | 229 | selection_range: to_proto::range(&line_index, symbol.navigation_range), |
234 | children: None, | 230 | children: None, |
235 | }; | 231 | }; |
236 | parents.push((doc_symbol, symbol.parent)); | 232 | parents.push((doc_symbol, symbol.parent)); |
@@ -249,40 +245,41 @@ pub fn handle_document_symbol( | |||
249 | } | 245 | } |
250 | } | 246 | } |
251 | 247 | ||
252 | if world.config.client_caps.hierarchical_symbols { | 248 | let res = if world.config.client_caps.hierarchical_symbols { |
253 | Ok(Some(document_symbols.into())) | 249 | document_symbols.into() |
254 | } else { | 250 | } else { |
251 | let url = to_proto::url(&world, file_id)?; | ||
255 | let mut symbol_information = Vec::<SymbolInformation>::new(); | 252 | let mut symbol_information = Vec::<SymbolInformation>::new(); |
256 | for symbol in document_symbols { | 253 | for symbol in document_symbols { |
257 | flatten_document_symbol(&symbol, None, &url, &mut symbol_information); | 254 | flatten_document_symbol(&symbol, None, &url, &mut symbol_information); |
258 | } | 255 | } |
256 | symbol_information.into() | ||
257 | }; | ||
258 | return Ok(Some(res)); | ||
259 | 259 | ||
260 | Ok(Some(symbol_information.into())) | 260 | fn flatten_document_symbol( |
261 | } | 261 | symbol: &DocumentSymbol, |
262 | } | 262 | container_name: Option<String>, |
263 | 263 | url: &Url, | |
264 | fn flatten_document_symbol( | 264 | res: &mut Vec<SymbolInformation>, |
265 | symbol: &DocumentSymbol, | 265 | ) { |
266 | container_name: Option<String>, | 266 | res.push(SymbolInformation { |
267 | url: &Url, | 267 | name: symbol.name.clone(), |
268 | res: &mut Vec<SymbolInformation>, | 268 | kind: symbol.kind, |
269 | ) { | 269 | deprecated: symbol.deprecated, |
270 | res.push(SymbolInformation { | 270 | location: Location::new(url.clone(), symbol.range), |
271 | name: symbol.name.clone(), | 271 | container_name: container_name, |
272 | kind: symbol.kind, | 272 | }); |
273 | deprecated: symbol.deprecated, | ||
274 | location: Location::new(url.clone(), symbol.range), | ||
275 | container_name: container_name, | ||
276 | }); | ||
277 | 273 | ||
278 | for child in symbol.children.iter().flatten() { | 274 | for child in symbol.children.iter().flatten() { |
279 | flatten_document_symbol(child, Some(symbol.name.clone()), url, res); | 275 | flatten_document_symbol(child, Some(symbol.name.clone()), url, res); |
276 | } | ||
280 | } | 277 | } |
281 | } | 278 | } |
282 | 279 | ||
283 | pub fn handle_workspace_symbol( | 280 | pub fn handle_workspace_symbol( |
284 | world: WorldSnapshot, | 281 | world: WorldSnapshot, |
285 | params: req::WorkspaceSymbolParams, | 282 | params: lsp_types::WorkspaceSymbolParams, |
286 | ) -> Result<Option<Vec<SymbolInformation>>> { | 283 | ) -> Result<Option<Vec<SymbolInformation>>> { |
287 | let _p = profile("handle_workspace_symbol"); | 284 | let _p = profile("handle_workspace_symbol"); |
288 | let all_symbols = params.query.contains('#'); | 285 | let all_symbols = params.query.contains('#'); |
@@ -313,8 +310,8 @@ pub fn handle_workspace_symbol( | |||
313 | for nav in world.analysis().symbol_search(query)? { | 310 | for nav in world.analysis().symbol_search(query)? { |
314 | let info = SymbolInformation { | 311 | let info = SymbolInformation { |
315 | name: nav.name().to_string(), | 312 | name: nav.name().to_string(), |
316 | kind: nav.kind().conv(), | 313 | kind: to_proto::symbol_kind(nav.kind()), |
317 | location: nav.try_conv_with(world)?, | 314 | location: to_proto::location(world, nav.file_range())?, |
318 | container_name: nav.container_name().map(|v| v.to_string()), | 315 | container_name: nav.container_name().map(|v| v.to_string()), |
319 | deprecated: None, | 316 | deprecated: None, |
320 | }; | 317 | }; |
@@ -326,63 +323,80 @@ pub fn handle_workspace_symbol( | |||
326 | 323 | ||
327 | pub fn handle_goto_definition( | 324 | pub fn handle_goto_definition( |
328 | world: WorldSnapshot, | 325 | world: WorldSnapshot, |
329 | params: req::GotoDefinitionParams, | 326 | params: lsp_types::GotoDefinitionParams, |
330 | ) -> Result<Option<req::GotoDefinitionResponse>> { | 327 | ) -> Result<Option<lsp_types::GotoDefinitionResponse>> { |
331 | let _p = profile("handle_goto_definition"); | 328 | let _p = profile("handle_goto_definition"); |
332 | let position = params.text_document_position_params.try_conv_with(&world)?; | 329 | let position = from_proto::file_position(&world, params.text_document_position_params)?; |
333 | let nav_info = match world.analysis().goto_definition(position)? { | 330 | let nav_info = match world.analysis().goto_definition(position)? { |
334 | None => return Ok(None), | 331 | None => return Ok(None), |
335 | Some(it) => it, | 332 | Some(it) => it, |
336 | }; | 333 | }; |
337 | let res = (position.file_id, nav_info).try_conv_with(&world)?; | 334 | let res = to_proto::goto_definition_response( |
335 | &world, | ||
336 | FileRange { file_id: position.file_id, range: nav_info.range }, | ||
337 | nav_info.info, | ||
338 | )?; | ||
338 | Ok(Some(res)) | 339 | Ok(Some(res)) |
339 | } | 340 | } |
340 | 341 | ||
341 | pub fn handle_goto_implementation( | 342 | pub fn handle_goto_implementation( |
342 | world: WorldSnapshot, | 343 | world: WorldSnapshot, |
343 | params: req::GotoImplementationParams, | 344 | params: lsp_types::request::GotoImplementationParams, |
344 | ) -> Result<Option<req::GotoImplementationResponse>> { | 345 | ) -> Result<Option<lsp_types::request::GotoImplementationResponse>> { |
345 | let _p = profile("handle_goto_implementation"); | 346 | let _p = profile("handle_goto_implementation"); |
346 | let position = params.text_document_position_params.try_conv_with(&world)?; | 347 | let position = from_proto::file_position(&world, params.text_document_position_params)?; |
347 | let nav_info = match world.analysis().goto_implementation(position)? { | 348 | let nav_info = match world.analysis().goto_implementation(position)? { |
348 | None => return Ok(None), | 349 | None => return Ok(None), |
349 | Some(it) => it, | 350 | Some(it) => it, |
350 | }; | 351 | }; |
351 | let res = (position.file_id, nav_info).try_conv_with(&world)?; | 352 | let res = to_proto::goto_definition_response( |
353 | &world, | ||
354 | FileRange { file_id: position.file_id, range: nav_info.range }, | ||
355 | nav_info.info, | ||
356 | )?; | ||
352 | Ok(Some(res)) | 357 | Ok(Some(res)) |
353 | } | 358 | } |
354 | 359 | ||
355 | pub fn handle_goto_type_definition( | 360 | pub fn handle_goto_type_definition( |
356 | world: WorldSnapshot, | 361 | world: WorldSnapshot, |
357 | params: req::GotoTypeDefinitionParams, | 362 | params: lsp_types::request::GotoTypeDefinitionParams, |
358 | ) -> Result<Option<req::GotoTypeDefinitionResponse>> { | 363 | ) -> Result<Option<lsp_types::request::GotoTypeDefinitionResponse>> { |
359 | let _p = profile("handle_goto_type_definition"); | 364 | let _p = profile("handle_goto_type_definition"); |
360 | let position = params.text_document_position_params.try_conv_with(&world)?; | 365 | let position = from_proto::file_position(&world, params.text_document_position_params)?; |
361 | let nav_info = match world.analysis().goto_type_definition(position)? { | 366 | let nav_info = match world.analysis().goto_type_definition(position)? { |
362 | None => return Ok(None), | 367 | None => return Ok(None), |
363 | Some(it) => it, | 368 | Some(it) => it, |
364 | }; | 369 | }; |
365 | let res = (position.file_id, nav_info).try_conv_with(&world)?; | 370 | let res = to_proto::goto_definition_response( |
371 | &world, | ||
372 | FileRange { file_id: position.file_id, range: nav_info.range }, | ||
373 | nav_info.info, | ||
374 | )?; | ||
366 | Ok(Some(res)) | 375 | Ok(Some(res)) |
367 | } | 376 | } |
368 | 377 | ||
369 | pub fn handle_parent_module( | 378 | pub fn handle_parent_module( |
370 | world: WorldSnapshot, | 379 | world: WorldSnapshot, |
371 | params: req::TextDocumentPositionParams, | 380 | params: lsp_types::TextDocumentPositionParams, |
372 | ) -> Result<Vec<Location>> { | 381 | ) -> Result<Vec<Location>> { |
373 | let _p = profile("handle_parent_module"); | 382 | let _p = profile("handle_parent_module"); |
374 | let position = params.try_conv_with(&world)?; | 383 | let position = from_proto::file_position(&world, params)?; |
375 | world.analysis().parent_module(position)?.iter().try_conv_with_to_vec(&world) | 384 | world |
385 | .analysis() | ||
386 | .parent_module(position)? | ||
387 | .into_iter() | ||
388 | .map(|it| to_proto::location(&world, it.file_range())) | ||
389 | .collect::<Result<Vec<_>>>() | ||
376 | } | 390 | } |
377 | 391 | ||
378 | pub fn handle_runnables( | 392 | pub fn handle_runnables( |
379 | world: WorldSnapshot, | 393 | world: WorldSnapshot, |
380 | params: req::RunnablesParams, | 394 | params: lsp_ext::RunnablesParams, |
381 | ) -> Result<Vec<req::Runnable>> { | 395 | ) -> Result<Vec<lsp_ext::Runnable>> { |
382 | let _p = profile("handle_runnables"); | 396 | let _p = profile("handle_runnables"); |
383 | let file_id = params.text_document.try_conv_with(&world)?; | 397 | let file_id = from_proto::file_id(&world, ¶ms.text_document.uri)?; |
384 | let line_index = world.analysis().file_line_index(file_id)?; | 398 | let line_index = world.analysis().file_line_index(file_id)?; |
385 | let offset = params.position.map(|it| it.conv_with(&line_index)); | 399 | let offset = params.position.map(|it| from_proto::offset(&line_index, it)); |
386 | let mut res = Vec::new(); | 400 | let mut res = Vec::new(); |
387 | let workspace_root = world.workspace_root_for(file_id); | 401 | let workspace_root = world.workspace_root_for(file_id); |
388 | let cargo_spec = CargoTargetSpec::for_file(&world, file_id)?; | 402 | let cargo_spec = CargoTargetSpec::for_file(&world, file_id)?; |
@@ -408,7 +422,7 @@ pub fn handle_runnables( | |||
408 | match cargo_spec { | 422 | match cargo_spec { |
409 | Some(spec) => { | 423 | Some(spec) => { |
410 | for &cmd in ["check", "test"].iter() { | 424 | for &cmd in ["check", "test"].iter() { |
411 | res.push(req::Runnable { | 425 | res.push(lsp_ext::Runnable { |
412 | range: Default::default(), | 426 | range: Default::default(), |
413 | label: format!("cargo {} -p {}", cmd, spec.package), | 427 | label: format!("cargo {} -p {}", cmd, spec.package), |
414 | bin: "cargo".to_string(), | 428 | bin: "cargo".to_string(), |
@@ -420,7 +434,7 @@ pub fn handle_runnables( | |||
420 | } | 434 | } |
421 | } | 435 | } |
422 | None => { | 436 | None => { |
423 | res.push(req::Runnable { | 437 | res.push(lsp_ext::Runnable { |
424 | range: Default::default(), | 438 | range: Default::default(), |
425 | label: "cargo check --workspace".to_string(), | 439 | label: "cargo check --workspace".to_string(), |
426 | bin: "cargo".to_string(), | 440 | bin: "cargo".to_string(), |
@@ -436,10 +450,10 @@ pub fn handle_runnables( | |||
436 | 450 | ||
437 | pub fn handle_completion( | 451 | pub fn handle_completion( |
438 | world: WorldSnapshot, | 452 | world: WorldSnapshot, |
439 | params: req::CompletionParams, | 453 | params: lsp_types::CompletionParams, |
440 | ) -> Result<Option<req::CompletionResponse>> { | 454 | ) -> Result<Option<lsp_types::CompletionResponse>> { |
441 | let _p = profile("handle_completion"); | 455 | let _p = profile("handle_completion"); |
442 | let position = params.text_document_position.try_conv_with(&world)?; | 456 | let position = from_proto::file_position(&world, params.text_document_position)?; |
443 | let completion_triggered_after_single_colon = { | 457 | let completion_triggered_after_single_colon = { |
444 | let mut res = false; | 458 | let mut res = false; |
445 | if let Some(ctx) = params.context { | 459 | if let Some(ctx) = params.context { |
@@ -468,8 +482,10 @@ pub fn handle_completion( | |||
468 | }; | 482 | }; |
469 | let line_index = world.analysis().file_line_index(position.file_id)?; | 483 | let line_index = world.analysis().file_line_index(position.file_id)?; |
470 | let line_endings = world.file_line_endings(position.file_id); | 484 | let line_endings = world.file_line_endings(position.file_id); |
471 | let items: Vec<CompletionItem> = | 485 | let items: Vec<CompletionItem> = items |
472 | items.into_iter().map(|item| item.conv_with((&line_index, line_endings))).collect(); | 486 | .into_iter() |
487 | .map(|item| to_proto::completion_item(&line_index, line_endings, item)) | ||
488 | .collect(); | ||
473 | 489 | ||
474 | Ok(Some(items.into())) | 490 | Ok(Some(items.into())) |
475 | } | 491 | } |
@@ -479,52 +495,51 @@ pub fn handle_folding_range( | |||
479 | params: FoldingRangeParams, | 495 | params: FoldingRangeParams, |
480 | ) -> Result<Option<Vec<FoldingRange>>> { | 496 | ) -> Result<Option<Vec<FoldingRange>>> { |
481 | let _p = profile("handle_folding_range"); | 497 | let _p = profile("handle_folding_range"); |
482 | let file_id = params.text_document.try_conv_with(&world)?; | 498 | let file_id = from_proto::file_id(&world, ¶ms.text_document.uri)?; |
483 | let folds = world.analysis().folding_ranges(file_id)?; | 499 | let folds = world.analysis().folding_ranges(file_id)?; |
484 | let text = world.analysis().file_text(file_id)?; | 500 | let text = world.analysis().file_text(file_id)?; |
485 | let line_index = world.analysis().file_line_index(file_id)?; | 501 | let line_index = world.analysis().file_line_index(file_id)?; |
486 | let ctx = FoldConvCtx { | 502 | let line_folding_only = world.config.client_caps.line_folding_only; |
487 | text: &text, | 503 | let res = folds |
488 | line_index: &line_index, | 504 | .into_iter() |
489 | line_folding_only: world.config.client_caps.line_folding_only, | 505 | .map(|it| to_proto::folding_range(&*text, &line_index, line_folding_only, it)) |
490 | }; | 506 | .collect(); |
491 | let res = Some(folds.into_iter().map_conv_with(&ctx).collect()); | 507 | Ok(Some(res)) |
492 | Ok(res) | ||
493 | } | 508 | } |
494 | 509 | ||
495 | pub fn handle_signature_help( | 510 | pub fn handle_signature_help( |
496 | world: WorldSnapshot, | 511 | world: WorldSnapshot, |
497 | params: req::SignatureHelpParams, | 512 | params: lsp_types::SignatureHelpParams, |
498 | ) -> Result<Option<req::SignatureHelp>> { | 513 | ) -> Result<Option<lsp_types::SignatureHelp>> { |
499 | let _p = profile("handle_signature_help"); | 514 | let _p = profile("handle_signature_help"); |
500 | let position = params.text_document_position_params.try_conv_with(&world)?; | 515 | let position = from_proto::file_position(&world, params.text_document_position_params)?; |
501 | if let Some(call_info) = world.analysis().call_info(position)? { | 516 | let call_info = match world.analysis().call_info(position)? { |
502 | let concise = !world.config.call_info_full; | 517 | None => return Ok(None), |
503 | let mut active_parameter = call_info.active_parameter.map(|it| it as i64); | 518 | Some(it) => it, |
504 | if concise && call_info.signature.has_self_param { | 519 | }; |
505 | active_parameter = active_parameter.map(|it| it.saturating_sub(1)); | 520 | let concise = !world.config.call_info_full; |
506 | } | 521 | let mut active_parameter = call_info.active_parameter.map(|it| it as i64); |
507 | let sig_info = call_info.signature.conv_with(concise); | 522 | if concise && call_info.signature.has_self_param { |
508 | 523 | active_parameter = active_parameter.map(|it| it.saturating_sub(1)); | |
509 | Ok(Some(req::SignatureHelp { | ||
510 | signatures: vec![sig_info], | ||
511 | active_signature: Some(0), | ||
512 | active_parameter, | ||
513 | })) | ||
514 | } else { | ||
515 | Ok(None) | ||
516 | } | 524 | } |
525 | let sig_info = to_proto::signature_information(call_info.signature, concise); | ||
526 | |||
527 | Ok(Some(lsp_types::SignatureHelp { | ||
528 | signatures: vec![sig_info], | ||
529 | active_signature: Some(0), | ||
530 | active_parameter, | ||
531 | })) | ||
517 | } | 532 | } |
518 | 533 | ||
519 | pub fn handle_hover(world: WorldSnapshot, params: req::HoverParams) -> Result<Option<Hover>> { | 534 | pub fn handle_hover(world: WorldSnapshot, params: lsp_types::HoverParams) -> Result<Option<Hover>> { |
520 | let _p = profile("handle_hover"); | 535 | let _p = profile("handle_hover"); |
521 | let position = params.text_document_position_params.try_conv_with(&world)?; | 536 | let position = from_proto::file_position(&world, params.text_document_position_params)?; |
522 | let info = match world.analysis().hover(position)? { | 537 | let info = match world.analysis().hover(position)? { |
523 | None => return Ok(None), | 538 | None => return Ok(None), |
524 | Some(info) => info, | 539 | Some(info) => info, |
525 | }; | 540 | }; |
526 | let line_index = world.analysis.file_line_index(position.file_id)?; | 541 | let line_index = world.analysis.file_line_index(position.file_id)?; |
527 | let range = info.range.conv_with(&line_index); | 542 | let range = to_proto::range(&line_index, info.range); |
528 | let res = Hover { | 543 | let res = Hover { |
529 | contents: HoverContents::Markup(MarkupContent { | 544 | contents: HoverContents::Markup(MarkupContent { |
530 | kind: MarkupKind::Markdown, | 545 | kind: MarkupKind::Markdown, |
@@ -537,10 +552,10 @@ pub fn handle_hover(world: WorldSnapshot, params: req::HoverParams) -> Result<Op | |||
537 | 552 | ||
538 | pub fn handle_prepare_rename( | 553 | pub fn handle_prepare_rename( |
539 | world: WorldSnapshot, | 554 | world: WorldSnapshot, |
540 | params: req::TextDocumentPositionParams, | 555 | params: lsp_types::TextDocumentPositionParams, |
541 | ) -> Result<Option<PrepareRenameResponse>> { | 556 | ) -> Result<Option<PrepareRenameResponse>> { |
542 | let _p = profile("handle_prepare_rename"); | 557 | let _p = profile("handle_prepare_rename"); |
543 | let position = params.try_conv_with(&world)?; | 558 | let position = from_proto::file_position(&world, params)?; |
544 | 559 | ||
545 | let optional_change = world.analysis().rename(position, "dummy")?; | 560 | let optional_change = world.analysis().rename(position, "dummy")?; |
546 | let range = match optional_change { | 561 | let range = match optional_change { |
@@ -548,15 +563,14 @@ pub fn handle_prepare_rename( | |||
548 | Some(it) => it.range, | 563 | Some(it) => it.range, |
549 | }; | 564 | }; |
550 | 565 | ||
551 | let file_id = params.text_document.try_conv_with(&world)?; | 566 | let line_index = world.analysis().file_line_index(position.file_id)?; |
552 | let line_index = world.analysis().file_line_index(file_id)?; | 567 | let range = to_proto::range(&line_index, range); |
553 | let range = range.conv_with(&line_index); | ||
554 | Ok(Some(PrepareRenameResponse::Range(range))) | 568 | Ok(Some(PrepareRenameResponse::Range(range))) |
555 | } | 569 | } |
556 | 570 | ||
557 | pub fn handle_rename(world: WorldSnapshot, params: RenameParams) -> Result<Option<WorkspaceEdit>> { | 571 | pub fn handle_rename(world: WorldSnapshot, params: RenameParams) -> Result<Option<WorkspaceEdit>> { |
558 | let _p = profile("handle_rename"); | 572 | let _p = profile("handle_rename"); |
559 | let position = params.text_document_position.try_conv_with(&world)?; | 573 | let position = from_proto::file_position(&world, params.text_document_position)?; |
560 | 574 | ||
561 | if params.new_name.is_empty() { | 575 | if params.new_name.is_empty() { |
562 | return Err(LspError::new( | 576 | return Err(LspError::new( |
@@ -567,22 +581,21 @@ pub fn handle_rename(world: WorldSnapshot, params: RenameParams) -> Result<Optio | |||
567 | } | 581 | } |
568 | 582 | ||
569 | let optional_change = world.analysis().rename(position, &*params.new_name)?; | 583 | let optional_change = world.analysis().rename(position, &*params.new_name)?; |
570 | let change = match optional_change { | 584 | let source_change = match optional_change { |
571 | None => return Ok(None), | 585 | None => return Ok(None), |
572 | Some(it) => it.info, | 586 | Some(it) => it.info, |
573 | }; | 587 | }; |
574 | 588 | ||
575 | let source_change_req = change.try_conv_with(&world)?; | 589 | let source_change = to_proto::source_change(&world, source_change)?; |
576 | 590 | Ok(Some(source_change.workspace_edit)) | |
577 | Ok(Some(source_change_req.workspace_edit)) | ||
578 | } | 591 | } |
579 | 592 | ||
580 | pub fn handle_references( | 593 | pub fn handle_references( |
581 | world: WorldSnapshot, | 594 | world: WorldSnapshot, |
582 | params: req::ReferenceParams, | 595 | params: lsp_types::ReferenceParams, |
583 | ) -> Result<Option<Vec<Location>>> { | 596 | ) -> Result<Option<Vec<Location>>> { |
584 | let _p = profile("handle_references"); | 597 | let _p = profile("handle_references"); |
585 | let position = params.text_document_position.try_conv_with(&world)?; | 598 | let position = from_proto::file_position(&world, params.text_document_position)?; |
586 | 599 | ||
587 | let refs = match world.analysis().find_all_refs(position, None)? { | 600 | let refs = match world.analysis().find_all_refs(position, None)? { |
588 | None => return Ok(None), | 601 | None => return Ok(None), |
@@ -591,33 +604,13 @@ pub fn handle_references( | |||
591 | 604 | ||
592 | let locations = if params.context.include_declaration { | 605 | let locations = if params.context.include_declaration { |
593 | refs.into_iter() | 606 | refs.into_iter() |
594 | .filter_map(|reference| { | 607 | .filter_map(|reference| to_proto::location(&world, reference.file_range).ok()) |
595 | let line_index = | ||
596 | world.analysis().file_line_index(reference.file_range.file_id).ok()?; | ||
597 | to_location( | ||
598 | reference.file_range.file_id, | ||
599 | reference.file_range.range, | ||
600 | &world, | ||
601 | &line_index, | ||
602 | ) | ||
603 | .ok() | ||
604 | }) | ||
605 | .collect() | 608 | .collect() |
606 | } else { | 609 | } else { |
607 | // Only iterate over the references if include_declaration was false | 610 | // Only iterate over the references if include_declaration was false |
608 | refs.references() | 611 | refs.references() |
609 | .iter() | 612 | .iter() |
610 | .filter_map(|reference| { | 613 | .filter_map(|reference| to_proto::location(&world, reference.file_range).ok()) |
611 | let line_index = | ||
612 | world.analysis().file_line_index(reference.file_range.file_id).ok()?; | ||
613 | to_location( | ||
614 | reference.file_range.file_id, | ||
615 | reference.file_range.range, | ||
616 | &world, | ||
617 | &line_index, | ||
618 | ) | ||
619 | .ok() | ||
620 | }) | ||
621 | .collect() | 614 | .collect() |
622 | }; | 615 | }; |
623 | 616 | ||
@@ -629,12 +622,12 @@ pub fn handle_formatting( | |||
629 | params: DocumentFormattingParams, | 622 | params: DocumentFormattingParams, |
630 | ) -> Result<Option<Vec<TextEdit>>> { | 623 | ) -> Result<Option<Vec<TextEdit>>> { |
631 | let _p = profile("handle_formatting"); | 624 | let _p = profile("handle_formatting"); |
632 | let file_id = params.text_document.try_conv_with(&world)?; | 625 | let file_id = from_proto::file_id(&world, ¶ms.text_document.uri)?; |
633 | let file = world.analysis().file_text(file_id)?; | 626 | let file = world.analysis().file_text(file_id)?; |
634 | let crate_ids = world.analysis().crate_for(file_id)?; | 627 | let crate_ids = world.analysis().crate_for(file_id)?; |
635 | 628 | ||
636 | let file_line_index = world.analysis().file_line_index(file_id)?; | 629 | let file_line_index = world.analysis().file_line_index(file_id)?; |
637 | let end_position = TextSize::of(file.as_str()).conv_with(&file_line_index); | 630 | let end_position = to_proto::position(&file_line_index, TextSize::of(file.as_str())); |
638 | 631 | ||
639 | let mut rustfmt = match &world.config.rustfmt { | 632 | let mut rustfmt = match &world.config.rustfmt { |
640 | RustfmtConfig::Rustfmt { extra_args } => { | 633 | RustfmtConfig::Rustfmt { extra_args } => { |
@@ -700,33 +693,14 @@ pub fn handle_formatting( | |||
700 | }])) | 693 | }])) |
701 | } | 694 | } |
702 | 695 | ||
703 | fn create_single_code_action(assist: Assist, world: &WorldSnapshot) -> Result<CodeAction> { | ||
704 | let arg = to_value(assist.source_change.try_conv_with(world)?)?; | ||
705 | let title = assist.label; | ||
706 | let command = Command { | ||
707 | title: title.clone(), | ||
708 | command: "rust-analyzer.applySourceChange".to_string(), | ||
709 | arguments: Some(vec![arg]), | ||
710 | }; | ||
711 | |||
712 | Ok(CodeAction { | ||
713 | title, | ||
714 | kind: Some(String::new()), | ||
715 | diagnostics: None, | ||
716 | edit: None, | ||
717 | command: Some(command), | ||
718 | is_preferred: None, | ||
719 | }) | ||
720 | } | ||
721 | |||
722 | pub fn handle_code_action( | 696 | pub fn handle_code_action( |
723 | world: WorldSnapshot, | 697 | world: WorldSnapshot, |
724 | params: req::CodeActionParams, | 698 | params: lsp_types::CodeActionParams, |
725 | ) -> Result<Option<CodeActionResponse>> { | 699 | ) -> Result<Option<CodeActionResponse>> { |
726 | let _p = profile("handle_code_action"); | 700 | let _p = profile("handle_code_action"); |
727 | let file_id = params.text_document.try_conv_with(&world)?; | 701 | let file_id = from_proto::file_id(&world, ¶ms.text_document.uri)?; |
728 | let line_index = world.analysis().file_line_index(file_id)?; | 702 | let line_index = world.analysis().file_line_index(file_id)?; |
729 | let range = params.range.conv_with(&line_index); | 703 | let range = from_proto::text_range(&line_index, params.range); |
730 | 704 | ||
731 | let diagnostics = world.analysis().diagnostics(file_id)?; | 705 | let diagnostics = world.analysis().diagnostics(file_id)?; |
732 | let mut res = CodeActionResponse::default(); | 706 | let mut res = CodeActionResponse::default(); |
@@ -739,7 +713,7 @@ pub fn handle_code_action( | |||
739 | 713 | ||
740 | for source_edit in fixes_from_diagnostics { | 714 | for source_edit in fixes_from_diagnostics { |
741 | let title = source_edit.label.clone(); | 715 | let title = source_edit.label.clone(); |
742 | let edit = source_edit.try_conv_with(&world)?; | 716 | let edit = to_proto::source_change(&world, source_edit)?; |
743 | 717 | ||
744 | let command = Command { | 718 | let command = Command { |
745 | title, | 719 | title, |
@@ -758,7 +732,7 @@ pub fn handle_code_action( | |||
758 | } | 732 | } |
759 | 733 | ||
760 | for fix in world.check_fixes.get(&file_id).into_iter().flatten() { | 734 | for fix in world.check_fixes.get(&file_id).into_iter().flatten() { |
761 | let fix_range = fix.range.conv_with(&line_index); | 735 | let fix_range = from_proto::text_range(&line_index, fix.range); |
762 | if fix_range.intersect(range).is_none() { | 736 | if fix_range.intersect(range).is_none() { |
763 | continue; | 737 | continue; |
764 | } | 738 | } |
@@ -779,21 +753,21 @@ pub fn handle_code_action( | |||
779 | .1 | 753 | .1 |
780 | .push(assist), | 754 | .push(assist), |
781 | None => { | 755 | None => { |
782 | res.push(create_single_code_action(assist, &world)?.into()); | 756 | res.push(to_proto::code_action(&world, assist)?.into()); |
783 | } | 757 | } |
784 | } | 758 | } |
785 | } | 759 | } |
786 | 760 | ||
787 | for (group_label, (idx, assists)) in grouped_assists { | 761 | for (group_label, (idx, assists)) in grouped_assists { |
788 | if assists.len() == 1 { | 762 | if assists.len() == 1 { |
789 | res[idx] = | 763 | res[idx] = to_proto::code_action(&world, assists.into_iter().next().unwrap())?.into(); |
790 | create_single_code_action(assists.into_iter().next().unwrap(), &world)?.into(); | ||
791 | } else { | 764 | } else { |
792 | let title = group_label; | 765 | let title = group_label; |
793 | 766 | ||
794 | let mut arguments = Vec::with_capacity(assists.len()); | 767 | let mut arguments = Vec::with_capacity(assists.len()); |
795 | for assist in assists { | 768 | for assist in assists { |
796 | arguments.push(to_value(assist.source_change.try_conv_with(&world)?)?); | 769 | let source_change = to_proto::source_change(&world, assist.source_change)?; |
770 | arguments.push(to_value(source_change)?); | ||
797 | } | 771 | } |
798 | 772 | ||
799 | let command = Some(Command { | 773 | let command = Some(Command { |
@@ -835,10 +809,10 @@ pub fn handle_code_action( | |||
835 | 809 | ||
836 | pub fn handle_code_lens( | 810 | pub fn handle_code_lens( |
837 | world: WorldSnapshot, | 811 | world: WorldSnapshot, |
838 | params: req::CodeLensParams, | 812 | params: lsp_types::CodeLensParams, |
839 | ) -> Result<Option<Vec<CodeLens>>> { | 813 | ) -> Result<Option<Vec<CodeLens>>> { |
840 | let _p = profile("handle_code_lens"); | 814 | let _p = profile("handle_code_lens"); |
841 | let file_id = params.text_document.try_conv_with(&world)?; | 815 | let file_id = from_proto::file_id(&world, ¶ms.text_document.uri)?; |
842 | let line_index = world.analysis().file_line_index(file_id)?; | 816 | let line_index = world.analysis().file_line_index(file_id)?; |
843 | 817 | ||
844 | let mut lenses: Vec<CodeLens> = Default::default(); | 818 | let mut lenses: Vec<CodeLens> = Default::default(); |
@@ -902,10 +876,10 @@ pub fn handle_code_lens( | |||
902 | _ => false, | 876 | _ => false, |
903 | }) | 877 | }) |
904 | .map(|it| { | 878 | .map(|it| { |
905 | let range = it.node_range.conv_with(&line_index); | 879 | let range = to_proto::range(&line_index, it.node_range); |
906 | let pos = range.start; | 880 | let pos = range.start; |
907 | let lens_params = req::GotoImplementationParams { | 881 | let lens_params = lsp_types::request::GotoImplementationParams { |
908 | text_document_position_params: req::TextDocumentPositionParams::new( | 882 | text_document_position_params: lsp_types::TextDocumentPositionParams::new( |
909 | params.text_document.clone(), | 883 | params.text_document.clone(), |
910 | pos, | 884 | pos, |
911 | ), | 885 | ), |
@@ -926,7 +900,7 @@ pub fn handle_code_lens( | |||
926 | #[derive(Debug, Serialize, Deserialize)] | 900 | #[derive(Debug, Serialize, Deserialize)] |
927 | #[serde(rename_all = "camelCase")] | 901 | #[serde(rename_all = "camelCase")] |
928 | enum CodeLensResolveData { | 902 | enum CodeLensResolveData { |
929 | Impls(req::GotoImplementationParams), | 903 | Impls(lsp_types::request::GotoImplementationParams), |
930 | } | 904 | } |
931 | 905 | ||
932 | pub fn handle_code_lens_resolve(world: WorldSnapshot, code_lens: CodeLens) -> Result<CodeLens> { | 906 | pub fn handle_code_lens_resolve(world: WorldSnapshot, code_lens: CodeLens) -> Result<CodeLens> { |
@@ -937,9 +911,9 @@ pub fn handle_code_lens_resolve(world: WorldSnapshot, code_lens: CodeLens) -> Re | |||
937 | Some(CodeLensResolveData::Impls(lens_params)) => { | 911 | Some(CodeLensResolveData::Impls(lens_params)) => { |
938 | let locations: Vec<Location> = | 912 | let locations: Vec<Location> = |
939 | match handle_goto_implementation(world, lens_params.clone())? { | 913 | match handle_goto_implementation(world, lens_params.clone())? { |
940 | Some(req::GotoDefinitionResponse::Scalar(loc)) => vec![loc], | 914 | Some(lsp_types::GotoDefinitionResponse::Scalar(loc)) => vec![loc], |
941 | Some(req::GotoDefinitionResponse::Array(locs)) => locs, | 915 | Some(lsp_types::GotoDefinitionResponse::Array(locs)) => locs, |
942 | Some(req::GotoDefinitionResponse::Link(links)) => links | 916 | Some(lsp_types::GotoDefinitionResponse::Link(links)) => links |
943 | .into_iter() | 917 | .into_iter() |
944 | .map(|link| Location::new(link.target_uri, link.target_selection_range)) | 918 | .map(|link| Location::new(link.target_uri, link.target_selection_range)) |
945 | .collect(), | 919 | .collect(), |
@@ -976,37 +950,39 @@ pub fn handle_code_lens_resolve(world: WorldSnapshot, code_lens: CodeLens) -> Re | |||
976 | 950 | ||
977 | pub fn handle_document_highlight( | 951 | pub fn handle_document_highlight( |
978 | world: WorldSnapshot, | 952 | world: WorldSnapshot, |
979 | params: req::DocumentHighlightParams, | 953 | params: lsp_types::DocumentHighlightParams, |
980 | ) -> Result<Option<Vec<DocumentHighlight>>> { | 954 | ) -> Result<Option<Vec<DocumentHighlight>>> { |
981 | let _p = profile("handle_document_highlight"); | 955 | let _p = profile("handle_document_highlight"); |
982 | let file_id = params.text_document_position_params.text_document.try_conv_with(&world)?; | 956 | let position = from_proto::file_position(&world, params.text_document_position_params)?; |
983 | let line_index = world.analysis().file_line_index(file_id)?; | 957 | let line_index = world.analysis().file_line_index(position.file_id)?; |
984 | 958 | ||
985 | let refs = match world.analysis().find_all_refs( | 959 | let refs = match world |
986 | params.text_document_position_params.try_conv_with(&world)?, | 960 | .analysis() |
987 | Some(SearchScope::single_file(file_id)), | 961 | .find_all_refs(position, Some(SearchScope::single_file(position.file_id)))? |
988 | )? { | 962 | { |
989 | None => return Ok(None), | 963 | None => return Ok(None), |
990 | Some(refs) => refs, | 964 | Some(refs) => refs, |
991 | }; | 965 | }; |
992 | 966 | ||
993 | Ok(Some( | 967 | let res = refs |
994 | refs.into_iter() | 968 | .into_iter() |
995 | .filter(|reference| reference.file_range.file_id == file_id) | 969 | .filter(|reference| reference.file_range.file_id == position.file_id) |
996 | .map(|reference| DocumentHighlight { | 970 | .map(|reference| DocumentHighlight { |
997 | range: reference.file_range.range.conv_with(&line_index), | 971 | range: to_proto::range(&line_index, reference.file_range.range), |
998 | kind: reference.access.map(|it| it.conv()), | 972 | kind: reference.access.map(to_proto::document_highlight_kind), |
999 | }) | 973 | }) |
1000 | .collect(), | 974 | .collect(); |
1001 | )) | 975 | Ok(Some(res)) |
1002 | } | 976 | } |
1003 | 977 | ||
1004 | pub fn handle_ssr(world: WorldSnapshot, params: req::SsrParams) -> Result<req::SourceChange> { | 978 | pub fn handle_ssr( |
979 | world: WorldSnapshot, | ||
980 | params: lsp_ext::SsrParams, | ||
981 | ) -> Result<lsp_ext::SourceChange> { | ||
1005 | let _p = profile("handle_ssr"); | 982 | let _p = profile("handle_ssr"); |
1006 | world | 983 | let source_change = |
1007 | .analysis() | 984 | world.analysis().structural_search_replace(¶ms.query, params.parse_only)??; |
1008 | .structural_search_replace(¶ms.query, params.parse_only)?? | 985 | to_proto::source_change(&world, source_change) |
1009 | .try_conv_with(&world) | ||
1010 | } | 986 | } |
1011 | 987 | ||
1012 | pub fn publish_diagnostics(world: &WorldSnapshot, file_id: FileId) -> Result<DiagnosticTask> { | 988 | pub fn publish_diagnostics(world: &WorldSnapshot, file_id: FileId) -> Result<DiagnosticTask> { |
@@ -1017,8 +993,8 @@ pub fn publish_diagnostics(world: &WorldSnapshot, file_id: FileId) -> Result<Dia | |||
1017 | .diagnostics(file_id)? | 993 | .diagnostics(file_id)? |
1018 | .into_iter() | 994 | .into_iter() |
1019 | .map(|d| Diagnostic { | 995 | .map(|d| Diagnostic { |
1020 | range: d.range.conv_with(&line_index), | 996 | range: to_proto::range(&line_index, d.range), |
1021 | severity: Some(d.severity.conv()), | 997 | severity: Some(to_proto::diagnostic_severity(d.severity)), |
1022 | code: None, | 998 | code: None, |
1023 | source: Some("rust-analyzer".to_string()), | 999 | source: Some("rust-analyzer".to_string()), |
1024 | message: d.message, | 1000 | message: d.message, |
@@ -1033,7 +1009,7 @@ fn to_lsp_runnable( | |||
1033 | world: &WorldSnapshot, | 1009 | world: &WorldSnapshot, |
1034 | file_id: FileId, | 1010 | file_id: FileId, |
1035 | runnable: Runnable, | 1011 | runnable: Runnable, |
1036 | ) -> Result<req::Runnable> { | 1012 | ) -> Result<lsp_ext::Runnable> { |
1037 | let spec = CargoTargetSpec::for_file(world, file_id)?; | 1013 | let spec = CargoTargetSpec::for_file(world, file_id)?; |
1038 | let (args, extra_args) = CargoTargetSpec::runnable_args(spec, &runnable.kind)?; | 1014 | let (args, extra_args) = CargoTargetSpec::runnable_args(spec, &runnable.kind)?; |
1039 | let line_index = world.analysis().file_line_index(file_id)?; | 1015 | let line_index = world.analysis().file_line_index(file_id)?; |
@@ -1044,8 +1020,8 @@ fn to_lsp_runnable( | |||
1044 | RunnableKind::DocTest { test_id, .. } => format!("doctest {}", test_id), | 1020 | RunnableKind::DocTest { test_id, .. } => format!("doctest {}", test_id), |
1045 | RunnableKind::Bin => "run binary".to_string(), | 1021 | RunnableKind::Bin => "run binary".to_string(), |
1046 | }; | 1022 | }; |
1047 | Ok(req::Runnable { | 1023 | Ok(lsp_ext::Runnable { |
1048 | range: runnable.range.conv_with(&line_index), | 1024 | range: to_proto::range(&line_index, runnable.range), |
1049 | label, | 1025 | label, |
1050 | bin: "cargo".to_string(), | 1026 | bin: "cargo".to_string(), |
1051 | args, | 1027 | args, |
@@ -1064,13 +1040,13 @@ pub fn handle_inlay_hints( | |||
1064 | params: InlayHintsParams, | 1040 | params: InlayHintsParams, |
1065 | ) -> Result<Vec<InlayHint>> { | 1041 | ) -> Result<Vec<InlayHint>> { |
1066 | let _p = profile("handle_inlay_hints"); | 1042 | let _p = profile("handle_inlay_hints"); |
1067 | let file_id = params.text_document.try_conv_with(&world)?; | 1043 | let file_id = from_proto::file_id(&world, ¶ms.text_document.uri)?; |
1068 | let analysis = world.analysis(); | 1044 | let analysis = world.analysis(); |
1069 | let line_index = analysis.file_line_index(file_id)?; | 1045 | let line_index = analysis.file_line_index(file_id)?; |
1070 | Ok(analysis | 1046 | Ok(analysis |
1071 | .inlay_hints(file_id, &world.config.inlay_hints)? | 1047 | .inlay_hints(file_id, &world.config.inlay_hints)? |
1072 | .into_iter() | 1048 | .into_iter() |
1073 | .map_conv_with(&line_index) | 1049 | .map(|it| to_proto::inlay_int(&line_index, it)) |
1074 | .collect()) | 1050 | .collect()) |
1075 | } | 1051 | } |
1076 | 1052 | ||
@@ -1079,21 +1055,19 @@ pub fn handle_call_hierarchy_prepare( | |||
1079 | params: CallHierarchyPrepareParams, | 1055 | params: CallHierarchyPrepareParams, |
1080 | ) -> Result<Option<Vec<CallHierarchyItem>>> { | 1056 | ) -> Result<Option<Vec<CallHierarchyItem>>> { |
1081 | let _p = profile("handle_call_hierarchy_prepare"); | 1057 | let _p = profile("handle_call_hierarchy_prepare"); |
1082 | let position = params.text_document_position_params.try_conv_with(&world)?; | 1058 | let position = from_proto::file_position(&world, params.text_document_position_params)?; |
1083 | let file_id = position.file_id; | ||
1084 | 1059 | ||
1085 | let nav_info = match world.analysis().call_hierarchy(position)? { | 1060 | let nav_info = match world.analysis().call_hierarchy(position)? { |
1086 | None => return Ok(None), | 1061 | None => return Ok(None), |
1087 | Some(it) => it, | 1062 | Some(it) => it, |
1088 | }; | 1063 | }; |
1089 | 1064 | ||
1090 | let line_index = world.analysis().file_line_index(file_id)?; | 1065 | let RangeInfo { range: _, info: navs } = nav_info; |
1091 | let RangeInfo { range, info: navs } = nav_info; | ||
1092 | let res = navs | 1066 | let res = navs |
1093 | .into_iter() | 1067 | .into_iter() |
1094 | .filter(|it| it.kind() == SyntaxKind::FN_DEF) | 1068 | .filter(|it| it.kind() == SyntaxKind::FN_DEF) |
1095 | .filter_map(|it| to_call_hierarchy_item(file_id, range, &world, &line_index, it).ok()) | 1069 | .map(|it| to_proto::call_hierarchy_item(&world, it)) |
1096 | .collect(); | 1070 | .collect::<Result<Vec<_>>>()?; |
1097 | 1071 | ||
1098 | Ok(Some(res)) | 1072 | Ok(Some(res)) |
1099 | } | 1073 | } |
@@ -1106,7 +1080,7 @@ pub fn handle_call_hierarchy_incoming( | |||
1106 | let item = params.item; | 1080 | let item = params.item; |
1107 | 1081 | ||
1108 | let doc = TextDocumentIdentifier::new(item.uri); | 1082 | let doc = TextDocumentIdentifier::new(item.uri); |
1109 | let frange: FileRange = (&doc, item.range).try_conv_with(&world)?; | 1083 | let frange = from_proto::file_range(&world, doc, item.range)?; |
1110 | let fpos = FilePosition { file_id: frange.file_id, offset: frange.range.start() }; | 1084 | let fpos = FilePosition { file_id: frange.file_id, offset: frange.range.start() }; |
1111 | 1085 | ||
1112 | let call_items = match world.analysis().incoming_calls(fpos)? { | 1086 | let call_items = match world.analysis().incoming_calls(fpos)? { |
@@ -1119,11 +1093,14 @@ pub fn handle_call_hierarchy_incoming( | |||
1119 | for call_item in call_items.into_iter() { | 1093 | for call_item in call_items.into_iter() { |
1120 | let file_id = call_item.target.file_id(); | 1094 | let file_id = call_item.target.file_id(); |
1121 | let line_index = world.analysis().file_line_index(file_id)?; | 1095 | let line_index = world.analysis().file_line_index(file_id)?; |
1122 | let range = call_item.target.range(); | 1096 | let item = to_proto::call_hierarchy_item(&world, call_item.target)?; |
1123 | let item = to_call_hierarchy_item(file_id, range, &world, &line_index, call_item.target)?; | ||
1124 | res.push(CallHierarchyIncomingCall { | 1097 | res.push(CallHierarchyIncomingCall { |
1125 | from: item, | 1098 | from: item, |
1126 | from_ranges: call_item.ranges.iter().map(|it| it.conv_with(&line_index)).collect(), | 1099 | from_ranges: call_item |
1100 | .ranges | ||
1101 | .into_iter() | ||
1102 | .map(|it| to_proto::range(&line_index, it)) | ||
1103 | .collect(), | ||
1127 | }); | 1104 | }); |
1128 | } | 1105 | } |
1129 | 1106 | ||
@@ -1138,7 +1115,7 @@ pub fn handle_call_hierarchy_outgoing( | |||
1138 | let item = params.item; | 1115 | let item = params.item; |
1139 | 1116 | ||
1140 | let doc = TextDocumentIdentifier::new(item.uri); | 1117 | let doc = TextDocumentIdentifier::new(item.uri); |
1141 | let frange: FileRange = (&doc, item.range).try_conv_with(&world)?; | 1118 | let frange = from_proto::file_range(&world, doc, item.range)?; |
1142 | let fpos = FilePosition { file_id: frange.file_id, offset: frange.range.start() }; | 1119 | let fpos = FilePosition { file_id: frange.file_id, offset: frange.range.start() }; |
1143 | 1120 | ||
1144 | let call_items = match world.analysis().outgoing_calls(fpos)? { | 1121 | let call_items = match world.analysis().outgoing_calls(fpos)? { |
@@ -1151,11 +1128,14 @@ pub fn handle_call_hierarchy_outgoing( | |||
1151 | for call_item in call_items.into_iter() { | 1128 | for call_item in call_items.into_iter() { |
1152 | let file_id = call_item.target.file_id(); | 1129 | let file_id = call_item.target.file_id(); |
1153 | let line_index = world.analysis().file_line_index(file_id)?; | 1130 | let line_index = world.analysis().file_line_index(file_id)?; |
1154 | let range = call_item.target.range(); | 1131 | let item = to_proto::call_hierarchy_item(&world, call_item.target)?; |
1155 | let item = to_call_hierarchy_item(file_id, range, &world, &line_index, call_item.target)?; | ||
1156 | res.push(CallHierarchyOutgoingCall { | 1132 | res.push(CallHierarchyOutgoingCall { |
1157 | to: item, | 1133 | to: item, |
1158 | from_ranges: call_item.ranges.iter().map(|it| it.conv_with(&line_index)).collect(), | 1134 | from_ranges: call_item |
1135 | .ranges | ||
1136 | .into_iter() | ||
1137 | .map(|it| to_proto::range(&line_index, it)) | ||
1138 | .collect(), | ||
1159 | }); | 1139 | }); |
1160 | } | 1140 | } |
1161 | 1141 | ||
@@ -1168,26 +1148,13 @@ pub fn handle_semantic_tokens( | |||
1168 | ) -> Result<Option<SemanticTokensResult>> { | 1148 | ) -> Result<Option<SemanticTokensResult>> { |
1169 | let _p = profile("handle_semantic_tokens"); | 1149 | let _p = profile("handle_semantic_tokens"); |
1170 | 1150 | ||
1171 | let file_id = params.text_document.try_conv_with(&world)?; | 1151 | let file_id = from_proto::file_id(&world, ¶ms.text_document.uri)?; |
1172 | let text = world.analysis().file_text(file_id)?; | 1152 | let text = world.analysis().file_text(file_id)?; |
1173 | let line_index = world.analysis().file_line_index(file_id)?; | 1153 | let line_index = world.analysis().file_line_index(file_id)?; |
1174 | 1154 | ||
1175 | let mut builder = SemanticTokensBuilder::default(); | 1155 | let highlights = world.analysis().highlight(file_id)?; |
1176 | 1156 | let semantic_tokens = to_proto::semantic_tokens(&text, &line_index, highlights); | |
1177 | for highlight_range in world.analysis().highlight(file_id)?.into_iter() { | 1157 | Ok(Some(semantic_tokens.into())) |
1178 | let (token_index, modifier_bitset) = highlight_range.highlight.conv(); | ||
1179 | for mut range in line_index.lines(highlight_range.range) { | ||
1180 | if text[range].ends_with('\n') { | ||
1181 | range = TextRange::new(range.start(), range.end() - TextSize::of('\n')); | ||
1182 | } | ||
1183 | let range = range.conv_with(&line_index); | ||
1184 | builder.push(range, token_index, modifier_bitset); | ||
1185 | } | ||
1186 | } | ||
1187 | |||
1188 | let tokens = builder.build(); | ||
1189 | |||
1190 | Ok(Some(tokens.into())) | ||
1191 | } | 1158 | } |
1192 | 1159 | ||
1193 | pub fn handle_semantic_tokens_range( | 1160 | pub fn handle_semantic_tokens_range( |
@@ -1196,17 +1163,11 @@ pub fn handle_semantic_tokens_range( | |||
1196 | ) -> Result<Option<SemanticTokensRangeResult>> { | 1163 | ) -> Result<Option<SemanticTokensRangeResult>> { |
1197 | let _p = profile("handle_semantic_tokens_range"); | 1164 | let _p = profile("handle_semantic_tokens_range"); |
1198 | 1165 | ||
1199 | let frange = (¶ms.text_document, params.range).try_conv_with(&world)?; | 1166 | let frange = from_proto::file_range(&world, params.text_document, params.range)?; |
1167 | let text = world.analysis().file_text(frange.file_id)?; | ||
1200 | let line_index = world.analysis().file_line_index(frange.file_id)?; | 1168 | let line_index = world.analysis().file_line_index(frange.file_id)?; |
1201 | 1169 | ||
1202 | let mut builder = SemanticTokensBuilder::default(); | 1170 | let highlights = world.analysis().highlight_range(frange)?; |
1203 | 1171 | let semantic_tokens = to_proto::semantic_tokens(&text, &line_index, highlights); | |
1204 | for highlight_range in world.analysis().highlight_range(frange)?.into_iter() { | 1172 | Ok(Some(semantic_tokens.into())) |
1205 | let (token_type, token_modifiers) = highlight_range.highlight.conv(); | ||
1206 | builder.push(highlight_range.range.conv_with(&line_index), token_type, token_modifiers); | ||
1207 | } | ||
1208 | |||
1209 | let tokens = builder.build(); | ||
1210 | |||
1211 | Ok(Some(tokens.into())) | ||
1212 | } | 1173 | } |
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs new file mode 100644 index 000000000..4500d4982 --- /dev/null +++ b/crates/rust-analyzer/src/to_proto.rs | |||
@@ -0,0 +1,592 @@ | |||
1 | //! Conversion of rust-analyzer specific types to lsp_types equivalents. | ||
2 | use ra_db::{FileId, FileRange}; | ||
3 | use ra_ide::{ | ||
4 | translate_offset_with_edit, Assist, CompletionItem, CompletionItemKind, Documentation, | ||
5 | FileSystemEdit, Fold, FoldKind, FunctionSignature, Highlight, HighlightModifier, HighlightTag, | ||
6 | HighlightedRange, InlayHint, InlayKind, InsertTextFormat, LineIndex, NavigationTarget, | ||
7 | ReferenceAccess, Severity, SourceChange, SourceFileEdit, | ||
8 | }; | ||
9 | use ra_syntax::{SyntaxKind, TextRange, TextSize}; | ||
10 | use ra_text_edit::{Indel, TextEdit}; | ||
11 | use ra_vfs::LineEndings; | ||
12 | |||
13 | use crate::{lsp_ext, semantic_tokens, world::WorldSnapshot, Result}; | ||
14 | |||
15 | pub(crate) fn position(line_index: &LineIndex, offset: TextSize) -> lsp_types::Position { | ||
16 | let line_col = line_index.line_col(offset); | ||
17 | let line = u64::from(line_col.line); | ||
18 | let character = u64::from(line_col.col_utf16); | ||
19 | lsp_types::Position::new(line, character) | ||
20 | } | ||
21 | |||
22 | pub(crate) fn range(line_index: &LineIndex, range: TextRange) -> lsp_types::Range { | ||
23 | let start = position(line_index, range.start()); | ||
24 | let end = position(line_index, range.end()); | ||
25 | lsp_types::Range::new(start, end) | ||
26 | } | ||
27 | |||
28 | pub(crate) fn symbol_kind(syntax_kind: SyntaxKind) -> lsp_types::SymbolKind { | ||
29 | match syntax_kind { | ||
30 | SyntaxKind::FN_DEF => lsp_types::SymbolKind::Function, | ||
31 | SyntaxKind::STRUCT_DEF => lsp_types::SymbolKind::Struct, | ||
32 | SyntaxKind::ENUM_DEF => lsp_types::SymbolKind::Enum, | ||
33 | SyntaxKind::ENUM_VARIANT => lsp_types::SymbolKind::EnumMember, | ||
34 | SyntaxKind::TRAIT_DEF => lsp_types::SymbolKind::Interface, | ||
35 | SyntaxKind::MACRO_CALL => lsp_types::SymbolKind::Function, | ||
36 | SyntaxKind::MODULE => lsp_types::SymbolKind::Module, | ||
37 | SyntaxKind::TYPE_ALIAS_DEF => lsp_types::SymbolKind::TypeParameter, | ||
38 | SyntaxKind::RECORD_FIELD_DEF => lsp_types::SymbolKind::Field, | ||
39 | SyntaxKind::STATIC_DEF => lsp_types::SymbolKind::Constant, | ||
40 | SyntaxKind::CONST_DEF => lsp_types::SymbolKind::Constant, | ||
41 | SyntaxKind::IMPL_DEF => lsp_types::SymbolKind::Object, | ||
42 | _ => lsp_types::SymbolKind::Variable, | ||
43 | } | ||
44 | } | ||
45 | |||
46 | pub(crate) fn document_highlight_kind( | ||
47 | reference_access: ReferenceAccess, | ||
48 | ) -> lsp_types::DocumentHighlightKind { | ||
49 | match reference_access { | ||
50 | ReferenceAccess::Read => lsp_types::DocumentHighlightKind::Read, | ||
51 | ReferenceAccess::Write => lsp_types::DocumentHighlightKind::Write, | ||
52 | } | ||
53 | } | ||
54 | |||
55 | pub(crate) fn diagnostic_severity(severity: Severity) -> lsp_types::DiagnosticSeverity { | ||
56 | match severity { | ||
57 | Severity::Error => lsp_types::DiagnosticSeverity::Error, | ||
58 | Severity::WeakWarning => lsp_types::DiagnosticSeverity::Hint, | ||
59 | } | ||
60 | } | ||
61 | |||
62 | pub(crate) fn documentation(documentation: Documentation) -> lsp_types::Documentation { | ||
63 | let value = crate::markdown::format_docs(documentation.as_str()); | ||
64 | let markup_content = lsp_types::MarkupContent { kind: lsp_types::MarkupKind::Markdown, value }; | ||
65 | lsp_types::Documentation::MarkupContent(markup_content) | ||
66 | } | ||
67 | |||
68 | pub(crate) fn insert_text_format( | ||
69 | insert_text_format: InsertTextFormat, | ||
70 | ) -> lsp_types::InsertTextFormat { | ||
71 | match insert_text_format { | ||
72 | InsertTextFormat::Snippet => lsp_types::InsertTextFormat::Snippet, | ||
73 | InsertTextFormat::PlainText => lsp_types::InsertTextFormat::PlainText, | ||
74 | } | ||
75 | } | ||
76 | |||
77 | pub(crate) fn completion_item_kind( | ||
78 | completion_item_kind: CompletionItemKind, | ||
79 | ) -> lsp_types::CompletionItemKind { | ||
80 | match completion_item_kind { | ||
81 | CompletionItemKind::Keyword => lsp_types::CompletionItemKind::Keyword, | ||
82 | CompletionItemKind::Snippet => lsp_types::CompletionItemKind::Snippet, | ||
83 | CompletionItemKind::Module => lsp_types::CompletionItemKind::Module, | ||
84 | CompletionItemKind::Function => lsp_types::CompletionItemKind::Function, | ||
85 | CompletionItemKind::Struct => lsp_types::CompletionItemKind::Struct, | ||
86 | CompletionItemKind::Enum => lsp_types::CompletionItemKind::Enum, | ||
87 | CompletionItemKind::EnumVariant => lsp_types::CompletionItemKind::EnumMember, | ||
88 | CompletionItemKind::BuiltinType => lsp_types::CompletionItemKind::Struct, | ||
89 | CompletionItemKind::Binding => lsp_types::CompletionItemKind::Variable, | ||
90 | CompletionItemKind::Field => lsp_types::CompletionItemKind::Field, | ||
91 | CompletionItemKind::Trait => lsp_types::CompletionItemKind::Interface, | ||
92 | CompletionItemKind::TypeAlias => lsp_types::CompletionItemKind::Struct, | ||
93 | CompletionItemKind::Const => lsp_types::CompletionItemKind::Constant, | ||
94 | CompletionItemKind::Static => lsp_types::CompletionItemKind::Value, | ||
95 | CompletionItemKind::Method => lsp_types::CompletionItemKind::Method, | ||
96 | CompletionItemKind::TypeParam => lsp_types::CompletionItemKind::TypeParameter, | ||
97 | CompletionItemKind::Macro => lsp_types::CompletionItemKind::Method, | ||
98 | CompletionItemKind::Attribute => lsp_types::CompletionItemKind::EnumMember, | ||
99 | } | ||
100 | } | ||
101 | |||
102 | pub(crate) fn text_edit( | ||
103 | line_index: &LineIndex, | ||
104 | line_endings: LineEndings, | ||
105 | indel: Indel, | ||
106 | ) -> lsp_types::TextEdit { | ||
107 | let range = range(line_index, indel.delete); | ||
108 | let new_text = match line_endings { | ||
109 | LineEndings::Unix => indel.insert, | ||
110 | LineEndings::Dos => indel.insert.replace('\n', "\r\n"), | ||
111 | }; | ||
112 | lsp_types::TextEdit { range, new_text } | ||
113 | } | ||
114 | |||
115 | pub(crate) fn text_edit_vec( | ||
116 | line_index: &LineIndex, | ||
117 | line_endings: LineEndings, | ||
118 | text_edit: TextEdit, | ||
119 | ) -> Vec<lsp_types::TextEdit> { | ||
120 | text_edit | ||
121 | .as_indels() | ||
122 | .iter() | ||
123 | .map(|it| self::text_edit(line_index, line_endings, it.clone())) | ||
124 | .collect() | ||
125 | } | ||
126 | |||
127 | pub(crate) fn completion_item( | ||
128 | line_index: &LineIndex, | ||
129 | line_endings: LineEndings, | ||
130 | completion_item: CompletionItem, | ||
131 | ) -> lsp_types::CompletionItem { | ||
132 | let mut additional_text_edits = Vec::new(); | ||
133 | let mut text_edit = None; | ||
134 | // LSP does not allow arbitrary edits in completion, so we have to do a | ||
135 | // non-trivial mapping here. | ||
136 | let source_range = completion_item.source_range(); | ||
137 | for indel in completion_item.text_edit().as_indels() { | ||
138 | if indel.delete.contains_range(source_range) { | ||
139 | text_edit = Some(if indel.delete == source_range { | ||
140 | self::text_edit(line_index, line_endings, indel.clone()) | ||
141 | } else { | ||
142 | assert!(source_range.end() == indel.delete.end()); | ||
143 | let range1 = TextRange::new(indel.delete.start(), source_range.start()); | ||
144 | let range2 = source_range; | ||
145 | let indel1 = Indel::replace(range1, String::new()); | ||
146 | let indel2 = Indel::replace(range2, indel.insert.clone()); | ||
147 | additional_text_edits.push(self::text_edit(line_index, line_endings, indel1)); | ||
148 | self::text_edit(line_index, line_endings, indel2) | ||
149 | }) | ||
150 | } else { | ||
151 | assert!(source_range.intersect(indel.delete).is_none()); | ||
152 | let text_edit = self::text_edit(line_index, line_endings, indel.clone()); | ||
153 | additional_text_edits.push(text_edit); | ||
154 | } | ||
155 | } | ||
156 | let text_edit = text_edit.unwrap(); | ||
157 | |||
158 | let mut res = lsp_types::CompletionItem { | ||
159 | label: completion_item.label().to_string(), | ||
160 | detail: completion_item.detail().map(|it| it.to_string()), | ||
161 | filter_text: Some(completion_item.lookup().to_string()), | ||
162 | kind: completion_item.kind().map(completion_item_kind), | ||
163 | text_edit: Some(text_edit.into()), | ||
164 | additional_text_edits: Some(additional_text_edits), | ||
165 | documentation: completion_item.documentation().map(documentation), | ||
166 | deprecated: Some(completion_item.deprecated()), | ||
167 | command: if completion_item.trigger_call_info() { | ||
168 | let cmd = lsp_types::Command { | ||
169 | title: "triggerParameterHints".into(), | ||
170 | command: "editor.action.triggerParameterHints".into(), | ||
171 | arguments: None, | ||
172 | }; | ||
173 | Some(cmd) | ||
174 | } else { | ||
175 | None | ||
176 | }, | ||
177 | ..Default::default() | ||
178 | }; | ||
179 | |||
180 | if completion_item.score().is_some() { | ||
181 | res.preselect = Some(true) | ||
182 | } | ||
183 | |||
184 | if completion_item.deprecated() { | ||
185 | res.tags = Some(vec![lsp_types::CompletionItemTag::Deprecated]) | ||
186 | } | ||
187 | |||
188 | res.insert_text_format = Some(insert_text_format(completion_item.insert_text_format())); | ||
189 | |||
190 | res | ||
191 | } | ||
192 | |||
193 | pub(crate) fn signature_information( | ||
194 | signature: FunctionSignature, | ||
195 | concise: bool, | ||
196 | ) -> lsp_types::SignatureInformation { | ||
197 | let (label, documentation, params) = if concise { | ||
198 | let mut params = signature.parameters; | ||
199 | if signature.has_self_param { | ||
200 | params.remove(0); | ||
201 | } | ||
202 | (params.join(", "), None, params) | ||
203 | } else { | ||
204 | (signature.to_string(), signature.doc.map(documentation), signature.parameters) | ||
205 | }; | ||
206 | |||
207 | let parameters: Vec<lsp_types::ParameterInformation> = params | ||
208 | .into_iter() | ||
209 | .map(|param| lsp_types::ParameterInformation { | ||
210 | label: lsp_types::ParameterLabel::Simple(param), | ||
211 | documentation: None, | ||
212 | }) | ||
213 | .collect(); | ||
214 | |||
215 | lsp_types::SignatureInformation { label, documentation, parameters: Some(parameters) } | ||
216 | } | ||
217 | |||
218 | pub(crate) fn inlay_int(line_index: &LineIndex, inlay_hint: InlayHint) -> lsp_ext::InlayHint { | ||
219 | lsp_ext::InlayHint { | ||
220 | label: inlay_hint.label.to_string(), | ||
221 | range: range(line_index, inlay_hint.range), | ||
222 | kind: match inlay_hint.kind { | ||
223 | InlayKind::ParameterHint => lsp_ext::InlayKind::ParameterHint, | ||
224 | InlayKind::TypeHint => lsp_ext::InlayKind::TypeHint, | ||
225 | InlayKind::ChainingHint => lsp_ext::InlayKind::ChainingHint, | ||
226 | }, | ||
227 | } | ||
228 | } | ||
229 | |||
230 | pub(crate) fn semantic_tokens( | ||
231 | text: &str, | ||
232 | line_index: &LineIndex, | ||
233 | highlights: Vec<HighlightedRange>, | ||
234 | ) -> lsp_types::SemanticTokens { | ||
235 | let mut builder = semantic_tokens::SemanticTokensBuilder::default(); | ||
236 | |||
237 | for highlight_range in highlights { | ||
238 | let (type_, mods) = semantic_token_type_and_modifiers(highlight_range.highlight); | ||
239 | let token_index = semantic_tokens::type_index(type_); | ||
240 | let modifier_bitset = mods.0; | ||
241 | |||
242 | for mut text_range in line_index.lines(highlight_range.range) { | ||
243 | if text[text_range].ends_with('\n') { | ||
244 | text_range = | ||
245 | TextRange::new(text_range.start(), text_range.end() - TextSize::of('\n')); | ||
246 | } | ||
247 | let range = range(&line_index, text_range); | ||
248 | builder.push(range, token_index, modifier_bitset); | ||
249 | } | ||
250 | } | ||
251 | |||
252 | builder.build() | ||
253 | } | ||
254 | |||
255 | fn semantic_token_type_and_modifiers( | ||
256 | highlight: Highlight, | ||
257 | ) -> (lsp_types::SemanticTokenType, semantic_tokens::ModifierSet) { | ||
258 | let mut mods = semantic_tokens::ModifierSet::default(); | ||
259 | let type_ = match highlight.tag { | ||
260 | HighlightTag::Struct => lsp_types::SemanticTokenType::STRUCT, | ||
261 | HighlightTag::Enum => lsp_types::SemanticTokenType::ENUM, | ||
262 | HighlightTag::Union => semantic_tokens::UNION, | ||
263 | HighlightTag::TypeAlias => semantic_tokens::TYPE_ALIAS, | ||
264 | HighlightTag::Trait => lsp_types::SemanticTokenType::INTERFACE, | ||
265 | HighlightTag::BuiltinType => semantic_tokens::BUILTIN_TYPE, | ||
266 | HighlightTag::SelfType => lsp_types::SemanticTokenType::TYPE, | ||
267 | HighlightTag::Field => lsp_types::SemanticTokenType::MEMBER, | ||
268 | HighlightTag::Function => lsp_types::SemanticTokenType::FUNCTION, | ||
269 | HighlightTag::Module => lsp_types::SemanticTokenType::NAMESPACE, | ||
270 | HighlightTag::Constant => { | ||
271 | mods |= semantic_tokens::CONSTANT; | ||
272 | mods |= lsp_types::SemanticTokenModifier::STATIC; | ||
273 | lsp_types::SemanticTokenType::VARIABLE | ||
274 | } | ||
275 | HighlightTag::Static => { | ||
276 | mods |= lsp_types::SemanticTokenModifier::STATIC; | ||
277 | lsp_types::SemanticTokenType::VARIABLE | ||
278 | } | ||
279 | HighlightTag::EnumVariant => semantic_tokens::ENUM_MEMBER, | ||
280 | HighlightTag::Macro => lsp_types::SemanticTokenType::MACRO, | ||
281 | HighlightTag::Local => lsp_types::SemanticTokenType::VARIABLE, | ||
282 | HighlightTag::TypeParam => lsp_types::SemanticTokenType::TYPE_PARAMETER, | ||
283 | HighlightTag::Lifetime => semantic_tokens::LIFETIME, | ||
284 | HighlightTag::ByteLiteral | HighlightTag::NumericLiteral => { | ||
285 | lsp_types::SemanticTokenType::NUMBER | ||
286 | } | ||
287 | HighlightTag::CharLiteral | HighlightTag::StringLiteral => { | ||
288 | lsp_types::SemanticTokenType::STRING | ||
289 | } | ||
290 | HighlightTag::Comment => lsp_types::SemanticTokenType::COMMENT, | ||
291 | HighlightTag::Attribute => semantic_tokens::ATTRIBUTE, | ||
292 | HighlightTag::Keyword => lsp_types::SemanticTokenType::KEYWORD, | ||
293 | HighlightTag::UnresolvedReference => semantic_tokens::UNRESOLVED_REFERENCE, | ||
294 | HighlightTag::FormatSpecifier => semantic_tokens::FORMAT_SPECIFIER, | ||
295 | }; | ||
296 | |||
297 | for modifier in highlight.modifiers.iter() { | ||
298 | let modifier = match modifier { | ||
299 | HighlightModifier::Definition => lsp_types::SemanticTokenModifier::DECLARATION, | ||
300 | HighlightModifier::ControlFlow => semantic_tokens::CONTROL_FLOW, | ||
301 | HighlightModifier::Mutable => semantic_tokens::MUTABLE, | ||
302 | HighlightModifier::Unsafe => semantic_tokens::UNSAFE, | ||
303 | }; | ||
304 | mods |= modifier; | ||
305 | } | ||
306 | |||
307 | (type_, mods) | ||
308 | } | ||
309 | |||
310 | pub(crate) fn folding_range( | ||
311 | text: &str, | ||
312 | line_index: &LineIndex, | ||
313 | line_folding_only: bool, | ||
314 | fold: Fold, | ||
315 | ) -> lsp_types::FoldingRange { | ||
316 | let kind = match fold.kind { | ||
317 | FoldKind::Comment => Some(lsp_types::FoldingRangeKind::Comment), | ||
318 | FoldKind::Imports => Some(lsp_types::FoldingRangeKind::Imports), | ||
319 | FoldKind::Mods | FoldKind::Block => None, | ||
320 | }; | ||
321 | |||
322 | let range = range(line_index, fold.range); | ||
323 | |||
324 | if line_folding_only { | ||
325 | // Clients with line_folding_only == true (such as VSCode) will fold the whole end line | ||
326 | // even if it contains text not in the folding range. To prevent that we exclude | ||
327 | // range.end.line from the folding region if there is more text after range.end | ||
328 | // on the same line. | ||
329 | let has_more_text_on_end_line = text[TextRange::new(fold.range.end(), TextSize::of(text))] | ||
330 | .chars() | ||
331 | .take_while(|it| *it != '\n') | ||
332 | .any(|it| !it.is_whitespace()); | ||
333 | |||
334 | let end_line = if has_more_text_on_end_line { | ||
335 | range.end.line.saturating_sub(1) | ||
336 | } else { | ||
337 | range.end.line | ||
338 | }; | ||
339 | |||
340 | lsp_types::FoldingRange { | ||
341 | start_line: range.start.line, | ||
342 | start_character: None, | ||
343 | end_line, | ||
344 | end_character: None, | ||
345 | kind, | ||
346 | } | ||
347 | } else { | ||
348 | lsp_types::FoldingRange { | ||
349 | start_line: range.start.line, | ||
350 | start_character: Some(range.start.character), | ||
351 | end_line: range.end.line, | ||
352 | end_character: Some(range.end.character), | ||
353 | kind, | ||
354 | } | ||
355 | } | ||
356 | } | ||
357 | |||
358 | pub(crate) fn url(world: &WorldSnapshot, file_id: FileId) -> Result<lsp_types::Url> { | ||
359 | world.file_id_to_uri(file_id) | ||
360 | } | ||
361 | |||
362 | pub(crate) fn text_document_identifier( | ||
363 | world: &WorldSnapshot, | ||
364 | file_id: FileId, | ||
365 | ) -> Result<lsp_types::TextDocumentIdentifier> { | ||
366 | let res = lsp_types::TextDocumentIdentifier { uri: url(world, file_id)? }; | ||
367 | Ok(res) | ||
368 | } | ||
369 | |||
370 | pub(crate) fn versioned_text_document_identifier( | ||
371 | world: &WorldSnapshot, | ||
372 | file_id: FileId, | ||
373 | version: Option<i64>, | ||
374 | ) -> Result<lsp_types::VersionedTextDocumentIdentifier> { | ||
375 | let res = lsp_types::VersionedTextDocumentIdentifier { uri: url(world, file_id)?, version }; | ||
376 | Ok(res) | ||
377 | } | ||
378 | |||
379 | pub(crate) fn location(world: &WorldSnapshot, frange: FileRange) -> Result<lsp_types::Location> { | ||
380 | let url = url(world, frange.file_id)?; | ||
381 | let line_index = world.analysis().file_line_index(frange.file_id)?; | ||
382 | let range = range(&line_index, frange.range); | ||
383 | let loc = lsp_types::Location::new(url, range); | ||
384 | Ok(loc) | ||
385 | } | ||
386 | |||
387 | pub(crate) fn location_link( | ||
388 | world: &WorldSnapshot, | ||
389 | src: FileRange, | ||
390 | target: NavigationTarget, | ||
391 | ) -> Result<lsp_types::LocationLink> { | ||
392 | let src_location = location(world, src)?; | ||
393 | let (target_uri, target_range, target_selection_range) = location_info(world, target)?; | ||
394 | let res = lsp_types::LocationLink { | ||
395 | origin_selection_range: Some(src_location.range), | ||
396 | target_uri, | ||
397 | target_range, | ||
398 | target_selection_range, | ||
399 | }; | ||
400 | Ok(res) | ||
401 | } | ||
402 | |||
403 | fn location_info( | ||
404 | world: &WorldSnapshot, | ||
405 | target: NavigationTarget, | ||
406 | ) -> Result<(lsp_types::Url, lsp_types::Range, lsp_types::Range)> { | ||
407 | let line_index = world.analysis().file_line_index(target.file_id())?; | ||
408 | |||
409 | let target_uri = url(world, target.file_id())?; | ||
410 | let target_range = range(&line_index, target.full_range()); | ||
411 | let target_selection_range = | ||
412 | target.focus_range().map(|it| range(&line_index, it)).unwrap_or(target_range); | ||
413 | Ok((target_uri, target_range, target_selection_range)) | ||
414 | } | ||
415 | |||
416 | pub(crate) fn goto_definition_response( | ||
417 | world: &WorldSnapshot, | ||
418 | src: FileRange, | ||
419 | targets: Vec<NavigationTarget>, | ||
420 | ) -> Result<lsp_types::GotoDefinitionResponse> { | ||
421 | if world.config.client_caps.location_link { | ||
422 | let links = targets | ||
423 | .into_iter() | ||
424 | .map(|nav| location_link(world, src, nav)) | ||
425 | .collect::<Result<Vec<_>>>()?; | ||
426 | Ok(links.into()) | ||
427 | } else { | ||
428 | let locations = targets | ||
429 | .into_iter() | ||
430 | .map(|nav| { | ||
431 | location( | ||
432 | world, | ||
433 | FileRange { | ||
434 | file_id: nav.file_id(), | ||
435 | range: nav.focus_range().unwrap_or(nav.range()), | ||
436 | }, | ||
437 | ) | ||
438 | }) | ||
439 | .collect::<Result<Vec<_>>>()?; | ||
440 | Ok(locations.into()) | ||
441 | } | ||
442 | } | ||
443 | |||
444 | pub(crate) fn text_document_edit( | ||
445 | world: &WorldSnapshot, | ||
446 | source_file_edit: SourceFileEdit, | ||
447 | ) -> Result<lsp_types::TextDocumentEdit> { | ||
448 | let text_document = versioned_text_document_identifier(world, source_file_edit.file_id, None)?; | ||
449 | let line_index = world.analysis().file_line_index(source_file_edit.file_id)?; | ||
450 | let line_endings = world.file_line_endings(source_file_edit.file_id); | ||
451 | let edits = source_file_edit | ||
452 | .edit | ||
453 | .as_indels() | ||
454 | .iter() | ||
455 | .map(|it| text_edit(&line_index, line_endings, it.clone())) | ||
456 | .collect(); | ||
457 | Ok(lsp_types::TextDocumentEdit { text_document, edits }) | ||
458 | } | ||
459 | |||
460 | pub(crate) fn resource_op( | ||
461 | world: &WorldSnapshot, | ||
462 | file_system_edit: FileSystemEdit, | ||
463 | ) -> Result<lsp_types::ResourceOp> { | ||
464 | let res = match file_system_edit { | ||
465 | FileSystemEdit::CreateFile { source_root, path } => { | ||
466 | let uri = world.path_to_uri(source_root, &path)?; | ||
467 | lsp_types::ResourceOp::Create(lsp_types::CreateFile { uri, options: None }) | ||
468 | } | ||
469 | FileSystemEdit::MoveFile { src, dst_source_root, dst_path } => { | ||
470 | let old_uri = world.file_id_to_uri(src)?; | ||
471 | let new_uri = world.path_to_uri(dst_source_root, &dst_path)?; | ||
472 | lsp_types::ResourceOp::Rename(lsp_types::RenameFile { old_uri, new_uri, options: None }) | ||
473 | } | ||
474 | }; | ||
475 | Ok(res) | ||
476 | } | ||
477 | |||
478 | pub(crate) fn source_change( | ||
479 | world: &WorldSnapshot, | ||
480 | source_change: SourceChange, | ||
481 | ) -> Result<lsp_ext::SourceChange> { | ||
482 | let cursor_position = match source_change.cursor_position { | ||
483 | None => None, | ||
484 | Some(pos) => { | ||
485 | let line_index = world.analysis().file_line_index(pos.file_id)?; | ||
486 | let edit = source_change | ||
487 | .source_file_edits | ||
488 | .iter() | ||
489 | .find(|it| it.file_id == pos.file_id) | ||
490 | .map(|it| &it.edit); | ||
491 | let line_col = match edit { | ||
492 | Some(edit) => translate_offset_with_edit(&*line_index, pos.offset, edit), | ||
493 | None => line_index.line_col(pos.offset), | ||
494 | }; | ||
495 | let position = | ||
496 | lsp_types::Position::new(u64::from(line_col.line), u64::from(line_col.col_utf16)); | ||
497 | Some(lsp_types::TextDocumentPositionParams { | ||
498 | text_document: text_document_identifier(world, pos.file_id)?, | ||
499 | position, | ||
500 | }) | ||
501 | } | ||
502 | }; | ||
503 | let mut document_changes: Vec<lsp_types::DocumentChangeOperation> = Vec::new(); | ||
504 | for op in source_change.file_system_edits { | ||
505 | let op = resource_op(&world, op)?; | ||
506 | document_changes.push(lsp_types::DocumentChangeOperation::Op(op)); | ||
507 | } | ||
508 | for edit in source_change.source_file_edits { | ||
509 | let edit = text_document_edit(&world, edit)?; | ||
510 | document_changes.push(lsp_types::DocumentChangeOperation::Edit(edit)); | ||
511 | } | ||
512 | let workspace_edit = lsp_types::WorkspaceEdit { | ||
513 | changes: None, | ||
514 | document_changes: Some(lsp_types::DocumentChanges::Operations(document_changes)), | ||
515 | }; | ||
516 | Ok(lsp_ext::SourceChange { label: source_change.label, workspace_edit, cursor_position }) | ||
517 | } | ||
518 | |||
519 | pub fn call_hierarchy_item( | ||
520 | world: &WorldSnapshot, | ||
521 | target: NavigationTarget, | ||
522 | ) -> Result<lsp_types::CallHierarchyItem> { | ||
523 | let name = target.name().to_string(); | ||
524 | let detail = target.description().map(|it| it.to_string()); | ||
525 | let kind = symbol_kind(target.kind()); | ||
526 | let (uri, range, selection_range) = location_info(world, target)?; | ||
527 | Ok(lsp_types::CallHierarchyItem { name, kind, tags: None, detail, uri, range, selection_range }) | ||
528 | } | ||
529 | |||
530 | #[cfg(test)] | ||
531 | mod tests { | ||
532 | use test_utils::extract_ranges; | ||
533 | |||
534 | use super::*; | ||
535 | |||
536 | #[test] | ||
537 | fn conv_fold_line_folding_only_fixup() { | ||
538 | let text = r#"<fold>mod a; | ||
539 | mod b; | ||
540 | mod c;</fold> | ||
541 | |||
542 | fn main() <fold>{ | ||
543 | if cond <fold>{ | ||
544 | a::do_a(); | ||
545 | }</fold> else <fold>{ | ||
546 | b::do_b(); | ||
547 | }</fold> | ||
548 | }</fold>"#; | ||
549 | |||
550 | let (ranges, text) = extract_ranges(text, "fold"); | ||
551 | assert_eq!(ranges.len(), 4); | ||
552 | let folds = vec![ | ||
553 | Fold { range: ranges[0], kind: FoldKind::Mods }, | ||
554 | Fold { range: ranges[1], kind: FoldKind::Block }, | ||
555 | Fold { range: ranges[2], kind: FoldKind::Block }, | ||
556 | Fold { range: ranges[3], kind: FoldKind::Block }, | ||
557 | ]; | ||
558 | |||
559 | let line_index = LineIndex::new(&text); | ||
560 | let converted: Vec<lsp_types::FoldingRange> = | ||
561 | folds.into_iter().map(|it| folding_range(&text, &line_index, true, it)).collect(); | ||
562 | |||
563 | let expected_lines = [(0, 2), (4, 10), (5, 6), (7, 9)]; | ||
564 | assert_eq!(converted.len(), expected_lines.len()); | ||
565 | for (folding_range, (start_line, end_line)) in converted.iter().zip(expected_lines.iter()) { | ||
566 | assert_eq!(folding_range.start_line, *start_line); | ||
567 | assert_eq!(folding_range.start_character, None); | ||
568 | assert_eq!(folding_range.end_line, *end_line); | ||
569 | assert_eq!(folding_range.end_character, None); | ||
570 | } | ||
571 | } | ||
572 | } | ||
573 | |||
574 | pub(crate) fn code_action(world: &WorldSnapshot, assist: Assist) -> Result<lsp_types::CodeAction> { | ||
575 | let source_change = source_change(&world, assist.source_change)?; | ||
576 | let arg = serde_json::to_value(source_change)?; | ||
577 | let title = assist.label; | ||
578 | let command = lsp_types::Command { | ||
579 | title: title.clone(), | ||
580 | command: "rust-analyzer.applySourceChange".to_string(), | ||
581 | arguments: Some(vec![arg]), | ||
582 | }; | ||
583 | |||
584 | Ok(lsp_types::CodeAction { | ||
585 | title, | ||
586 | kind: Some(String::new()), | ||
587 | diagnostics: None, | ||
588 | edit: None, | ||
589 | command: Some(command), | ||
590 | is_preferred: None, | ||
591 | }) | ||
592 | } | ||
diff --git a/crates/rust-analyzer/tests/heavy_tests/main.rs b/crates/rust-analyzer/tests/heavy_tests/main.rs index e459e3a3c..5011cc273 100644 --- a/crates/rust-analyzer/tests/heavy_tests/main.rs +++ b/crates/rust-analyzer/tests/heavy_tests/main.rs | |||
@@ -3,15 +3,16 @@ mod support; | |||
3 | use std::{collections::HashMap, path::PathBuf, time::Instant}; | 3 | use std::{collections::HashMap, path::PathBuf, time::Instant}; |
4 | 4 | ||
5 | use lsp_types::{ | 5 | use lsp_types::{ |
6 | CodeActionContext, DidOpenTextDocumentParams, DocumentFormattingParams, FormattingOptions, | 6 | notification::DidOpenTextDocument, |
7 | GotoDefinitionParams, HoverParams, PartialResultParams, Position, Range, TextDocumentItem, | 7 | request::{ |
8 | TextDocumentPositionParams, WorkDoneProgressParams, | 8 | CodeActionRequest, Completion, Formatting, GotoDefinition, GotoTypeDefinition, HoverRequest, |
9 | }; | 9 | }, |
10 | use rust_analyzer::req::{ | 10 | CodeActionContext, CodeActionParams, CompletionParams, DidOpenTextDocumentParams, |
11 | CodeActionParams, CodeActionRequest, Completion, CompletionParams, DidOpenTextDocument, | 11 | DocumentFormattingParams, FormattingOptions, GotoDefinitionParams, HoverParams, |
12 | Formatting, GotoDefinition, GotoTypeDefinition, HoverRequest, OnEnter, Runnables, | 12 | PartialResultParams, Position, Range, TextDocumentItem, TextDocumentPositionParams, |
13 | RunnablesParams, | 13 | WorkDoneProgressParams, |
14 | }; | 14 | }; |
15 | use rust_analyzer::lsp_ext::{OnEnter, Runnables, RunnablesParams}; | ||
15 | use serde_json::json; | 16 | use serde_json::json; |
16 | use tempfile::TempDir; | 17 | use tempfile::TempDir; |
17 | use test_utils::skip_slow_tests; | 18 | use test_utils::skip_slow_tests; |
diff --git a/crates/rust-analyzer/tests/heavy_tests/support.rs b/crates/rust-analyzer/tests/heavy_tests/support.rs index 8d47ee4f6..8756ad4a3 100644 --- a/crates/rust-analyzer/tests/heavy_tests/support.rs +++ b/crates/rust-analyzer/tests/heavy_tests/support.rs | |||
@@ -13,15 +13,15 @@ use lsp_types::{ | |||
13 | request::Shutdown, | 13 | request::Shutdown, |
14 | DidOpenTextDocumentParams, TextDocumentIdentifier, TextDocumentItem, Url, WorkDoneProgress, | 14 | DidOpenTextDocumentParams, TextDocumentIdentifier, TextDocumentItem, Url, WorkDoneProgress, |
15 | }; | 15 | }; |
16 | use lsp_types::{ProgressParams, ProgressParamsValue}; | ||
16 | use serde::Serialize; | 17 | use serde::Serialize; |
17 | use serde_json::{to_string_pretty, Value}; | 18 | use serde_json::{to_string_pretty, Value}; |
18 | use tempfile::TempDir; | 19 | use tempfile::TempDir; |
19 | use test_utils::{find_mismatch, parse_fixture}; | 20 | use test_utils::{find_mismatch, parse_fixture}; |
20 | 21 | ||
21 | use req::{ProgressParams, ProgressParamsValue}; | ||
22 | use rust_analyzer::{ | 22 | use rust_analyzer::{ |
23 | config::{ClientCapsConfig, Config}, | 23 | config::{ClientCapsConfig, Config}, |
24 | main_loop, req, | 24 | main_loop, |
25 | }; | 25 | }; |
26 | 26 | ||
27 | pub struct Project<'a> { | 27 | pub struct Project<'a> { |
@@ -206,7 +206,7 @@ impl Server { | |||
206 | Message::Notification(n) if n.method == "$/progress" => { | 206 | Message::Notification(n) if n.method == "$/progress" => { |
207 | match n.clone().extract::<ProgressParams>("$/progress").unwrap() { | 207 | match n.clone().extract::<ProgressParams>("$/progress").unwrap() { |
208 | ProgressParams { | 208 | ProgressParams { |
209 | token: req::ProgressToken::String(ref token), | 209 | token: lsp_types::ProgressToken::String(ref token), |
210 | value: ProgressParamsValue::WorkDone(WorkDoneProgress::End(_)), | 210 | value: ProgressParamsValue::WorkDone(WorkDoneProgress::End(_)), |
211 | } if token == "rustAnalyzer/startup" => true, | 211 | } if token == "rustAnalyzer/startup" => true, |
212 | _ => false, | 212 | _ => false, |