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 self.language_registry
128 .update_lsp_binary_status(language_server_id, status);
129 }
130}
131
132struct ExtensionLspAdapter {
133 extension: Arc<dyn Extension>,
134 language_server_id: LanguageServerName,
135 language_name: LanguageName,
136}
137
138impl ExtensionLspAdapter {
139 fn new(
140 extension: Arc<dyn Extension>,
141 language_server_id: LanguageServerName,
142 language_name: LanguageName,
143 ) -> Self {
144 Self {
145 extension,
146 language_server_id,
147 language_name,
148 }
149 }
150}
151
152#[async_trait(?Send)]
153impl LspAdapter for ExtensionLspAdapter {
154 fn name(&self) -> LanguageServerName {
155 self.language_server_id.clone()
156 }
157
158 fn get_language_server_command<'a>(
159 self: Arc<Self>,
160 delegate: Arc<dyn LspAdapterDelegate>,
161 _: Option<Toolchain>,
162 _: LanguageServerBinaryOptions,
163 _: futures::lock::MutexGuard<'a, Option<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 fetch_latest_server_version(
204 &self,
205 _: &dyn LspAdapterDelegate,
206 _: &AsyncApp,
207 ) -> Result<Box<dyn 'static + Send + Any>> {
208 unreachable!("get_language_server_command is overridden")
209 }
210
211 async fn fetch_server_binary(
212 &self,
213 _: Box<dyn 'static + Send + Any>,
214 _: PathBuf,
215 _: &dyn LspAdapterDelegate,
216 ) -> Result<LanguageServerBinary> {
217 unreachable!("get_language_server_command is overridden")
218 }
219
220 async fn cached_server_binary(
221 &self,
222 _: PathBuf,
223 _: &dyn LspAdapterDelegate,
224 ) -> Option<LanguageServerBinary> {
225 unreachable!("get_language_server_command is overridden")
226 }
227
228 fn code_action_kinds(&self) -> Option<Vec<CodeActionKind>> {
229 let code_action_kinds = self
230 .extension
231 .manifest()
232 .language_servers
233 .get(&self.language_server_id)
234 .and_then(|server| server.code_action_kinds.clone());
235
236 code_action_kinds.or(Some(vec![
237 CodeActionKind::EMPTY,
238 CodeActionKind::QUICKFIX,
239 CodeActionKind::REFACTOR,
240 CodeActionKind::REFACTOR_EXTRACT,
241 CodeActionKind::SOURCE,
242 ]))
243 }
244
245 fn language_ids(&self) -> HashMap<LanguageName, String> {
246 // TODO: The language IDs can be provided via the language server options
247 // in `extension.toml now but we're leaving these existing usages in place temporarily
248 // to avoid any compatibility issues between Zed and the extension versions.
249 //
250 // We can remove once the following extension versions no longer see any use:
251 // - php@0.0.1
252 if self.extension.manifest().id.as_ref() == "php" {
253 return HashMap::from_iter([(LanguageName::new("PHP"), "php".into())]);
254 }
255
256 self.extension
257 .manifest()
258 .language_servers
259 .get(&self.language_server_id)
260 .map(|server| server.language_ids.clone())
261 .unwrap_or_default()
262 }
263
264 async fn initialization_options(
265 self: Arc<Self>,
266 delegate: &Arc<dyn LspAdapterDelegate>,
267 ) -> Result<Option<serde_json::Value>> {
268 let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
269 let json_options = self
270 .extension
271 .language_server_initialization_options(
272 self.language_server_id.clone(),
273 self.language_name.clone(),
274 delegate,
275 )
276 .await?;
277 Ok(if let Some(json_options) = json_options {
278 serde_json::from_str(&json_options).with_context(|| {
279 format!("failed to parse initialization_options from extension: {json_options}")
280 })?
281 } else {
282 None
283 })
284 }
285
286 async fn workspace_configuration(
287 self: Arc<Self>,
288 delegate: &Arc<dyn LspAdapterDelegate>,
289 _: Option<Toolchain>,
290 _cx: &mut AsyncApp,
291 ) -> Result<Value> {
292 let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
293 let json_options: Option<String> = self
294 .extension
295 .language_server_workspace_configuration(self.language_server_id.clone(), delegate)
296 .await?;
297 Ok(if let Some(json_options) = json_options {
298 serde_json::from_str(&json_options).with_context(|| {
299 format!("failed to parse workspace_configuration from extension: {json_options}")
300 })?
301 } else {
302 serde_json::json!({})
303 })
304 }
305
306 async fn additional_initialization_options(
307 self: Arc<Self>,
308 target_language_server_id: LanguageServerName,
309 delegate: &Arc<dyn LspAdapterDelegate>,
310 ) -> Result<Option<serde_json::Value>> {
311 let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
312 let json_options: Option<String> = self
313 .extension
314 .language_server_additional_initialization_options(
315 self.language_server_id.clone(),
316 target_language_server_id.clone(),
317 delegate,
318 )
319 .await?;
320 Ok(if let Some(json_options) = json_options {
321 serde_json::from_str(&json_options).with_context(|| {
322 format!(
323 "failed to parse additional_initialization_options from extension: {json_options}"
324 )
325 })?
326 } else {
327 None
328 })
329 }
330
331 async fn additional_workspace_configuration(
332 self: Arc<Self>,
333 target_language_server_id: LanguageServerName,
334
335 delegate: &Arc<dyn LspAdapterDelegate>,
336
337 _cx: &mut AsyncApp,
338 ) -> Result<Option<serde_json::Value>> {
339 let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
340 let json_options: Option<String> = self
341 .extension
342 .language_server_additional_workspace_configuration(
343 self.language_server_id.clone(),
344 target_language_server_id.clone(),
345 delegate,
346 )
347 .await?;
348 Ok(if let Some(json_options) = json_options {
349 serde_json::from_str(&json_options).with_context(|| {
350 format!("failed to parse additional_workspace_configuration from extension: {json_options}")
351 })?
352 } else {
353 None
354 })
355 }
356
357 async fn labels_for_completions(
358 self: Arc<Self>,
359 completions: &[lsp::CompletionItem],
360 language: &Arc<Language>,
361 ) -> Result<Vec<Option<CodeLabel>>> {
362 let completions = completions
363 .iter()
364 .cloned()
365 .map(lsp_completion_to_extension)
366 .collect::<Vec<_>>();
367
368 let labels = self
369 .extension
370 .labels_for_completions(self.language_server_id.clone(), completions)
371 .await?;
372
373 Ok(labels_from_extension(labels, language))
374 }
375
376 async fn labels_for_symbols(
377 self: Arc<Self>,
378 symbols: &[(String, lsp::SymbolKind)],
379 language: &Arc<Language>,
380 ) -> Result<Vec<Option<CodeLabel>>> {
381 let symbols = symbols
382 .iter()
383 .cloned()
384 .map(|(name, kind)| extension::Symbol {
385 name,
386 kind: lsp_symbol_kind_to_extension(kind),
387 })
388 .collect::<Vec<_>>();
389
390 let labels = self
391 .extension
392 .labels_for_symbols(self.language_server_id.clone(), symbols)
393 .await?;
394
395 Ok(labels_from_extension(labels, language))
396 }
397
398 fn is_extension(&self) -> bool {
399 true
400 }
401}
402
403fn labels_from_extension(
404 labels: Vec<Option<extension::CodeLabel>>,
405 language: &Arc<Language>,
406) -> Vec<Option<CodeLabel>> {
407 labels
408 .into_iter()
409 .map(|label| {
410 let label = label?;
411 let runs = if label.code.is_empty() {
412 Vec::new()
413 } else {
414 language.highlight_text(&label.code.as_str().into(), 0..label.code.len())
415 };
416 build_code_label(&label, &runs, language)
417 })
418 .collect()
419}
420
421fn build_code_label(
422 label: &extension::CodeLabel,
423 parsed_runs: &[(Range<usize>, HighlightId)],
424 language: &Arc<Language>,
425) -> Option<CodeLabel> {
426 let mut text = String::new();
427 let mut runs = vec![];
428
429 for span in &label.spans {
430 match span {
431 extension::CodeLabelSpan::CodeRange(range) => {
432 let code_span = &label.code.get(range.clone())?;
433 let mut input_ix = range.start;
434 let mut output_ix = text.len();
435 for (run_range, id) in parsed_runs {
436 if run_range.start >= range.end {
437 break;
438 }
439 if run_range.end <= input_ix {
440 continue;
441 }
442
443 if run_range.start > input_ix {
444 let len = run_range.start - input_ix;
445 output_ix += len;
446 input_ix += len;
447 }
448
449 let len = range.end.min(run_range.end) - input_ix;
450 runs.push((output_ix..output_ix + len, *id));
451 output_ix += len;
452 input_ix += len;
453 }
454
455 text.push_str(code_span);
456 }
457 extension::CodeLabelSpan::Literal(span) => {
458 let highlight_id = language
459 .grammar()
460 .zip(span.highlight_name.as_ref())
461 .and_then(|(grammar, highlight_name)| {
462 grammar.highlight_id_for_name(highlight_name)
463 })
464 .unwrap_or_default();
465 let ix = text.len();
466 runs.push((ix..ix + span.text.len(), highlight_id));
467 text.push_str(&span.text);
468 }
469 }
470 }
471
472 let filter_range = label.filter_range.clone();
473 text.get(filter_range.clone())?;
474 Some(CodeLabel {
475 text,
476 runs,
477 filter_range,
478 })
479}
480
481fn lsp_completion_to_extension(value: lsp::CompletionItem) -> extension::Completion {
482 extension::Completion {
483 label: value.label,
484 label_details: value
485 .label_details
486 .map(lsp_completion_item_label_details_to_extension),
487 detail: value.detail,
488 kind: value.kind.map(lsp_completion_item_kind_to_extension),
489 insert_text_format: value
490 .insert_text_format
491 .map(lsp_insert_text_format_to_extension),
492 }
493}
494
495fn lsp_completion_item_label_details_to_extension(
496 value: lsp::CompletionItemLabelDetails,
497) -> extension::CompletionLabelDetails {
498 extension::CompletionLabelDetails {
499 detail: value.detail,
500 description: value.description,
501 }
502}
503
504fn lsp_completion_item_kind_to_extension(
505 value: lsp::CompletionItemKind,
506) -> extension::CompletionKind {
507 match value {
508 lsp::CompletionItemKind::TEXT => extension::CompletionKind::Text,
509 lsp::CompletionItemKind::METHOD => extension::CompletionKind::Method,
510 lsp::CompletionItemKind::FUNCTION => extension::CompletionKind::Function,
511 lsp::CompletionItemKind::CONSTRUCTOR => extension::CompletionKind::Constructor,
512 lsp::CompletionItemKind::FIELD => extension::CompletionKind::Field,
513 lsp::CompletionItemKind::VARIABLE => extension::CompletionKind::Variable,
514 lsp::CompletionItemKind::CLASS => extension::CompletionKind::Class,
515 lsp::CompletionItemKind::INTERFACE => extension::CompletionKind::Interface,
516 lsp::CompletionItemKind::MODULE => extension::CompletionKind::Module,
517 lsp::CompletionItemKind::PROPERTY => extension::CompletionKind::Property,
518 lsp::CompletionItemKind::UNIT => extension::CompletionKind::Unit,
519 lsp::CompletionItemKind::VALUE => extension::CompletionKind::Value,
520 lsp::CompletionItemKind::ENUM => extension::CompletionKind::Enum,
521 lsp::CompletionItemKind::KEYWORD => extension::CompletionKind::Keyword,
522 lsp::CompletionItemKind::SNIPPET => extension::CompletionKind::Snippet,
523 lsp::CompletionItemKind::COLOR => extension::CompletionKind::Color,
524 lsp::CompletionItemKind::FILE => extension::CompletionKind::File,
525 lsp::CompletionItemKind::REFERENCE => extension::CompletionKind::Reference,
526 lsp::CompletionItemKind::FOLDER => extension::CompletionKind::Folder,
527 lsp::CompletionItemKind::ENUM_MEMBER => extension::CompletionKind::EnumMember,
528 lsp::CompletionItemKind::CONSTANT => extension::CompletionKind::Constant,
529 lsp::CompletionItemKind::STRUCT => extension::CompletionKind::Struct,
530 lsp::CompletionItemKind::EVENT => extension::CompletionKind::Event,
531 lsp::CompletionItemKind::OPERATOR => extension::CompletionKind::Operator,
532 lsp::CompletionItemKind::TYPE_PARAMETER => extension::CompletionKind::TypeParameter,
533 _ => extension::CompletionKind::Other(extract_int(value)),
534 }
535}
536
537fn lsp_insert_text_format_to_extension(
538 value: lsp::InsertTextFormat,
539) -> extension::InsertTextFormat {
540 match value {
541 lsp::InsertTextFormat::PLAIN_TEXT => extension::InsertTextFormat::PlainText,
542 lsp::InsertTextFormat::SNIPPET => extension::InsertTextFormat::Snippet,
543 _ => extension::InsertTextFormat::Other(extract_int(value)),
544 }
545}
546
547fn lsp_symbol_kind_to_extension(value: lsp::SymbolKind) -> extension::SymbolKind {
548 match value {
549 lsp::SymbolKind::FILE => extension::SymbolKind::File,
550 lsp::SymbolKind::MODULE => extension::SymbolKind::Module,
551 lsp::SymbolKind::NAMESPACE => extension::SymbolKind::Namespace,
552 lsp::SymbolKind::PACKAGE => extension::SymbolKind::Package,
553 lsp::SymbolKind::CLASS => extension::SymbolKind::Class,
554 lsp::SymbolKind::METHOD => extension::SymbolKind::Method,
555 lsp::SymbolKind::PROPERTY => extension::SymbolKind::Property,
556 lsp::SymbolKind::FIELD => extension::SymbolKind::Field,
557 lsp::SymbolKind::CONSTRUCTOR => extension::SymbolKind::Constructor,
558 lsp::SymbolKind::ENUM => extension::SymbolKind::Enum,
559 lsp::SymbolKind::INTERFACE => extension::SymbolKind::Interface,
560 lsp::SymbolKind::FUNCTION => extension::SymbolKind::Function,
561 lsp::SymbolKind::VARIABLE => extension::SymbolKind::Variable,
562 lsp::SymbolKind::CONSTANT => extension::SymbolKind::Constant,
563 lsp::SymbolKind::STRING => extension::SymbolKind::String,
564 lsp::SymbolKind::NUMBER => extension::SymbolKind::Number,
565 lsp::SymbolKind::BOOLEAN => extension::SymbolKind::Boolean,
566 lsp::SymbolKind::ARRAY => extension::SymbolKind::Array,
567 lsp::SymbolKind::OBJECT => extension::SymbolKind::Object,
568 lsp::SymbolKind::KEY => extension::SymbolKind::Key,
569 lsp::SymbolKind::NULL => extension::SymbolKind::Null,
570 lsp::SymbolKind::ENUM_MEMBER => extension::SymbolKind::EnumMember,
571 lsp::SymbolKind::STRUCT => extension::SymbolKind::Struct,
572 lsp::SymbolKind::EVENT => extension::SymbolKind::Event,
573 lsp::SymbolKind::OPERATOR => extension::SymbolKind::Operator,
574 lsp::SymbolKind::TYPE_PARAMETER => extension::SymbolKind::TypeParameter,
575 _ => extension::SymbolKind::Other(extract_int(value)),
576 }
577}
578
579fn extract_int<T: Serialize>(value: T) -> i32 {
580 maybe!({
581 let kind = serde_json::to_value(&value)?;
582 serde_json::from_value(kind)
583 })
584 .log_err()
585 .unwrap_or(-1)
586}
587
588#[test]
589fn test_build_code_label() {
590 use util::test::marked_text_ranges;
591
592 let (code, code_ranges) = marked_text_ranges(
593 "«const» «a»: «fn»(«Bcd»(«Efgh»)) -> «Ijklm» = pqrs.tuv",
594 false,
595 );
596 let code_runs = code_ranges
597 .into_iter()
598 .map(|range| (range, HighlightId(0)))
599 .collect::<Vec<_>>();
600
601 let label = build_code_label(
602 &extension::CodeLabel {
603 spans: vec![
604 extension::CodeLabelSpan::CodeRange(code.find("pqrs").unwrap()..code.len()),
605 extension::CodeLabelSpan::CodeRange(
606 code.find(": fn").unwrap()..code.find(" = ").unwrap(),
607 ),
608 ],
609 filter_range: 0.."pqrs.tuv".len(),
610 code,
611 },
612 &code_runs,
613 &language::PLAIN_TEXT,
614 )
615 .unwrap();
616
617 let (label_text, label_ranges) =
618 marked_text_ranges("pqrs.tuv: «fn»(«Bcd»(«Efgh»)) -> «Ijklm»", false);
619 let label_runs = label_ranges
620 .into_iter()
621 .map(|range| (range, HighlightId(0)))
622 .collect::<Vec<_>>();
623
624 assert_eq!(
625 label,
626 CodeLabel {
627 text: label_text,
628 runs: label_runs,
629 filter_range: label.filter_range.clone()
630 }
631 )
632}
633
634#[test]
635fn test_build_code_label_with_invalid_ranges() {
636 use util::test::marked_text_ranges;
637
638 let (code, code_ranges) = marked_text_ranges("const «a»: «B» = '🏀'", false);
639 let code_runs = code_ranges
640 .into_iter()
641 .map(|range| (range, HighlightId(0)))
642 .collect::<Vec<_>>();
643
644 // A span uses a code range that is invalid because it starts inside of
645 // a multi-byte character.
646 let label = build_code_label(
647 &extension::CodeLabel {
648 spans: vec![
649 extension::CodeLabelSpan::CodeRange(
650 code.find('B').unwrap()..code.find(" = ").unwrap(),
651 ),
652 extension::CodeLabelSpan::CodeRange((code.find('🏀').unwrap() + 1)..code.len()),
653 ],
654 filter_range: 0.."B".len(),
655 code,
656 },
657 &code_runs,
658 &language::PLAIN_TEXT,
659 );
660 assert!(label.is_none());
661
662 // Filter range extends beyond actual text
663 let label = build_code_label(
664 &extension::CodeLabel {
665 spans: vec![extension::CodeLabelSpan::Literal(
666 extension::CodeLabelSpanLiteral {
667 text: "abc".into(),
668 highlight_name: Some("type".into()),
669 },
670 )],
671 filter_range: 0..5,
672 code: String::new(),
673 },
674 &code_runs,
675 &language::PLAIN_TEXT,
676 );
677 assert!(label.is_none());
678}