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