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
169 let detail = completion.detail.as_ref().unwrap();
170 if detail.starts_with("fn(") {
171 let text = REGEX.replace(&completion.label, &detail[2..]).to_string();
172 let source = Rope::from(format!("fn {} {{}}", text).as_str());
173 let runs = language.highlight_text(&source, 3..3 + text.len());
174 return Some(CodeLabel {
175 filter_range: 0..completion.label.find('(').unwrap_or(text.len()),
176 text,
177 runs,
178 });
179 }
180 }
181 Some(kind) => {
182 let highlight_name = match kind {
183 lsp::CompletionItemKind::STRUCT
184 | lsp::CompletionItemKind::INTERFACE
185 | lsp::CompletionItemKind::ENUM => Some("type"),
186 lsp::CompletionItemKind::ENUM_MEMBER => Some("variant"),
187 lsp::CompletionItemKind::KEYWORD => Some("keyword"),
188 lsp::CompletionItemKind::VALUE | lsp::CompletionItemKind::CONSTANT => {
189 Some("constant")
190 }
191 _ => None,
192 };
193 let highlight_id = language.grammar()?.highlight_id_for_name(highlight_name?)?;
194 let mut label = CodeLabel::plain(completion.label.clone(), None);
195 label.runs.push((
196 0..label.text.rfind('(').unwrap_or(label.text.len()),
197 highlight_id,
198 ));
199 return Some(label);
200 }
201 _ => {}
202 }
203 None
204 }
205
206 async fn label_for_symbol(
207 &self,
208 name: &str,
209 kind: lsp::SymbolKind,
210 language: &Arc<Language>,
211 ) -> Option<CodeLabel> {
212 let (text, filter_range, display_range) = match kind {
213 lsp::SymbolKind::METHOD | lsp::SymbolKind::FUNCTION => {
214 let text = format!("fn {} () {{}}", name);
215 let filter_range = 3..3 + name.len();
216 let display_range = 0..filter_range.end;
217 (text, filter_range, display_range)
218 }
219 lsp::SymbolKind::STRUCT => {
220 let text = format!("struct {} {{}}", name);
221 let filter_range = 7..7 + name.len();
222 let display_range = 0..filter_range.end;
223 (text, filter_range, display_range)
224 }
225 lsp::SymbolKind::ENUM => {
226 let text = format!("enum {} {{}}", name);
227 let filter_range = 5..5 + name.len();
228 let display_range = 0..filter_range.end;
229 (text, filter_range, display_range)
230 }
231 lsp::SymbolKind::INTERFACE => {
232 let text = format!("trait {} {{}}", name);
233 let filter_range = 6..6 + name.len();
234 let display_range = 0..filter_range.end;
235 (text, filter_range, display_range)
236 }
237 lsp::SymbolKind::CONSTANT => {
238 let text = format!("const {}: () = ();", name);
239 let filter_range = 6..6 + name.len();
240 let display_range = 0..filter_range.end;
241 (text, filter_range, display_range)
242 }
243 lsp::SymbolKind::MODULE => {
244 let text = format!("mod {} {{}}", name);
245 let filter_range = 4..4 + name.len();
246 let display_range = 0..filter_range.end;
247 (text, filter_range, display_range)
248 }
249 lsp::SymbolKind::TYPE_PARAMETER => {
250 let text = format!("type {} {{}}", name);
251 let filter_range = 5..5 + name.len();
252 let display_range = 0..filter_range.end;
253 (text, filter_range, display_range)
254 }
255 _ => return None,
256 };
257
258 Some(CodeLabel {
259 runs: language.highlight_text(&text.as_str().into(), display_range.clone()),
260 text: text[display_range].to_string(),
261 filter_range,
262 })
263 }
264}
265async fn get_cached_server_binary(container_dir: PathBuf) -> Option<LanguageServerBinary> {
266 (|| async move {
267 let mut last = None;
268 let mut entries = fs::read_dir(&container_dir).await?;
269 while let Some(entry) = entries.next().await {
270 last = Some(entry?.path());
271 }
272
273 anyhow::Ok(LanguageServerBinary {
274 path: last.ok_or_else(|| anyhow!("no cached binary"))?,
275 arguments: Default::default(),
276 })
277 })()
278 .await
279 .log_err()
280}
281
282#[cfg(test)]
283mod tests {
284 use std::num::NonZeroU32;
285
286 use super::*;
287 use crate::languages::language;
288 use gpui::{color::Color, TestAppContext};
289 use language::language_settings::AllLanguageSettings;
290 use settings::SettingsStore;
291 use theme::SyntaxTheme;
292
293 #[gpui::test]
294 async fn test_process_rust_diagnostics() {
295 let mut params = lsp::PublishDiagnosticsParams {
296 uri: lsp::Url::from_file_path("/a").unwrap(),
297 version: None,
298 diagnostics: vec![
299 // no newlines
300 lsp::Diagnostic {
301 message: "use of moved value `a`".to_string(),
302 ..Default::default()
303 },
304 // newline at the end of a code span
305 lsp::Diagnostic {
306 message: "consider importing this struct: `use b::c;\n`".to_string(),
307 ..Default::default()
308 },
309 // code span starting right after a newline
310 lsp::Diagnostic {
311 message: "cannot borrow `self.d` as mutable\n`self` is a `&` reference"
312 .to_string(),
313 ..Default::default()
314 },
315 ],
316 };
317 RustLspAdapter.process_diagnostics(&mut params);
318
319 assert_eq!(params.diagnostics[0].message, "use of moved value `a`");
320
321 // remove trailing newline from code span
322 assert_eq!(
323 params.diagnostics[1].message,
324 "consider importing this struct: `use b::c;`"
325 );
326
327 // do not remove newline before the start of code span
328 assert_eq!(
329 params.diagnostics[2].message,
330 "cannot borrow `self.d` as mutable\n`self` is a `&` reference"
331 );
332 }
333
334 #[gpui::test]
335 async fn test_rust_label_for_completion() {
336 let language = language(
337 "rust",
338 tree_sitter_rust::language(),
339 Some(Arc::new(RustLspAdapter)),
340 )
341 .await;
342 let grammar = language.grammar().unwrap();
343 let theme = SyntaxTheme::new(vec![
344 ("type".into(), Color::green().into()),
345 ("keyword".into(), Color::blue().into()),
346 ("function".into(), Color::red().into()),
347 ("property".into(), Color::white().into()),
348 ]);
349
350 language.set_theme(&theme);
351
352 let highlight_function = grammar.highlight_id_for_name("function").unwrap();
353 let highlight_type = grammar.highlight_id_for_name("type").unwrap();
354 let highlight_keyword = grammar.highlight_id_for_name("keyword").unwrap();
355 let highlight_field = grammar.highlight_id_for_name("property").unwrap();
356
357 assert_eq!(
358 language
359 .label_for_completion(&lsp::CompletionItem {
360 kind: Some(lsp::CompletionItemKind::FUNCTION),
361 label: "hello(…)".to_string(),
362 detail: Some("fn(&mut Option<T>) -> Vec<T>".to_string()),
363 ..Default::default()
364 })
365 .await,
366 Some(CodeLabel {
367 text: "hello(&mut Option<T>) -> Vec<T>".to_string(),
368 filter_range: 0..5,
369 runs: vec![
370 (0..5, highlight_function),
371 (7..10, highlight_keyword),
372 (11..17, highlight_type),
373 (18..19, highlight_type),
374 (25..28, highlight_type),
375 (29..30, highlight_type),
376 ],
377 })
378 );
379
380 assert_eq!(
381 language
382 .label_for_completion(&lsp::CompletionItem {
383 kind: Some(lsp::CompletionItemKind::FIELD),
384 label: "len".to_string(),
385 detail: Some("usize".to_string()),
386 ..Default::default()
387 })
388 .await,
389 Some(CodeLabel {
390 text: "len: usize".to_string(),
391 filter_range: 0..3,
392 runs: vec![(0..3, highlight_field), (5..10, highlight_type),],
393 })
394 );
395
396 assert_eq!(
397 language
398 .label_for_completion(&lsp::CompletionItem {
399 kind: Some(lsp::CompletionItemKind::FUNCTION),
400 label: "hello(…)".to_string(),
401 detail: Some("fn(&mut Option<T>) -> Vec<T>".to_string()),
402 ..Default::default()
403 })
404 .await,
405 Some(CodeLabel {
406 text: "hello(&mut Option<T>) -> Vec<T>".to_string(),
407 filter_range: 0..5,
408 runs: vec![
409 (0..5, highlight_function),
410 (7..10, highlight_keyword),
411 (11..17, highlight_type),
412 (18..19, highlight_type),
413 (25..28, highlight_type),
414 (29..30, highlight_type),
415 ],
416 })
417 );
418 }
419
420 #[gpui::test]
421 async fn test_rust_label_for_symbol() {
422 let language = language(
423 "rust",
424 tree_sitter_rust::language(),
425 Some(Arc::new(RustLspAdapter)),
426 )
427 .await;
428 let grammar = language.grammar().unwrap();
429 let theme = SyntaxTheme::new(vec![
430 ("type".into(), Color::green().into()),
431 ("keyword".into(), Color::blue().into()),
432 ("function".into(), Color::red().into()),
433 ("property".into(), Color::white().into()),
434 ]);
435
436 language.set_theme(&theme);
437
438 let highlight_function = grammar.highlight_id_for_name("function").unwrap();
439 let highlight_type = grammar.highlight_id_for_name("type").unwrap();
440 let highlight_keyword = grammar.highlight_id_for_name("keyword").unwrap();
441
442 assert_eq!(
443 language
444 .label_for_symbol("hello", lsp::SymbolKind::FUNCTION)
445 .await,
446 Some(CodeLabel {
447 text: "fn hello".to_string(),
448 filter_range: 3..8,
449 runs: vec![(0..2, highlight_keyword), (3..8, highlight_function)],
450 })
451 );
452
453 assert_eq!(
454 language
455 .label_for_symbol("World", lsp::SymbolKind::TYPE_PARAMETER)
456 .await,
457 Some(CodeLabel {
458 text: "type World".to_string(),
459 filter_range: 5..10,
460 runs: vec![(0..4, highlight_keyword), (5..10, highlight_type)],
461 })
462 );
463 }
464
465 #[gpui::test]
466 async fn test_rust_autoindent(cx: &mut TestAppContext) {
467 cx.foreground().set_block_on_ticks(usize::MAX..=usize::MAX);
468 cx.update(|cx| {
469 cx.set_global(SettingsStore::test(cx));
470 language::init(cx);
471 cx.update_global::<SettingsStore, _, _>(|store, cx| {
472 store.update_user_settings::<AllLanguageSettings>(cx, |s| {
473 s.defaults.tab_size = NonZeroU32::new(2);
474 });
475 });
476 });
477
478 let language = crate::languages::language("rust", tree_sitter_rust::language(), None).await;
479
480 cx.add_model(|cx| {
481 let mut buffer = Buffer::new(0, cx.model_id() as u64, "").with_language(language, cx);
482
483 // indent between braces
484 buffer.set_text("fn a() {}", cx);
485 let ix = buffer.len() - 1;
486 buffer.edit([(ix..ix, "\n\n")], Some(AutoindentMode::EachLine), cx);
487 assert_eq!(buffer.text(), "fn a() {\n \n}");
488
489 // indent between braces, even after empty lines
490 buffer.set_text("fn a() {\n\n\n}", cx);
491 let ix = buffer.len() - 2;
492 buffer.edit([(ix..ix, "\n")], Some(AutoindentMode::EachLine), cx);
493 assert_eq!(buffer.text(), "fn a() {\n\n\n \n}");
494
495 // indent a line that continues a field expression
496 buffer.set_text("fn a() {\n \n}", cx);
497 let ix = buffer.len() - 2;
498 buffer.edit([(ix..ix, "b\n.c")], Some(AutoindentMode::EachLine), cx);
499 assert_eq!(buffer.text(), "fn a() {\n b\n .c\n}");
500
501 // indent further lines that continue the field expression, even after empty lines
502 let ix = buffer.len() - 2;
503 buffer.edit([(ix..ix, "\n\n.d")], Some(AutoindentMode::EachLine), cx);
504 assert_eq!(buffer.text(), "fn a() {\n b\n .c\n \n .d\n}");
505
506 // dedent the line after the field expression
507 let ix = buffer.len() - 2;
508 buffer.edit([(ix..ix, ";\ne")], Some(AutoindentMode::EachLine), cx);
509 assert_eq!(
510 buffer.text(),
511 "fn a() {\n b\n .c\n \n .d;\n e\n}"
512 );
513
514 // indent inside a struct within a call
515 buffer.set_text("const a: B = c(D {});", cx);
516 let ix = buffer.len() - 3;
517 buffer.edit([(ix..ix, "\n\n")], Some(AutoindentMode::EachLine), cx);
518 assert_eq!(buffer.text(), "const a: B = c(D {\n \n});");
519
520 // indent further inside a nested call
521 let ix = buffer.len() - 4;
522 buffer.edit([(ix..ix, "e: f(\n\n)")], Some(AutoindentMode::EachLine), cx);
523 assert_eq!(buffer.text(), "const a: B = c(D {\n e: f(\n \n )\n});");
524
525 // keep that indent after an empty line
526 let ix = buffer.len() - 8;
527 buffer.edit([(ix..ix, "\n")], Some(AutoindentMode::EachLine), cx);
528 assert_eq!(
529 buffer.text(),
530 "const a: B = c(D {\n e: f(\n \n \n )\n});"
531 );
532
533 buffer
534 });
535 }
536}