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