1use anyhow::{anyhow, Context, Result};
2use async_trait::async_trait;
3use futures::StreamExt;
4use gpui::{AsyncAppContext, Task};
5pub use language::*;
6use lazy_static::lazy_static;
7use lsp::LanguageServerBinary;
8use regex::Regex;
9use serde_json::json;
10use smol::{fs, process};
11use std::{
12 any::Any,
13 ffi::{OsStr, OsString},
14 ops::Range,
15 path::PathBuf,
16 str,
17 sync::{
18 atomic::{AtomicBool, Ordering::SeqCst},
19 Arc,
20 },
21};
22use util::{async_maybe, fs::remove_matching, github::latest_github_release, ResultExt};
23
24fn server_binary_arguments() -> Vec<OsString> {
25 vec!["-mode=stdio".into()]
26}
27
28#[derive(Copy, Clone)]
29pub struct GoLspAdapter;
30
31lazy_static! {
32 static ref GOPLS_VERSION_REGEX: Regex = Regex::new(r"\d+\.\d+\.\d+").unwrap();
33}
34
35#[async_trait]
36impl super::LspAdapter for GoLspAdapter {
37 fn name(&self) -> LanguageServerName {
38 LanguageServerName("gopls".into())
39 }
40
41 fn short_name(&self) -> &'static str {
42 "gopls"
43 }
44
45 async fn fetch_latest_server_version(
46 &self,
47 delegate: &dyn LspAdapterDelegate,
48 ) -> Result<Box<dyn 'static + Send + Any>> {
49 let release =
50 latest_github_release("golang/tools", false, false, delegate.http_client()).await?;
51 let version: Option<String> = release.tag_name.strip_prefix("gopls/v").map(str::to_string);
52 if version.is_none() {
53 log::warn!(
54 "couldn't infer gopls version from GitHub release tag name '{}'",
55 release.tag_name
56 );
57 }
58 Ok(Box::new(version) as Box<_>)
59 }
60
61 fn check_if_user_installed(
62 &self,
63 delegate: &Arc<dyn LspAdapterDelegate>,
64 cx: &mut AsyncAppContext,
65 ) -> Option<Task<Option<LanguageServerBinary>>> {
66 let delegate = delegate.clone();
67
68 Some(cx.spawn(|cx| async move {
69 match cx.update(|cx| delegate.which_command(OsString::from("gopls"), cx)) {
70 Ok(task) => task.await.map(|(path, env)| LanguageServerBinary {
71 path,
72 arguments: server_binary_arguments(),
73 env: Some(env),
74 }),
75 Err(_) => None,
76 }
77 }))
78 }
79
80 fn will_fetch_server(
81 &self,
82 delegate: &Arc<dyn LspAdapterDelegate>,
83 cx: &mut AsyncAppContext,
84 ) -> Option<Task<Result<()>>> {
85 static DID_SHOW_NOTIFICATION: AtomicBool = AtomicBool::new(false);
86
87 const NOTIFICATION_MESSAGE: &str =
88 "Could not install the Go language server `gopls`, because `go` was not found.";
89
90 let delegate = delegate.clone();
91 Some(cx.spawn(|cx| async move {
92 let install_output = process::Command::new("go").args(["version"]).output().await;
93 if install_output.is_err() {
94 if DID_SHOW_NOTIFICATION
95 .compare_exchange(false, true, SeqCst, SeqCst)
96 .is_ok()
97 {
98 cx.update(|cx| {
99 delegate.show_notification(NOTIFICATION_MESSAGE, cx);
100 })?
101 }
102 return Err(anyhow!("cannot install gopls"));
103 }
104 Ok(())
105 }))
106 }
107
108 async fn fetch_server_binary(
109 &self,
110 version: Box<dyn 'static + Send + Any>,
111 container_dir: PathBuf,
112 delegate: &dyn LspAdapterDelegate,
113 ) -> Result<LanguageServerBinary> {
114 let version = version.downcast::<Option<String>>().unwrap();
115 let this = *self;
116
117 if let Some(version) = *version {
118 let binary_path = container_dir.join(&format!("gopls_{version}"));
119 if let Ok(metadata) = fs::metadata(&binary_path).await {
120 if metadata.is_file() {
121 remove_matching(&container_dir, |entry| {
122 entry != binary_path && entry.file_name() != Some(OsStr::new("gobin"))
123 })
124 .await;
125
126 return Ok(LanguageServerBinary {
127 path: binary_path.to_path_buf(),
128 arguments: server_binary_arguments(),
129 env: None,
130 });
131 }
132 }
133 } else if let Some(path) = this
134 .cached_server_binary(container_dir.clone(), delegate)
135 .await
136 {
137 return Ok(path);
138 }
139
140 let gobin_dir = container_dir.join("gobin");
141 fs::create_dir_all(&gobin_dir).await?;
142 let install_output = process::Command::new("go")
143 .env("GO111MODULE", "on")
144 .env("GOBIN", &gobin_dir)
145 .args(["install", "golang.org/x/tools/gopls@latest"])
146 .output()
147 .await?;
148
149 if !install_output.status.success() {
150 log::error!(
151 "failed to install gopls via `go install`. stdout: {:?}, stderr: {:?}",
152 String::from_utf8_lossy(&install_output.stdout),
153 String::from_utf8_lossy(&install_output.stderr)
154 );
155
156 return Err(anyhow!("failed to install gopls with `go install`. Is `go` installed and in the PATH? Check logs for more information."));
157 }
158
159 let installed_binary_path = gobin_dir.join("gopls");
160 let version_output = process::Command::new(&installed_binary_path)
161 .arg("version")
162 .output()
163 .await
164 .context("failed to run installed gopls binary")?;
165 let version_stdout = str::from_utf8(&version_output.stdout)
166 .context("gopls version produced invalid utf8 output")?;
167 let version = GOPLS_VERSION_REGEX
168 .find(version_stdout)
169 .with_context(|| format!("failed to parse golps version output '{version_stdout}'"))?
170 .as_str();
171 let binary_path = container_dir.join(&format!("gopls_{version}"));
172 fs::rename(&installed_binary_path, &binary_path).await?;
173
174 Ok(LanguageServerBinary {
175 path: binary_path.to_path_buf(),
176 arguments: server_binary_arguments(),
177 env: None,
178 })
179 }
180
181 async fn cached_server_binary(
182 &self,
183 container_dir: PathBuf,
184 _: &dyn LspAdapterDelegate,
185 ) -> Option<LanguageServerBinary> {
186 get_cached_server_binary(container_dir).await
187 }
188
189 async fn installation_test_binary(
190 &self,
191 container_dir: PathBuf,
192 ) -> Option<LanguageServerBinary> {
193 get_cached_server_binary(container_dir)
194 .await
195 .map(|mut binary| {
196 binary.arguments = vec!["--help".into()];
197 binary
198 })
199 }
200
201 fn initialization_options(&self) -> Option<serde_json::Value> {
202 Some(json!({
203 "usePlaceholders": true,
204 "hints": {
205 "assignVariableTypes": true,
206 "compositeLiteralFields": true,
207 "compositeLiteralTypes": true,
208 "constantValues": true,
209 "functionTypeParameters": true,
210 "parameterNames": true,
211 "rangeVariableTypes": true
212 }
213 }))
214 }
215
216 async fn label_for_completion(
217 &self,
218 completion: &lsp::CompletionItem,
219 language: &Arc<Language>,
220 ) -> Option<CodeLabel> {
221 let label = &completion.label;
222
223 // Gopls returns nested fields and methods as completions.
224 // To syntax highlight these, combine their final component
225 // with their detail.
226 let name_offset = label.rfind('.').unwrap_or(0);
227
228 match completion.kind.zip(completion.detail.as_ref()) {
229 Some((lsp::CompletionItemKind::MODULE, detail)) => {
230 let text = format!("{label} {detail}");
231 let source = Rope::from(format!("import {text}").as_str());
232 let runs = language.highlight_text(&source, 7..7 + text.len());
233 return Some(CodeLabel {
234 text,
235 runs,
236 filter_range: 0..label.len(),
237 });
238 }
239 Some((
240 lsp::CompletionItemKind::CONSTANT | lsp::CompletionItemKind::VARIABLE,
241 detail,
242 )) => {
243 let text = format!("{label} {detail}");
244 let source =
245 Rope::from(format!("var {} {}", &text[name_offset..], detail).as_str());
246 let runs = adjust_runs(
247 name_offset,
248 language.highlight_text(&source, 4..4 + text.len()),
249 );
250 return Some(CodeLabel {
251 text,
252 runs,
253 filter_range: 0..label.len(),
254 });
255 }
256 Some((lsp::CompletionItemKind::STRUCT, _)) => {
257 let text = format!("{label} struct {{}}");
258 let source = Rope::from(format!("type {}", &text[name_offset..]).as_str());
259 let runs = adjust_runs(
260 name_offset,
261 language.highlight_text(&source, 5..5 + text.len()),
262 );
263 return Some(CodeLabel {
264 text,
265 runs,
266 filter_range: 0..label.len(),
267 });
268 }
269 Some((lsp::CompletionItemKind::INTERFACE, _)) => {
270 let text = format!("{label} interface {{}}");
271 let source = Rope::from(format!("type {}", &text[name_offset..]).as_str());
272 let runs = adjust_runs(
273 name_offset,
274 language.highlight_text(&source, 5..5 + text.len()),
275 );
276 return Some(CodeLabel {
277 text,
278 runs,
279 filter_range: 0..label.len(),
280 });
281 }
282 Some((lsp::CompletionItemKind::FIELD, detail)) => {
283 let text = format!("{label} {detail}");
284 let source =
285 Rope::from(format!("type T struct {{ {} }}", &text[name_offset..]).as_str());
286 let runs = adjust_runs(
287 name_offset,
288 language.highlight_text(&source, 16..16 + text.len()),
289 );
290 return Some(CodeLabel {
291 text,
292 runs,
293 filter_range: 0..label.len(),
294 });
295 }
296 Some((lsp::CompletionItemKind::FUNCTION | lsp::CompletionItemKind::METHOD, detail)) => {
297 if let Some(signature) = detail.strip_prefix("func") {
298 let text = format!("{label}{signature}");
299 let source = Rope::from(format!("func {} {{}}", &text[name_offset..]).as_str());
300 let runs = adjust_runs(
301 name_offset,
302 language.highlight_text(&source, 5..5 + text.len()),
303 );
304 return Some(CodeLabel {
305 filter_range: 0..label.len(),
306 text,
307 runs,
308 });
309 }
310 }
311 _ => {}
312 }
313 None
314 }
315
316 async fn label_for_symbol(
317 &self,
318 name: &str,
319 kind: lsp::SymbolKind,
320 language: &Arc<Language>,
321 ) -> Option<CodeLabel> {
322 let (text, filter_range, display_range) = match kind {
323 lsp::SymbolKind::METHOD | lsp::SymbolKind::FUNCTION => {
324 let text = format!("func {} () {{}}", name);
325 let filter_range = 5..5 + name.len();
326 let display_range = 0..filter_range.end;
327 (text, filter_range, display_range)
328 }
329 lsp::SymbolKind::STRUCT => {
330 let text = format!("type {} struct {{}}", name);
331 let filter_range = 5..5 + name.len();
332 let display_range = 0..text.len();
333 (text, filter_range, display_range)
334 }
335 lsp::SymbolKind::INTERFACE => {
336 let text = format!("type {} interface {{}}", name);
337 let filter_range = 5..5 + name.len();
338 let display_range = 0..text.len();
339 (text, filter_range, display_range)
340 }
341 lsp::SymbolKind::CLASS => {
342 let text = format!("type {} T", name);
343 let filter_range = 5..5 + name.len();
344 let display_range = 0..filter_range.end;
345 (text, filter_range, display_range)
346 }
347 lsp::SymbolKind::CONSTANT => {
348 let text = format!("const {} = nil", name);
349 let filter_range = 6..6 + name.len();
350 let display_range = 0..filter_range.end;
351 (text, filter_range, display_range)
352 }
353 lsp::SymbolKind::VARIABLE => {
354 let text = format!("var {} = nil", name);
355 let filter_range = 4..4 + name.len();
356 let display_range = 0..filter_range.end;
357 (text, filter_range, display_range)
358 }
359 lsp::SymbolKind::MODULE => {
360 let text = format!("package {}", name);
361 let filter_range = 8..8 + name.len();
362 let display_range = 0..filter_range.end;
363 (text, filter_range, display_range)
364 }
365 _ => return None,
366 };
367
368 Some(CodeLabel {
369 runs: language.highlight_text(&text.as_str().into(), display_range.clone()),
370 text: text[display_range].to_string(),
371 filter_range,
372 })
373 }
374}
375
376async fn get_cached_server_binary(container_dir: PathBuf) -> Option<LanguageServerBinary> {
377 async_maybe!({
378 let mut last_binary_path = None;
379 let mut entries = fs::read_dir(&container_dir).await?;
380 while let Some(entry) = entries.next().await {
381 let entry = entry?;
382 if entry.file_type().await?.is_file()
383 && entry
384 .file_name()
385 .to_str()
386 .map_or(false, |name| name.starts_with("gopls_"))
387 {
388 last_binary_path = Some(entry.path());
389 }
390 }
391
392 if let Some(path) = last_binary_path {
393 Ok(LanguageServerBinary {
394 path,
395 arguments: server_binary_arguments(),
396 env: None,
397 })
398 } else {
399 Err(anyhow!("no cached binary"))
400 }
401 })
402 .await
403 .log_err()
404}
405
406fn adjust_runs(
407 delta: usize,
408 mut runs: Vec<(Range<usize>, HighlightId)>,
409) -> Vec<(Range<usize>, HighlightId)> {
410 for (range, _) in &mut runs {
411 range.start += delta;
412 range.end += delta;
413 }
414 runs
415}
416
417#[cfg(test)]
418mod tests {
419 use super::*;
420 use crate::language;
421 use gpui::Hsla;
422 use theme::SyntaxTheme;
423
424 #[gpui::test]
425 async fn test_go_label_for_completion() {
426 let language = language(
427 "go",
428 tree_sitter_go::language(),
429 Some(Arc::new(GoLspAdapter)),
430 )
431 .await;
432
433 let theme = SyntaxTheme::new_test([
434 ("type", Hsla::default()),
435 ("keyword", Hsla::default()),
436 ("function", Hsla::default()),
437 ("number", Hsla::default()),
438 ("property", Hsla::default()),
439 ]);
440 language.set_theme(&theme);
441
442 let grammar = language.grammar().unwrap();
443 let highlight_function = grammar.highlight_id_for_name("function").unwrap();
444 let highlight_type = grammar.highlight_id_for_name("type").unwrap();
445 let highlight_keyword = grammar.highlight_id_for_name("keyword").unwrap();
446 let highlight_number = grammar.highlight_id_for_name("number").unwrap();
447
448 assert_eq!(
449 language
450 .label_for_completion(&lsp::CompletionItem {
451 kind: Some(lsp::CompletionItemKind::FUNCTION),
452 label: "Hello".to_string(),
453 detail: Some("func(a B) c.D".to_string()),
454 ..Default::default()
455 })
456 .await,
457 Some(CodeLabel {
458 text: "Hello(a B) c.D".to_string(),
459 filter_range: 0..5,
460 runs: vec![
461 (0..5, highlight_function),
462 (8..9, highlight_type),
463 (13..14, highlight_type),
464 ],
465 })
466 );
467
468 // Nested methods
469 assert_eq!(
470 language
471 .label_for_completion(&lsp::CompletionItem {
472 kind: Some(lsp::CompletionItemKind::METHOD),
473 label: "one.two.Three".to_string(),
474 detail: Some("func() [3]interface{}".to_string()),
475 ..Default::default()
476 })
477 .await,
478 Some(CodeLabel {
479 text: "one.two.Three() [3]interface{}".to_string(),
480 filter_range: 0..13,
481 runs: vec![
482 (8..13, highlight_function),
483 (17..18, highlight_number),
484 (19..28, highlight_keyword),
485 ],
486 })
487 );
488
489 // Nested fields
490 assert_eq!(
491 language
492 .label_for_completion(&lsp::CompletionItem {
493 kind: Some(lsp::CompletionItemKind::FIELD),
494 label: "two.Three".to_string(),
495 detail: Some("a.Bcd".to_string()),
496 ..Default::default()
497 })
498 .await,
499 Some(CodeLabel {
500 text: "two.Three a.Bcd".to_string(),
501 filter_range: 0..9,
502 runs: vec![(12..15, highlight_type)],
503 })
504 );
505 }
506}