1use std::ops::Range;
2use std::path::PathBuf;
3use std::pin::Pin;
4use std::sync::Arc;
5
6use anyhow::{Context as _, Result};
7use async_trait::async_trait;
8use collections::{HashMap, HashSet};
9use extension::{Extension, ExtensionLanguageServerProxy, WorktreeDelegate};
10use futures::{Future, FutureExt, future::join_all};
11use gpui::{App, AppContext, AsyncApp, Task};
12use language::{
13 BinaryStatus, CodeLabel, DynLspInstaller, HighlightId, Language, LanguageName, LspAdapter,
14 LspAdapterDelegate, Rope, Toolchain,
15};
16use lsp::{
17 CodeActionKind, LanguageServerBinary, LanguageServerBinaryOptions, LanguageServerName,
18 LanguageServerSelector,
19};
20use serde::Serialize;
21use serde_json::Value;
22use util::{ResultExt, fs::make_file_executable, maybe, rel_path::RelPath};
23
24use crate::{LanguageServerRegistryProxy, LspAccess};
25
26/// An adapter that allows an [`LspAdapterDelegate`] to be used as a [`WorktreeDelegate`].
27struct WorktreeDelegateAdapter(pub Arc<dyn LspAdapterDelegate>);
28
29#[async_trait]
30impl WorktreeDelegate for WorktreeDelegateAdapter {
31 fn id(&self) -> u64 {
32 self.0.worktree_id().to_proto()
33 }
34
35 fn root_path(&self) -> String {
36 self.0.worktree_root_path().to_string_lossy().into_owned()
37 }
38
39 async fn read_text_file(&self, path: &RelPath) -> Result<String> {
40 self.0.read_text_file(path).await
41 }
42
43 async fn which(&self, binary_name: String) -> Option<String> {
44 self.0
45 .which(binary_name.as_ref())
46 .await
47 .map(|path| path.to_string_lossy().into_owned())
48 }
49
50 async fn shell_env(&self) -> Vec<(String, String)> {
51 self.0.shell_env().await.into_iter().collect()
52 }
53}
54
55impl ExtensionLanguageServerProxy for LanguageServerRegistryProxy {
56 fn register_language_server(
57 &self,
58 extension: Arc<dyn Extension>,
59 language_server_id: LanguageServerName,
60 language: LanguageName,
61 ) {
62 self.language_registry.register_lsp_adapter(
63 language.clone(),
64 Arc::new(ExtensionLspAdapter::new(
65 extension,
66 language_server_id,
67 language,
68 )),
69 );
70 }
71
72 fn remove_language_server(
73 &self,
74 language: &LanguageName,
75 language_server_name: &LanguageServerName,
76 cx: &mut App,
77 ) -> Task<Result<()>> {
78 self.language_registry
79 .remove_lsp_adapter(language, language_server_name);
80
81 let mut tasks = Vec::new();
82 match &self.lsp_access {
83 LspAccess::ViaLspStore(lsp_store) => lsp_store.update(cx, |lsp_store, cx| {
84 let stop_task = lsp_store.stop_language_servers_for_buffers(
85 Vec::new(),
86 HashSet::from_iter([LanguageServerSelector::Name(
87 language_server_name.clone(),
88 )]),
89 cx,
90 );
91 tasks.push(stop_task);
92 }),
93 LspAccess::ViaWorkspaces(lsp_store_provider) => {
94 if let Ok(lsp_stores) = lsp_store_provider(cx) {
95 for lsp_store in lsp_stores {
96 lsp_store.update(cx, |lsp_store, cx| {
97 let stop_task = lsp_store.stop_language_servers_for_buffers(
98 Vec::new(),
99 HashSet::from_iter([LanguageServerSelector::Name(
100 language_server_name.clone(),
101 )]),
102 cx,
103 );
104 tasks.push(stop_task);
105 });
106 }
107 }
108 }
109 LspAccess::Noop => {}
110 }
111
112 cx.background_spawn(async move {
113 let results = join_all(tasks).await;
114 for result in results {
115 result?;
116 }
117 Ok(())
118 })
119 }
120
121 fn update_language_server_status(
122 &self,
123 language_server_id: LanguageServerName,
124 status: BinaryStatus,
125 ) {
126 log::debug!(
127 "updating binary status for {} to {:?}",
128 language_server_id,
129 status
130 );
131 self.language_registry
132 .update_lsp_binary_status(language_server_id, status);
133 }
134}
135
136struct ExtensionLspAdapter {
137 extension: Arc<dyn Extension>,
138 language_server_id: LanguageServerName,
139 language_name: LanguageName,
140}
141
142impl ExtensionLspAdapter {
143 fn new(
144 extension: Arc<dyn Extension>,
145 language_server_id: LanguageServerName,
146 language_name: LanguageName,
147 ) -> Self {
148 Self {
149 extension,
150 language_server_id,
151 language_name,
152 }
153 }
154}
155
156#[async_trait(?Send)]
157impl DynLspInstaller for ExtensionLspAdapter {
158 fn get_language_server_command<'a>(
159 self: Arc<Self>,
160 delegate: Arc<dyn LspAdapterDelegate>,
161 _: Option<Toolchain>,
162 _: LanguageServerBinaryOptions,
163 _: &'a mut Option<(bool, LanguageServerBinary)>,
164 _: &'a mut AsyncApp,
165 ) -> Pin<Box<dyn 'a + Future<Output = Result<LanguageServerBinary>>>> {
166 async move {
167 let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
168 let command = self
169 .extension
170 .language_server_command(
171 self.language_server_id.clone(),
172 self.language_name.clone(),
173 delegate,
174 )
175 .await?;
176
177 let path = self.extension.path_from_extension(command.command.as_ref());
178
179 // TODO: This should now be done via the `zed::make_file_executable` function in
180 // Zed extension API, but we're leaving these existing usages in place temporarily
181 // to avoid any compatibility issues between Zed and the extension versions.
182 //
183 // We can remove once the following extension versions no longer see any use:
184 // - toml@0.0.2
185 // - zig@0.0.1
186 if ["toml", "zig"].contains(&self.extension.manifest().id.as_ref())
187 && path.starts_with(&self.extension.work_dir())
188 {
189 make_file_executable(&path)
190 .await
191 .context("failed to set file permissions")?;
192 }
193
194 Ok(LanguageServerBinary {
195 path,
196 arguments: command.args.into_iter().map(|arg| arg.into()).collect(),
197 env: Some(command.env.into_iter().collect()),
198 })
199 }
200 .boxed_local()
201 }
202
203 async fn try_fetch_server_binary(
204 &self,
205 _: &Arc<dyn LspAdapterDelegate>,
206 _: PathBuf,
207 _: bool,
208 _: &mut AsyncApp,
209 ) -> Result<LanguageServerBinary> {
210 unreachable!("get_language_server_command is overridden")
211 }
212}
213
214#[async_trait(?Send)]
215impl LspAdapter for ExtensionLspAdapter {
216 fn name(&self) -> LanguageServerName {
217 self.language_server_id.clone()
218 }
219
220 fn code_action_kinds(&self) -> Option<Vec<CodeActionKind>> {
221 let code_action_kinds = self
222 .extension
223 .manifest()
224 .language_servers
225 .get(&self.language_server_id)
226 .and_then(|server| server.code_action_kinds.clone());
227
228 code_action_kinds.or(Some(vec![
229 CodeActionKind::EMPTY,
230 CodeActionKind::QUICKFIX,
231 CodeActionKind::REFACTOR,
232 CodeActionKind::REFACTOR_EXTRACT,
233 CodeActionKind::SOURCE,
234 ]))
235 }
236
237 fn language_ids(&self) -> HashMap<LanguageName, String> {
238 // TODO: The language IDs can be provided via the language server options
239 // in `extension.toml now but we're leaving these existing usages in place temporarily
240 // to avoid any compatibility issues between Zed and the extension versions.
241 //
242 // We can remove once the following extension versions no longer see any use:
243 // - php@0.0.1
244 if self.extension.manifest().id.as_ref() == "php" {
245 return HashMap::from_iter([(LanguageName::new("PHP"), "php".into())]);
246 }
247
248 self.extension
249 .manifest()
250 .language_servers
251 .get(&self.language_server_id)
252 .map(|server| server.language_ids.clone())
253 .unwrap_or_default()
254 }
255
256 async fn initialization_options(
257 self: Arc<Self>,
258 delegate: &Arc<dyn LspAdapterDelegate>,
259 ) -> Result<Option<serde_json::Value>> {
260 let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
261 let json_options = self
262 .extension
263 .language_server_initialization_options(
264 self.language_server_id.clone(),
265 self.language_name.clone(),
266 delegate,
267 )
268 .await?;
269 Ok(if let Some(json_options) = json_options {
270 serde_json::from_str(&json_options).with_context(|| {
271 format!("failed to parse initialization_options from extension: {json_options}")
272 })?
273 } else {
274 None
275 })
276 }
277
278 async fn workspace_configuration(
279 self: Arc<Self>,
280 delegate: &Arc<dyn LspAdapterDelegate>,
281 _: Option<Toolchain>,
282 _cx: &mut AsyncApp,
283 ) -> Result<Value> {
284 let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
285 let json_options: Option<String> = self
286 .extension
287 .language_server_workspace_configuration(self.language_server_id.clone(), delegate)
288 .await?;
289 Ok(if let Some(json_options) = json_options {
290 serde_json::from_str(&json_options).with_context(|| {
291 format!("failed to parse workspace_configuration from extension: {json_options}")
292 })?
293 } else {
294 serde_json::json!({})
295 })
296 }
297
298 async fn additional_initialization_options(
299 self: Arc<Self>,
300 target_language_server_id: LanguageServerName,
301 delegate: &Arc<dyn LspAdapterDelegate>,
302 ) -> Result<Option<serde_json::Value>> {
303 let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
304 let json_options: Option<String> = self
305 .extension
306 .language_server_additional_initialization_options(
307 self.language_server_id.clone(),
308 target_language_server_id.clone(),
309 delegate,
310 )
311 .await?;
312 Ok(if let Some(json_options) = json_options {
313 serde_json::from_str(&json_options).with_context(|| {
314 format!(
315 "failed to parse additional_initialization_options from extension: {json_options}"
316 )
317 })?
318 } else {
319 None
320 })
321 }
322
323 async fn additional_workspace_configuration(
324 self: Arc<Self>,
325 target_language_server_id: LanguageServerName,
326
327 delegate: &Arc<dyn LspAdapterDelegate>,
328
329 _cx: &mut AsyncApp,
330 ) -> Result<Option<serde_json::Value>> {
331 let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
332 let json_options: Option<String> = self
333 .extension
334 .language_server_additional_workspace_configuration(
335 self.language_server_id.clone(),
336 target_language_server_id.clone(),
337 delegate,
338 )
339 .await?;
340 Ok(if let Some(json_options) = json_options {
341 serde_json::from_str(&json_options).with_context(|| {
342 format!("failed to parse additional_workspace_configuration from extension: {json_options}")
343 })?
344 } else {
345 None
346 })
347 }
348
349 async fn labels_for_completions(
350 self: Arc<Self>,
351 completions: &[lsp::CompletionItem],
352 language: &Arc<Language>,
353 ) -> Result<Vec<Option<CodeLabel>>> {
354 let completions = completions
355 .iter()
356 .cloned()
357 .map(lsp_completion_to_extension)
358 .collect::<Vec<_>>();
359
360 let labels = self
361 .extension
362 .labels_for_completions(self.language_server_id.clone(), completions)
363 .await?;
364
365 Ok(labels_from_extension(labels, language))
366 }
367
368 async fn labels_for_symbols(
369 self: Arc<Self>,
370 symbols: &[(String, lsp::SymbolKind)],
371 language: &Arc<Language>,
372 ) -> Result<Vec<Option<CodeLabel>>> {
373 let symbols = symbols
374 .iter()
375 .cloned()
376 .map(|(name, kind)| extension::Symbol {
377 name,
378 kind: lsp_symbol_kind_to_extension(kind),
379 })
380 .collect::<Vec<_>>();
381
382 let labels = self
383 .extension
384 .labels_for_symbols(self.language_server_id.clone(), symbols)
385 .await?;
386
387 Ok(labels_from_extension(labels, language))
388 }
389
390 fn is_extension(&self) -> bool {
391 true
392 }
393}
394
395fn labels_from_extension(
396 labels: Vec<Option<extension::CodeLabel>>,
397 language: &Arc<Language>,
398) -> Vec<Option<CodeLabel>> {
399 labels
400 .into_iter()
401 .map(|label| {
402 let label = label?;
403 let runs = if label.code.is_empty() {
404 Vec::new()
405 } else {
406 language.highlight_text(
407 &Rope::from_str_small(label.code.as_str()),
408 0..label.code.len(),
409 )
410 };
411 build_code_label(&label, &runs, language)
412 })
413 .collect()
414}
415
416fn build_code_label(
417 label: &extension::CodeLabel,
418 parsed_runs: &[(Range<usize>, HighlightId)],
419 language: &Arc<Language>,
420) -> Option<CodeLabel> {
421 let mut text = String::new();
422 let mut runs = vec![];
423
424 for span in &label.spans {
425 match span {
426 extension::CodeLabelSpan::CodeRange(range) => {
427 let code_span = &label.code.get(range.clone())?;
428 let mut input_ix = range.start;
429 let mut output_ix = text.len();
430 for (run_range, id) in parsed_runs {
431 if run_range.start >= range.end {
432 break;
433 }
434 if run_range.end <= input_ix {
435 continue;
436 }
437
438 if run_range.start > input_ix {
439 let len = run_range.start - input_ix;
440 output_ix += len;
441 input_ix += len;
442 }
443
444 let len = range.end.min(run_range.end) - input_ix;
445 runs.push((output_ix..output_ix + len, *id));
446 output_ix += len;
447 input_ix += len;
448 }
449
450 text.push_str(code_span);
451 }
452 extension::CodeLabelSpan::Literal(span) => {
453 let highlight_id = language
454 .grammar()
455 .zip(span.highlight_name.as_ref())
456 .and_then(|(grammar, highlight_name)| {
457 grammar.highlight_id_for_name(highlight_name)
458 })
459 .unwrap_or_default();
460 let ix = text.len();
461 runs.push((ix..ix + span.text.len(), highlight_id));
462 text.push_str(&span.text);
463 }
464 }
465 }
466
467 let filter_range = label.filter_range.clone();
468 text.get(filter_range.clone())?;
469 Some(CodeLabel::new(text, filter_range, runs))
470}
471
472fn lsp_completion_to_extension(value: lsp::CompletionItem) -> extension::Completion {
473 extension::Completion {
474 label: value.label,
475 label_details: value
476 .label_details
477 .map(lsp_completion_item_label_details_to_extension),
478 detail: value.detail,
479 kind: value.kind.map(lsp_completion_item_kind_to_extension),
480 insert_text_format: value
481 .insert_text_format
482 .map(lsp_insert_text_format_to_extension),
483 }
484}
485
486fn lsp_completion_item_label_details_to_extension(
487 value: lsp::CompletionItemLabelDetails,
488) -> extension::CompletionLabelDetails {
489 extension::CompletionLabelDetails {
490 detail: value.detail,
491 description: value.description,
492 }
493}
494
495fn lsp_completion_item_kind_to_extension(
496 value: lsp::CompletionItemKind,
497) -> extension::CompletionKind {
498 match value {
499 lsp::CompletionItemKind::TEXT => extension::CompletionKind::Text,
500 lsp::CompletionItemKind::METHOD => extension::CompletionKind::Method,
501 lsp::CompletionItemKind::FUNCTION => extension::CompletionKind::Function,
502 lsp::CompletionItemKind::CONSTRUCTOR => extension::CompletionKind::Constructor,
503 lsp::CompletionItemKind::FIELD => extension::CompletionKind::Field,
504 lsp::CompletionItemKind::VARIABLE => extension::CompletionKind::Variable,
505 lsp::CompletionItemKind::CLASS => extension::CompletionKind::Class,
506 lsp::CompletionItemKind::INTERFACE => extension::CompletionKind::Interface,
507 lsp::CompletionItemKind::MODULE => extension::CompletionKind::Module,
508 lsp::CompletionItemKind::PROPERTY => extension::CompletionKind::Property,
509 lsp::CompletionItemKind::UNIT => extension::CompletionKind::Unit,
510 lsp::CompletionItemKind::VALUE => extension::CompletionKind::Value,
511 lsp::CompletionItemKind::ENUM => extension::CompletionKind::Enum,
512 lsp::CompletionItemKind::KEYWORD => extension::CompletionKind::Keyword,
513 lsp::CompletionItemKind::SNIPPET => extension::CompletionKind::Snippet,
514 lsp::CompletionItemKind::COLOR => extension::CompletionKind::Color,
515 lsp::CompletionItemKind::FILE => extension::CompletionKind::File,
516 lsp::CompletionItemKind::REFERENCE => extension::CompletionKind::Reference,
517 lsp::CompletionItemKind::FOLDER => extension::CompletionKind::Folder,
518 lsp::CompletionItemKind::ENUM_MEMBER => extension::CompletionKind::EnumMember,
519 lsp::CompletionItemKind::CONSTANT => extension::CompletionKind::Constant,
520 lsp::CompletionItemKind::STRUCT => extension::CompletionKind::Struct,
521 lsp::CompletionItemKind::EVENT => extension::CompletionKind::Event,
522 lsp::CompletionItemKind::OPERATOR => extension::CompletionKind::Operator,
523 lsp::CompletionItemKind::TYPE_PARAMETER => extension::CompletionKind::TypeParameter,
524 _ => extension::CompletionKind::Other(extract_int(value)),
525 }
526}
527
528fn lsp_insert_text_format_to_extension(
529 value: lsp::InsertTextFormat,
530) -> extension::InsertTextFormat {
531 match value {
532 lsp::InsertTextFormat::PLAIN_TEXT => extension::InsertTextFormat::PlainText,
533 lsp::InsertTextFormat::SNIPPET => extension::InsertTextFormat::Snippet,
534 _ => extension::InsertTextFormat::Other(extract_int(value)),
535 }
536}
537
538fn lsp_symbol_kind_to_extension(value: lsp::SymbolKind) -> extension::SymbolKind {
539 match value {
540 lsp::SymbolKind::FILE => extension::SymbolKind::File,
541 lsp::SymbolKind::MODULE => extension::SymbolKind::Module,
542 lsp::SymbolKind::NAMESPACE => extension::SymbolKind::Namespace,
543 lsp::SymbolKind::PACKAGE => extension::SymbolKind::Package,
544 lsp::SymbolKind::CLASS => extension::SymbolKind::Class,
545 lsp::SymbolKind::METHOD => extension::SymbolKind::Method,
546 lsp::SymbolKind::PROPERTY => extension::SymbolKind::Property,
547 lsp::SymbolKind::FIELD => extension::SymbolKind::Field,
548 lsp::SymbolKind::CONSTRUCTOR => extension::SymbolKind::Constructor,
549 lsp::SymbolKind::ENUM => extension::SymbolKind::Enum,
550 lsp::SymbolKind::INTERFACE => extension::SymbolKind::Interface,
551 lsp::SymbolKind::FUNCTION => extension::SymbolKind::Function,
552 lsp::SymbolKind::VARIABLE => extension::SymbolKind::Variable,
553 lsp::SymbolKind::CONSTANT => extension::SymbolKind::Constant,
554 lsp::SymbolKind::STRING => extension::SymbolKind::String,
555 lsp::SymbolKind::NUMBER => extension::SymbolKind::Number,
556 lsp::SymbolKind::BOOLEAN => extension::SymbolKind::Boolean,
557 lsp::SymbolKind::ARRAY => extension::SymbolKind::Array,
558 lsp::SymbolKind::OBJECT => extension::SymbolKind::Object,
559 lsp::SymbolKind::KEY => extension::SymbolKind::Key,
560 lsp::SymbolKind::NULL => extension::SymbolKind::Null,
561 lsp::SymbolKind::ENUM_MEMBER => extension::SymbolKind::EnumMember,
562 lsp::SymbolKind::STRUCT => extension::SymbolKind::Struct,
563 lsp::SymbolKind::EVENT => extension::SymbolKind::Event,
564 lsp::SymbolKind::OPERATOR => extension::SymbolKind::Operator,
565 lsp::SymbolKind::TYPE_PARAMETER => extension::SymbolKind::TypeParameter,
566 _ => extension::SymbolKind::Other(extract_int(value)),
567 }
568}
569
570fn extract_int<T: Serialize>(value: T) -> i32 {
571 maybe!({
572 let kind = serde_json::to_value(&value)?;
573 serde_json::from_value(kind)
574 })
575 .log_err()
576 .unwrap_or(-1)
577}
578
579#[test]
580fn test_build_code_label() {
581 use util::test::marked_text_ranges;
582
583 let (code, code_ranges) = marked_text_ranges(
584 "«const» «a»: «fn»(«Bcd»(«Efgh»)) -> «Ijklm» = pqrs.tuv",
585 false,
586 );
587 let code_runs = code_ranges
588 .into_iter()
589 .map(|range| (range, HighlightId(0)))
590 .collect::<Vec<_>>();
591
592 let label = build_code_label(
593 &extension::CodeLabel {
594 spans: vec![
595 extension::CodeLabelSpan::CodeRange(code.find("pqrs").unwrap()..code.len()),
596 extension::CodeLabelSpan::CodeRange(
597 code.find(": fn").unwrap()..code.find(" = ").unwrap(),
598 ),
599 ],
600 filter_range: 0.."pqrs.tuv".len(),
601 code,
602 },
603 &code_runs,
604 &language::PLAIN_TEXT,
605 )
606 .unwrap();
607
608 let (label_text, label_ranges) =
609 marked_text_ranges("pqrs.tuv: «fn»(«Bcd»(«Efgh»)) -> «Ijklm»", false);
610 let label_runs = label_ranges
611 .into_iter()
612 .map(|range| (range, HighlightId(0)))
613 .collect::<Vec<_>>();
614
615 assert_eq!(
616 label,
617 CodeLabel::new(label_text, label.filter_range.clone(), label_runs)
618 )
619}
620
621#[test]
622fn test_build_code_label_with_invalid_ranges() {
623 use util::test::marked_text_ranges;
624
625 let (code, code_ranges) = marked_text_ranges("const «a»: «B» = '🏀'", false);
626 let code_runs = code_ranges
627 .into_iter()
628 .map(|range| (range, HighlightId(0)))
629 .collect::<Vec<_>>();
630
631 // A span uses a code range that is invalid because it starts inside of
632 // a multi-byte character.
633 let label = build_code_label(
634 &extension::CodeLabel {
635 spans: vec![
636 extension::CodeLabelSpan::CodeRange(
637 code.find('B').unwrap()..code.find(" = ").unwrap(),
638 ),
639 extension::CodeLabelSpan::CodeRange((code.find('🏀').unwrap() + 1)..code.len()),
640 ],
641 filter_range: 0.."B".len(),
642 code,
643 },
644 &code_runs,
645 &language::PLAIN_TEXT,
646 );
647 assert!(label.is_none());
648
649 // Filter range extends beyond actual text
650 let label = build_code_label(
651 &extension::CodeLabel {
652 spans: vec![extension::CodeLabelSpan::Literal(
653 extension::CodeLabelSpanLiteral {
654 text: "abc".into(),
655 highlight_name: Some("type".into()),
656 },
657 )],
658 filter_range: 0..5,
659 code: String::new(),
660 },
661 &code_runs,
662 &language::PLAIN_TEXT,
663 );
664 assert!(label.is_none());
665}