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