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