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