aboutsummaryrefslogtreecommitdiff
path: root/crates
diff options
context:
space:
mode:
Diffstat (limited to 'crates')
-rw-r--r--crates/ra_ide/src/display/navigation_target.rs9
-rw-r--r--crates/ra_text_edit/src/lib.rs1
-rw-r--r--crates/rust-analyzer/src/conv.rs726
-rw-r--r--crates/rust-analyzer/src/from_proto.rs42
-rw-r--r--crates/rust-analyzer/src/lib.rs5
-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.rs176
-rw-r--r--crates/rust-analyzer/src/main_loop/handlers.rs519
-rw-r--r--crates/rust-analyzer/src/to_proto.rs592
-rw-r--r--crates/rust-analyzer/tests/heavy_tests/main.rs17
-rw-r--r--crates/rust-analyzer/tests/heavy_tests/support.rs6
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
14use crate::FileSymbol; 14use crate::{FileRange, FileSymbol};
15 15
16use super::short_label::ShortLabel; 16use 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)]
24pub struct NavigationTarget { 24pub 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
4use 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};
11use 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};
17use ra_syntax::{SyntaxKind, TextRange, TextSize};
18use ra_text_edit::{Indel, TextEdit};
19use ra_vfs::LineEndings;
20
21use crate::{
22 req,
23 semantic_tokens::{self, ModifierSet, CONSTANT, CONTROL_FLOW, MUTABLE, UNSAFE},
24 world::WorldSnapshot,
25 Result,
26};
27use semantic_tokens::{
28 ATTRIBUTE, BUILTIN_TYPE, ENUM_MEMBER, FORMAT_SPECIFIER, LIFETIME, TYPE_ALIAS, UNION,
29 UNRESOLVED_REFERENCE,
30};
31
32pub trait Conv {
33 type Output;
34 fn conv(self) -> Self::Output;
35}
36
37pub trait ConvWith<CTX> {
38 type Output;
39 fn conv_with(self, ctx: CTX) -> Self::Output;
40}
41
42pub trait TryConvWith<CTX> {
43 type Output;
44 fn try_conv_with(self, ctx: CTX) -> Result<Self::Output>;
45}
46
47impl 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
69impl 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
81impl 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
109impl 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
119impl 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
186impl 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
195impl 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
204impl 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
212impl 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
220impl 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
230impl 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
255impl 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
263impl 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
278pub(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
284impl 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
333impl 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
348impl 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
401impl<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
409impl 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
416impl 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
423impl 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
430impl 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
437impl 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
444impl 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
454impl 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
464impl<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
475impl 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
514impl 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
529impl 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
547impl 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
556impl 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
583impl 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
603pub 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
621pub 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
632pub 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
640impl<CTX, I> MapConvWith<CTX> for I
641where
642 I: Iterator,
643 I::Item: ConvWith<CTX>,
644{
645 type Output = <I::Item as ConvWith<CTX>>::Output;
646}
647
648pub struct ConvWithIter<I, CTX> {
649 iter: I,
650 ctx: CTX,
651}
652
653impl<I, CTX> Iterator for ConvWithIter<I, CTX>
654where
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
666pub trait TryConvWithToVec<CTX>: Sized {
667 type Output;
668
669 fn try_conv_with_to_vec(self, ctx: CTX) -> Result<Vec<Self::Output>>;
670}
671
672impl<I, CTX> TryConvWithToVec<CTX> for I
673where
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)]
686mod 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;
693mod b;
694mod c;</fold>
695
696fn 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.
2use ra_db::{FileId, FilePosition, FileRange};
3use ra_ide::{LineCol, LineIndex};
4use ra_syntax::{TextRange, TextSize};
5
6use crate::{world::WorldSnapshot, Result};
7
8pub(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
13pub(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
19pub(crate) fn file_id(world: &WorldSnapshot, url: &lsp_types::Url) -> Result<FileId> {
20 world.uri_to_file_id(url)
21}
22
23pub(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
33pub(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 {
20mod vfs_glob; 20mod vfs_glob;
21mod caps; 21mod caps;
22mod cargo_target_spec; 22mod cargo_target_spec;
23mod conv; 23mod to_proto;
24mod from_proto;
24mod main_loop; 25mod main_loop;
25mod markdown; 26mod markdown;
26pub mod req; 27pub mod lsp_ext;
27pub mod config; 28pub mod config;
28mod world; 29mod world;
29mod diagnostics; 30mod 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
3use std::path::PathBuf;
4
5use lsp_types::request::Request;
3use lsp_types::{Location, Position, Range, TextDocumentIdentifier}; 6use lsp_types::{Location, Position, Range, TextDocumentIdentifier};
4use rustc_hash::FxHashMap; 7use rustc_hash::FxHashMap;
5use serde::{Deserialize, Serialize}; 8use serde::{Deserialize, Serialize};
6 9
7pub 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};
21use std::path::PathBuf;
22
23pub enum AnalyzerStatus {} 10pub enum AnalyzerStatus {}
24 11
25impl Request for AnalyzerStatus { 12impl Request for AnalyzerStatus {
@@ -91,7 +78,7 @@ pub struct FindMatchingBraceParams {
91pub enum ParentModule {} 78pub enum ParentModule {}
92 79
93impl Request for ParentModule { 80impl 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 {
114pub enum OnEnter {} 101pub enum OnEnter {}
115 102
116impl Request for OnEnter { 103impl 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")]
151pub struct SourceChange { 138pub 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
157pub enum InlayHints {} 144pub 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
38use crate::{ 38use 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
929fn result_to_task<R>(id: RequestId, result: Result<R::Result>) -> Task 937fn result_to_task<R>(id: RequestId, result: Result<R::Result>) -> Task
930where 938where
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
987pub fn show_message(typ: req::MessageType, message: impl Into<String>, sender: &Sender<Message>) { 995pub 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};
24use ra_prof::profile; 24use ra_prof::profile;
25use ra_project_model::TargetKind;
25use ra_syntax::{AstNode, SyntaxKind, TextRange, TextSize}; 26use ra_syntax::{AstNode, SyntaxKind, TextRange, TextSize};
26use rustc_hash::FxHashMap; 27use rustc_hash::FxHashMap;
27use serde::{Deserialize, Serialize}; 28use serde::{Deserialize, Serialize};
@@ -31,18 +32,13 @@ use stdx::format_to;
31use crate::{ 32use 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};
45use ra_project_model::TargetKind;
46 42
47pub fn handle_analyzer_status(world: WorldSnapshot, _: ()) -> Result<String> { 43pub 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
59pub fn handle_syntax_tree(world: WorldSnapshot, params: req::SyntaxTreeParams) -> Result<String> { 55pub 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, &params.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
68pub fn handle_expand_macro( 67pub 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, &params.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
86pub fn handle_selection_range( 85pub 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, &params.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
129pub fn handle_find_matching_brace( 128pub 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, &params.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
154pub fn handle_join_lines( 150pub 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 = (&params.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
163pub fn handle_on_enter( 160pub 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`.
176pub fn handle_on_type_formatting( 173pub 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
215pub fn handle_document_symbol( 212pub 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, &params.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,
264fn 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
283pub fn handle_workspace_symbol( 280pub 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
327pub fn handle_goto_definition( 324pub 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
341pub fn handle_goto_implementation( 342pub 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
355pub fn handle_goto_type_definition( 360pub 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
369pub fn handle_parent_module( 378pub 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
378pub fn handle_runnables( 392pub 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, &params.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
437pub fn handle_completion( 451pub 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, &params.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
495pub fn handle_signature_help( 510pub 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
519pub fn handle_hover(world: WorldSnapshot, params: req::HoverParams) -> Result<Option<Hover>> { 534pub 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
538pub fn handle_prepare_rename( 553pub 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
557pub fn handle_rename(world: WorldSnapshot, params: RenameParams) -> Result<Option<WorkspaceEdit>> { 571pub 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
580pub fn handle_references( 593pub 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, &params.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
703fn 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
722pub fn handle_code_action( 696pub 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, &params.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
836pub fn handle_code_lens( 810pub 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, &params.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")]
928enum CodeLensResolveData { 902enum CodeLensResolveData {
929 Impls(req::GotoImplementationParams), 903 Impls(lsp_types::request::GotoImplementationParams),
930} 904}
931 905
932pub fn handle_code_lens_resolve(world: WorldSnapshot, code_lens: CodeLens) -> Result<CodeLens> { 906pub 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
977pub fn handle_document_highlight( 951pub 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
1004pub fn handle_ssr(world: WorldSnapshot, params: req::SsrParams) -> Result<req::SourceChange> { 978pub 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(&params.query, params.parse_only)??;
1008 .structural_search_replace(&params.query, params.parse_only)?? 985 to_proto::source_change(&world, source_change)
1009 .try_conv_with(&world)
1010} 986}
1011 987
1012pub fn publish_diagnostics(world: &WorldSnapshot, file_id: FileId) -> Result<DiagnosticTask> { 988pub 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, &params.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, &params.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
1193pub fn handle_semantic_tokens_range( 1160pub 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 = (&params.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.
2use ra_db::{FileId, FileRange};
3use 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};
9use ra_syntax::{SyntaxKind, TextRange, TextSize};
10use ra_text_edit::{Indel, TextEdit};
11use ra_vfs::LineEndings;
12
13use crate::{lsp_ext, semantic_tokens, world::WorldSnapshot, Result};
14
15pub(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
22pub(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
28pub(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
46pub(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
55pub(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
62pub(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
68pub(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
77pub(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
102pub(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
115pub(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
127pub(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
193pub(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
218pub(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
230pub(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
255fn 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
310pub(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
358pub(crate) fn url(world: &WorldSnapshot, file_id: FileId) -> Result<lsp_types::Url> {
359 world.file_id_to_uri(file_id)
360}
361
362pub(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
370pub(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
379pub(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
387pub(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
403fn 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
416pub(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
444pub(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
460pub(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
478pub(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
519pub 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)]
531mod 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;
539mod b;
540mod c;</fold>
541
542fn 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
574pub(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;
3use std::{collections::HashMap, path::PathBuf, time::Instant}; 3use std::{collections::HashMap, path::PathBuf, time::Instant};
4 4
5use lsp_types::{ 5use 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 },
10use 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};
15use rust_analyzer::lsp_ext::{OnEnter, Runnables, RunnablesParams};
15use serde_json::json; 16use serde_json::json;
16use tempfile::TempDir; 17use tempfile::TempDir;
17use test_utils::skip_slow_tests; 18use 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};
16use lsp_types::{ProgressParams, ProgressParamsValue};
16use serde::Serialize; 17use serde::Serialize;
17use serde_json::{to_string_pretty, Value}; 18use serde_json::{to_string_pretty, Value};
18use tempfile::TempDir; 19use tempfile::TempDir;
19use test_utils::{find_mismatch, parse_fixture}; 20use test_utils::{find_mismatch, parse_fixture};
20 21
21use req::{ProgressParams, ProgressParamsValue};
22use rust_analyzer::{ 22use rust_analyzer::{
23 config::{ClientCapsConfig, Config}, 23 config::{ClientCapsConfig, Config},
24 main_loop, req, 24 main_loop,
25}; 25};
26 26
27pub struct Project<'a> { 27pub 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,
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-26 15:45:19 +0000