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