1use anyhow::{anyhow, Result};
2use async_compression::futures::bufread::GzipDecoder;
3use async_trait::async_trait;
4use futures::{io::BufReader, StreamExt};
5pub use language::*;
6use lazy_static::lazy_static;
7use lsp::LanguageServerBinary;
8use regex::Regex;
9use smol::fs::{self, File};
10use std::{any::Any, borrow::Cow, env::consts, path::PathBuf, str, sync::Arc};
11use util::{
12 fs::remove_matching,
13 github::{latest_github_release, GitHubLspBinaryVersion},
14 ResultExt,
15};
16
17pub struct RustLspAdapter;
18
19#[async_trait]
20impl LspAdapter for RustLspAdapter {
21 async fn name(&self) -> LanguageServerName {
22 LanguageServerName("rust-analyzer".into())
23 }
24
25 fn short_name(&self) -> &'static str {
26 "rust"
27 }
28
29 async fn fetch_latest_server_version(
30 &self,
31 delegate: &dyn LspAdapterDelegate,
32 ) -> Result<Box<dyn 'static + Send + Any>> {
33 let release =
34 latest_github_release("rust-analyzer/rust-analyzer", false, delegate.http_client())
35 .await?;
36 let asset_name = format!("rust-analyzer-{}-apple-darwin.gz", consts::ARCH);
37 let asset = release
38 .assets
39 .iter()
40 .find(|asset| asset.name == asset_name)
41 .ok_or_else(|| anyhow!("no asset found matching {:?}", asset_name))?;
42 Ok(Box::new(GitHubLspBinaryVersion {
43 name: release.name,
44 url: asset.browser_download_url.clone(),
45 }))
46 }
47
48 async fn fetch_server_binary(
49 &self,
50 version: Box<dyn 'static + Send + Any>,
51 container_dir: PathBuf,
52 delegate: &dyn LspAdapterDelegate,
53 ) -> Result<LanguageServerBinary> {
54 let version = version.downcast::<GitHubLspBinaryVersion>().unwrap();
55 let destination_path = container_dir.join(format!("rust-analyzer-{}", version.name));
56
57 if fs::metadata(&destination_path).await.is_err() {
58 let mut response = delegate
59 .http_client()
60 .get(&version.url, Default::default(), true)
61 .await
62 .map_err(|err| anyhow!("error downloading release: {}", err))?;
63 let decompressed_bytes = GzipDecoder::new(BufReader::new(response.body_mut()));
64 let mut file = File::create(&destination_path).await?;
65 futures::io::copy(decompressed_bytes, &mut file).await?;
66 fs::set_permissions(
67 &destination_path,
68 <fs::Permissions as fs::unix::PermissionsExt>::from_mode(0o755),
69 )
70 .await?;
71
72 remove_matching(&container_dir, |entry| entry != destination_path).await;
73 }
74
75 Ok(LanguageServerBinary {
76 path: destination_path,
77 arguments: Default::default(),
78 })
79 }
80
81 async fn cached_server_binary(
82 &self,
83 container_dir: PathBuf,
84 _: &dyn LspAdapterDelegate,
85 ) -> Option<LanguageServerBinary> {
86 get_cached_server_binary(container_dir).await
87 }
88
89 async fn installation_test_binary(
90 &self,
91 container_dir: PathBuf,
92 ) -> Option<LanguageServerBinary> {
93 get_cached_server_binary(container_dir)
94 .await
95 .map(|mut binary| {
96 binary.arguments = vec!["--help".into()];
97 binary
98 })
99 }
100
101 async fn disk_based_diagnostic_sources(&self) -> Vec<String> {
102 vec!["rustc".into()]
103 }
104
105 async fn disk_based_diagnostics_progress_token(&self) -> Option<String> {
106 Some("rust-analyzer/flycheck".into())
107 }
108
109 fn process_diagnostics(&self, params: &mut lsp::PublishDiagnosticsParams) {
110 lazy_static! {
111 static ref REGEX: Regex = Regex::new("(?m)`([^`]+)\n`$").unwrap();
112 }
113
114 for diagnostic in &mut params.diagnostics {
115 for message in diagnostic
116 .related_information
117 .iter_mut()
118 .flatten()
119 .map(|info| &mut info.message)
120 .chain([&mut diagnostic.message])
121 {
122 if let Cow::Owned(sanitized) = REGEX.replace_all(message, "`$1`") {
123 *message = sanitized;
124 }
125 }
126 }
127 }
128
129 async fn label_for_completion(
130 &self,
131 completion: &lsp::CompletionItem,
132 language: &Arc<Language>,
133 ) -> Option<CodeLabel> {
134 match completion.kind {
135 Some(lsp::CompletionItemKind::FIELD) if completion.detail.is_some() => {
136 let detail = completion.detail.as_ref().unwrap();
137 let name = &completion.label;
138 let text = format!("{}: {}", name, detail);
139 let source = Rope::from(format!("struct S {{ {} }}", text).as_str());
140 let runs = language.highlight_text(&source, 11..11 + text.len());
141 return Some(CodeLabel {
142 text,
143 runs,
144 filter_range: 0..name.len(),
145 });
146 }
147 Some(lsp::CompletionItemKind::CONSTANT | lsp::CompletionItemKind::VARIABLE)
148 if completion.detail.is_some()
149 && completion.insert_text_format != Some(lsp::InsertTextFormat::SNIPPET) =>
150 {
151 let detail = completion.detail.as_ref().unwrap();
152 let name = &completion.label;
153 let text = format!("{}: {}", name, detail);
154 let source = Rope::from(format!("let {} = ();", text).as_str());
155 let runs = language.highlight_text(&source, 4..4 + text.len());
156 return Some(CodeLabel {
157 text,
158 runs,
159 filter_range: 0..name.len(),
160 });
161 }
162 Some(lsp::CompletionItemKind::FUNCTION | lsp::CompletionItemKind::METHOD)
163 if completion.detail.is_some() =>
164 {
165 lazy_static! {
166 static ref REGEX: Regex = Regex::new("\\(…?\\)").unwrap();
167 }
168 let detail = completion.detail.as_ref().unwrap();
169 const FUNCTION_PREFIXES: [&'static str; 2] = ["async fn", "fn"];
170 let prefix = FUNCTION_PREFIXES
171 .iter()
172 .find_map(|prefix| detail.strip_prefix(*prefix).map(|suffix| (prefix, suffix)));
173 // fn keyword should be followed by opening parenthesis.
174 if let Some((prefix, suffix)) = prefix {
175 if suffix.starts_with('(') {
176 let text = REGEX.replace(&completion.label, suffix).to_string();
177 let source = Rope::from(format!("{prefix} {} {{}}", text).as_str());
178 let run_start = prefix.len() + 1;
179 let runs =
180 language.highlight_text(&source, run_start..run_start + text.len());
181 return Some(CodeLabel {
182 filter_range: 0..completion.label.find('(').unwrap_or(text.len()),
183 text,
184 runs,
185 });
186 }
187 }
188 }
189 Some(kind) => {
190 let highlight_name = match kind {
191 lsp::CompletionItemKind::STRUCT
192 | lsp::CompletionItemKind::INTERFACE
193 | lsp::CompletionItemKind::ENUM => Some("type"),
194 lsp::CompletionItemKind::ENUM_MEMBER => Some("variant"),
195 lsp::CompletionItemKind::KEYWORD => Some("keyword"),
196 lsp::CompletionItemKind::VALUE | lsp::CompletionItemKind::CONSTANT => {
197 Some("constant")
198 }
199 _ => None,
200 };
201 let highlight_id = language.grammar()?.highlight_id_for_name(highlight_name?)?;
202 let mut label = CodeLabel::plain(completion.label.clone(), None);
203 label.runs.push((
204 0..label.text.rfind('(').unwrap_or(label.text.len()),
205 highlight_id,
206 ));
207 return Some(label);
208 }
209 _ => {}
210 }
211 None
212 }
213
214 async fn label_for_symbol(
215 &self,
216 name: &str,
217 kind: lsp::SymbolKind,
218 language: &Arc<Language>,
219 ) -> Option<CodeLabel> {
220 let (text, filter_range, display_range) = match kind {
221 lsp::SymbolKind::METHOD | lsp::SymbolKind::FUNCTION => {
222 let text = format!("fn {} () {{}}", name);
223 let filter_range = 3..3 + name.len();
224 let display_range = 0..filter_range.end;
225 (text, filter_range, display_range)
226 }
227 lsp::SymbolKind::STRUCT => {
228 let text = format!("struct {} {{}}", name);
229 let filter_range = 7..7 + name.len();
230 let display_range = 0..filter_range.end;
231 (text, filter_range, display_range)
232 }
233 lsp::SymbolKind::ENUM => {
234 let text = format!("enum {} {{}}", name);
235 let filter_range = 5..5 + name.len();
236 let display_range = 0..filter_range.end;
237 (text, filter_range, display_range)
238 }
239 lsp::SymbolKind::INTERFACE => {
240 let text = format!("trait {} {{}}", name);
241 let filter_range = 6..6 + name.len();
242 let display_range = 0..filter_range.end;
243 (text, filter_range, display_range)
244 }
245 lsp::SymbolKind::CONSTANT => {
246 let text = format!("const {}: () = ();", name);
247 let filter_range = 6..6 + name.len();
248 let display_range = 0..filter_range.end;
249 (text, filter_range, display_range)
250 }
251 lsp::SymbolKind::MODULE => {
252 let text = format!("mod {} {{}}", name);
253 let filter_range = 4..4 + name.len();
254 let display_range = 0..filter_range.end;
255 (text, filter_range, display_range)
256 }
257 lsp::SymbolKind::TYPE_PARAMETER => {
258 let text = format!("type {} {{}}", name);
259 let filter_range = 5..5 + name.len();
260 let display_range = 0..filter_range.end;
261 (text, filter_range, display_range)
262 }
263 _ => return None,
264 };
265
266 Some(CodeLabel {
267 runs: language.highlight_text(&text.as_str().into(), display_range.clone()),
268 text: text[display_range].to_string(),
269 filter_range,
270 })
271 }
272}
273
274async fn get_cached_server_binary(container_dir: PathBuf) -> Option<LanguageServerBinary> {
275 (|| async move {
276 let mut last = None;
277 let mut entries = fs::read_dir(&container_dir).await?;
278 while let Some(entry) = entries.next().await {
279 last = Some(entry?.path());
280 }
281
282 anyhow::Ok(LanguageServerBinary {
283 path: last.ok_or_else(|| anyhow!("no cached binary"))?,
284 arguments: Default::default(),
285 })
286 })()
287 .await
288 .log_err()
289}
290
291#[cfg(test)]
292mod tests {
293 use std::num::NonZeroU32;
294
295 use super::*;
296 use crate::languages::language;
297 use gpui::{Context, Hsla, TestAppContext};
298 use language::language_settings::AllLanguageSettings;
299 use settings::SettingsStore;
300 use theme::SyntaxTheme;
301
302 #[gpui::test]
303 async fn test_process_rust_diagnostics() {
304 let mut params = lsp::PublishDiagnosticsParams {
305 uri: lsp::Url::from_file_path("/a").unwrap(),
306 version: None,
307 diagnostics: vec![
308 // no newlines
309 lsp::Diagnostic {
310 message: "use of moved value `a`".to_string(),
311 ..Default::default()
312 },
313 // newline at the end of a code span
314 lsp::Diagnostic {
315 message: "consider importing this struct: `use b::c;\n`".to_string(),
316 ..Default::default()
317 },
318 // code span starting right after a newline
319 lsp::Diagnostic {
320 message: "cannot borrow `self.d` as mutable\n`self` is a `&` reference"
321 .to_string(),
322 ..Default::default()
323 },
324 ],
325 };
326 RustLspAdapter.process_diagnostics(&mut params);
327
328 assert_eq!(params.diagnostics[0].message, "use of moved value `a`");
329
330 // remove trailing newline from code span
331 assert_eq!(
332 params.diagnostics[1].message,
333 "consider importing this struct: `use b::c;`"
334 );
335
336 // do not remove newline before the start of code span
337 assert_eq!(
338 params.diagnostics[2].message,
339 "cannot borrow `self.d` as mutable\n`self` is a `&` reference"
340 );
341 }
342
343 #[gpui::test]
344 async fn test_rust_label_for_completion() {
345 let language = language(
346 "rust",
347 tree_sitter_rust::language(),
348 Some(Arc::new(RustLspAdapter)),
349 )
350 .await;
351 let grammar = language.grammar().unwrap();
352 let theme = SyntaxTheme::new_test([
353 ("type", Hsla::default()),
354 ("keyword", Hsla::default()),
355 ("function", Hsla::default()),
356 ("property", Hsla::default()),
357 ]);
358
359 language.set_theme(&theme);
360
361 let highlight_function = grammar.highlight_id_for_name("function").unwrap();
362 let highlight_type = grammar.highlight_id_for_name("type").unwrap();
363 let highlight_keyword = grammar.highlight_id_for_name("keyword").unwrap();
364 let highlight_field = grammar.highlight_id_for_name("property").unwrap();
365
366 assert_eq!(
367 language
368 .label_for_completion(&lsp::CompletionItem {
369 kind: Some(lsp::CompletionItemKind::FUNCTION),
370 label: "hello(…)".to_string(),
371 detail: Some("fn(&mut Option<T>) -> Vec<T>".to_string()),
372 ..Default::default()
373 })
374 .await,
375 Some(CodeLabel {
376 text: "hello(&mut Option<T>) -> Vec<T>".to_string(),
377 filter_range: 0..5,
378 runs: vec![
379 (0..5, highlight_function),
380 (7..10, highlight_keyword),
381 (11..17, highlight_type),
382 (18..19, highlight_type),
383 (25..28, highlight_type),
384 (29..30, highlight_type),
385 ],
386 })
387 );
388 assert_eq!(
389 language
390 .label_for_completion(&lsp::CompletionItem {
391 kind: Some(lsp::CompletionItemKind::FUNCTION),
392 label: "hello(…)".to_string(),
393 detail: Some("async fn(&mut Option<T>) -> Vec<T>".to_string()),
394 ..Default::default()
395 })
396 .await,
397 Some(CodeLabel {
398 text: "hello(&mut Option<T>) -> Vec<T>".to_string(),
399 filter_range: 0..5,
400 runs: vec![
401 (0..5, highlight_function),
402 (7..10, highlight_keyword),
403 (11..17, highlight_type),
404 (18..19, highlight_type),
405 (25..28, highlight_type),
406 (29..30, highlight_type),
407 ],
408 })
409 );
410 assert_eq!(
411 language
412 .label_for_completion(&lsp::CompletionItem {
413 kind: Some(lsp::CompletionItemKind::FIELD),
414 label: "len".to_string(),
415 detail: Some("usize".to_string()),
416 ..Default::default()
417 })
418 .await,
419 Some(CodeLabel {
420 text: "len: usize".to_string(),
421 filter_range: 0..3,
422 runs: vec![(0..3, highlight_field), (5..10, highlight_type),],
423 })
424 );
425
426 assert_eq!(
427 language
428 .label_for_completion(&lsp::CompletionItem {
429 kind: Some(lsp::CompletionItemKind::FUNCTION),
430 label: "hello(…)".to_string(),
431 detail: Some("fn(&mut Option<T>) -> Vec<T>".to_string()),
432 ..Default::default()
433 })
434 .await,
435 Some(CodeLabel {
436 text: "hello(&mut Option<T>) -> Vec<T>".to_string(),
437 filter_range: 0..5,
438 runs: vec![
439 (0..5, highlight_function),
440 (7..10, highlight_keyword),
441 (11..17, highlight_type),
442 (18..19, highlight_type),
443 (25..28, highlight_type),
444 (29..30, highlight_type),
445 ],
446 })
447 );
448 }
449
450 #[gpui::test]
451 async fn test_rust_label_for_symbol() {
452 let language = language(
453 "rust",
454 tree_sitter_rust::language(),
455 Some(Arc::new(RustLspAdapter)),
456 )
457 .await;
458 let grammar = language.grammar().unwrap();
459 let theme = SyntaxTheme::new_test([
460 ("type", Hsla::default()),
461 ("keyword", Hsla::default()),
462 ("function", Hsla::default()),
463 ("property", Hsla::default()),
464 ]);
465
466 language.set_theme(&theme);
467
468 let highlight_function = grammar.highlight_id_for_name("function").unwrap();
469 let highlight_type = grammar.highlight_id_for_name("type").unwrap();
470 let highlight_keyword = grammar.highlight_id_for_name("keyword").unwrap();
471
472 assert_eq!(
473 language
474 .label_for_symbol("hello", lsp::SymbolKind::FUNCTION)
475 .await,
476 Some(CodeLabel {
477 text: "fn hello".to_string(),
478 filter_range: 3..8,
479 runs: vec![(0..2, highlight_keyword), (3..8, highlight_function)],
480 })
481 );
482
483 assert_eq!(
484 language
485 .label_for_symbol("World", lsp::SymbolKind::TYPE_PARAMETER)
486 .await,
487 Some(CodeLabel {
488 text: "type World".to_string(),
489 filter_range: 5..10,
490 runs: vec![(0..4, highlight_keyword), (5..10, highlight_type)],
491 })
492 );
493 }
494
495 #[gpui::test]
496 async fn test_rust_autoindent(cx: &mut TestAppContext) {
497 // cx.executor().set_block_on_ticks(usize::MAX..=usize::MAX);
498 cx.update(|cx| {
499 let test_settings = SettingsStore::test(cx);
500 cx.set_global(test_settings);
501 language::init(cx);
502 cx.update_global::<SettingsStore, _>(|store, cx| {
503 store.update_user_settings::<AllLanguageSettings>(cx, |s| {
504 s.defaults.tab_size = NonZeroU32::new(2);
505 });
506 });
507 });
508
509 let language = crate::languages::language("rust", tree_sitter_rust::language(), None).await;
510
511 cx.build_model(|cx| {
512 let mut buffer =
513 Buffer::new(0, cx.entity_id().as_u64(), "").with_language(language, cx);
514
515 // indent between braces
516 buffer.set_text("fn a() {}", cx);
517 let ix = buffer.len() - 1;
518 buffer.edit([(ix..ix, "\n\n")], Some(AutoindentMode::EachLine), cx);
519 assert_eq!(buffer.text(), "fn a() {\n \n}");
520
521 // indent between braces, even after empty lines
522 buffer.set_text("fn a() {\n\n\n}", cx);
523 let ix = buffer.len() - 2;
524 buffer.edit([(ix..ix, "\n")], Some(AutoindentMode::EachLine), cx);
525 assert_eq!(buffer.text(), "fn a() {\n\n\n \n}");
526
527 // indent a line that continues a field expression
528 buffer.set_text("fn a() {\n \n}", cx);
529 let ix = buffer.len() - 2;
530 buffer.edit([(ix..ix, "b\n.c")], Some(AutoindentMode::EachLine), cx);
531 assert_eq!(buffer.text(), "fn a() {\n b\n .c\n}");
532
533 // indent further lines that continue the field expression, even after empty lines
534 let ix = buffer.len() - 2;
535 buffer.edit([(ix..ix, "\n\n.d")], Some(AutoindentMode::EachLine), cx);
536 assert_eq!(buffer.text(), "fn a() {\n b\n .c\n \n .d\n}");
537
538 // dedent the line after the field expression
539 let ix = buffer.len() - 2;
540 buffer.edit([(ix..ix, ";\ne")], Some(AutoindentMode::EachLine), cx);
541 assert_eq!(
542 buffer.text(),
543 "fn a() {\n b\n .c\n \n .d;\n e\n}"
544 );
545
546 // indent inside a struct within a call
547 buffer.set_text("const a: B = c(D {});", cx);
548 let ix = buffer.len() - 3;
549 buffer.edit([(ix..ix, "\n\n")], Some(AutoindentMode::EachLine), cx);
550 assert_eq!(buffer.text(), "const a: B = c(D {\n \n});");
551
552 // indent further inside a nested call
553 let ix = buffer.len() - 4;
554 buffer.edit([(ix..ix, "e: f(\n\n)")], Some(AutoindentMode::EachLine), cx);
555 assert_eq!(buffer.text(), "const a: B = c(D {\n e: f(\n \n )\n});");
556
557 // keep that indent after an empty line
558 let ix = buffer.len() - 8;
559 buffer.edit([(ix..ix, "\n")], Some(AutoindentMode::EachLine), cx);
560 assert_eq!(
561 buffer.text(),
562 "const a: B = c(D {\n e: f(\n \n \n )\n});"
563 );
564
565 buffer
566 });
567 }
568}