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