1use crate::{
2 buffer_store::{BufferStore, BufferStoreEvent},
3 deserialize_code_actions,
4 environment::ProjectEnvironment,
5 lsp_command::{self, *},
6 lsp_ext_command,
7 prettier_store::{self, PrettierStore, PrettierStoreEvent},
8 project_settings::{LspSettings, ProjectSettings},
9 relativize_path, resolve_path,
10 worktree_store::{WorktreeStore, WorktreeStoreEvent},
11 yarn::YarnPathStore,
12 CodeAction, Completion, CoreCompletion, Hover, InlayHint, Item as _, ProjectPath,
13 ProjectTransaction, ResolveState, Symbol,
14};
15use anyhow::{anyhow, Context as _, Result};
16use async_trait::async_trait;
17use client::{proto, TypedEnvelope};
18use collections::{btree_map, BTreeMap, HashMap, HashSet};
19use futures::{
20 future::{join_all, Shared},
21 select,
22 stream::FuturesUnordered,
23 AsyncWriteExt, Future, FutureExt, StreamExt,
24};
25use globset::{Glob, GlobSet, GlobSetBuilder};
26use gpui::{
27 AppContext, AsyncAppContext, Context, Entity, EventEmitter, Model, ModelContext, PromptLevel,
28 Task, WeakModel,
29};
30use http_client::HttpClient;
31use language::{
32 language_settings::{
33 all_language_settings, language_settings, AllLanguageSettings, FormatOnSave, Formatter,
34 LanguageSettings, SelectedFormatter,
35 },
36 markdown, point_to_lsp, prepare_completion_documentation,
37 proto::{deserialize_anchor, deserialize_version, serialize_anchor, serialize_version},
38 range_from_lsp, Bias, Buffer, BufferSnapshot, CachedLspAdapter, CodeLabel, Diagnostic,
39 DiagnosticEntry, DiagnosticSet, Diff, Documentation, File as _, Language, LanguageName,
40 LanguageRegistry, LanguageServerBinaryStatus, LanguageServerName, LocalFile, LspAdapter,
41 LspAdapterDelegate, Patch, PointUtf16, TextBufferSnapshot, ToOffset, ToPointUtf16, Transaction,
42 Unclipped,
43};
44use lsp::{
45 CodeActionKind, CompletionContext, DiagnosticSeverity, DiagnosticTag,
46 DidChangeWatchedFilesRegistrationOptions, Edit, FileSystemWatcher, InsertTextFormat,
47 LanguageServer, LanguageServerBinary, LanguageServerBinaryOptions, LanguageServerId,
48 LspRequestFuture, MessageActionItem, MessageType, OneOf, ServerHealthStatus, ServerStatus,
49 SymbolKind, TextEdit, Url, WorkDoneProgressCancelParams, WorkspaceFolder,
50};
51use node_runtime::read_package_installed_version;
52use parking_lot::{Mutex, RwLock};
53use postage::watch;
54use rand::prelude::*;
55
56use rpc::AnyProtoClient;
57use serde::Serialize;
58use settings::{Settings, SettingsLocation, SettingsStore};
59use sha2::{Digest, Sha256};
60use similar::{ChangeTag, TextDiff};
61use smol::channel::Sender;
62use snippet::Snippet;
63use std::{
64 any::Any,
65 cmp::Ordering,
66 convert::TryInto,
67 ffi::OsStr,
68 iter, mem,
69 ops::{ControlFlow, Range},
70 path::{self, Path, PathBuf},
71 str,
72 sync::Arc,
73 time::{Duration, Instant},
74};
75use text::{Anchor, BufferId, LineEnding, Point, Selection};
76use util::{
77 debug_panic, defer, maybe, merge_json_value_into, post_inc, ResultExt, TryFutureExt as _,
78};
79
80pub use fs::*;
81pub use language::Location;
82#[cfg(any(test, feature = "test-support"))]
83pub use prettier::FORMAT_SUFFIX as TEST_PRETTIER_FORMAT_SUFFIX;
84pub use worktree::{
85 Entry, EntryKind, File, LocalWorktree, PathChange, ProjectEntryId, RepositoryEntry,
86 UpdatedEntriesSet, UpdatedGitRepositoriesSet, Worktree, WorktreeId, WorktreeSettings,
87 FS_WATCH_LATENCY,
88};
89
90const SERVER_LAUNCHING_BEFORE_SHUTDOWN_TIMEOUT: Duration = Duration::from_secs(5);
91pub const SERVER_PROGRESS_THROTTLE_TIMEOUT: Duration = Duration::from_millis(100);
92
93#[derive(Debug, Clone, Copy, PartialEq, Eq)]
94pub enum FormatTrigger {
95 Save,
96 Manual,
97}
98
99pub enum FormatTarget {
100 Buffer,
101 Ranges(Vec<Selection<Point>>),
102}
103
104impl FormatTarget {
105 pub fn as_selections(&self) -> Option<&[Selection<Point>]> {
106 match self {
107 FormatTarget::Buffer => None,
108 FormatTarget::Ranges(selections) => Some(selections.as_slice()),
109 }
110 }
111}
112
113// Currently, formatting operations are represented differently depending on
114// whether they come from a language server or an external command.
115#[derive(Debug)]
116pub enum FormatOperation {
117 Lsp(Vec<(Range<Anchor>, String)>),
118 External(Diff),
119 Prettier(Diff),
120}
121
122impl FormatTrigger {
123 fn from_proto(value: i32) -> FormatTrigger {
124 match value {
125 0 => FormatTrigger::Save,
126 1 => FormatTrigger::Manual,
127 _ => FormatTrigger::Save,
128 }
129 }
130}
131
132pub struct LocalLspStore {
133 http_client: Arc<dyn HttpClient>,
134 environment: Model<ProjectEnvironment>,
135 fs: Arc<dyn Fs>,
136 yarn: Model<YarnPathStore>,
137 pub language_servers: HashMap<LanguageServerId, LanguageServerState>,
138 buffers_being_formatted: HashSet<BufferId>,
139 last_workspace_edits_by_language_server: HashMap<LanguageServerId, ProjectTransaction>,
140 language_server_watched_paths: HashMap<LanguageServerId, Model<LanguageServerWatchedPaths>>,
141 language_server_watcher_registrations:
142 HashMap<LanguageServerId, HashMap<String, Vec<FileSystemWatcher>>>,
143 supplementary_language_servers:
144 HashMap<LanguageServerId, (LanguageServerName, Arc<LanguageServer>)>,
145 prettier_store: Model<PrettierStore>,
146 current_lsp_settings: HashMap<LanguageServerName, LspSettings>,
147 last_formatting_failure: Option<String>,
148 _subscription: gpui::Subscription,
149}
150
151impl LocalLspStore {
152 fn shutdown_language_servers(
153 &mut self,
154 _cx: &mut ModelContext<LspStore>,
155 ) -> impl Future<Output = ()> {
156 let shutdown_futures = self
157 .language_servers
158 .drain()
159 .map(|(_, server_state)| async {
160 use LanguageServerState::*;
161 match server_state {
162 Running { server, .. } => server.shutdown()?.await,
163 Starting(task) => task.await?.shutdown()?.await,
164 }
165 })
166 .collect::<Vec<_>>();
167
168 async move {
169 futures::future::join_all(shutdown_futures).await;
170 }
171 }
172
173 async fn format_locally(
174 lsp_store: WeakModel<LspStore>,
175 mut buffers: Vec<FormattableBuffer>,
176 push_to_history: bool,
177 trigger: FormatTrigger,
178 target: FormatTarget,
179 mut cx: AsyncAppContext,
180 ) -> anyhow::Result<ProjectTransaction> {
181 // Do not allow multiple concurrent formatting requests for the
182 // same buffer.
183 lsp_store.update(&mut cx, |this, cx| {
184 let this = this.as_local_mut().unwrap();
185 buffers.retain(|buffer| {
186 this.buffers_being_formatted
187 .insert(buffer.handle.read(cx).remote_id())
188 });
189 })?;
190
191 let _cleanup = defer({
192 let this = lsp_store.clone();
193 let mut cx = cx.clone();
194 let buffers = &buffers;
195 move || {
196 this.update(&mut cx, |this, cx| {
197 let this = this.as_local_mut().unwrap();
198 for buffer in buffers {
199 this.buffers_being_formatted
200 .remove(&buffer.handle.read(cx).remote_id());
201 }
202 })
203 .ok();
204 }
205 });
206
207 let mut project_transaction = ProjectTransaction::default();
208 for buffer in &buffers {
209 let (primary_adapter_and_server, adapters_and_servers) =
210 lsp_store.update(&mut cx, |lsp_store, cx| {
211 let buffer = buffer.handle.read(cx);
212
213 let adapters_and_servers = lsp_store
214 .language_servers_for_buffer(buffer, cx)
215 .map(|(adapter, lsp)| (adapter.clone(), lsp.clone()))
216 .collect::<Vec<_>>();
217
218 let primary_adapter = lsp_store
219 .primary_language_server_for_buffer(buffer, cx)
220 .map(|(adapter, lsp)| (adapter.clone(), lsp.clone()));
221
222 (primary_adapter, adapters_and_servers)
223 })?;
224
225 let settings = buffer.handle.update(&mut cx, |buffer, cx| {
226 language_settings(buffer.language(), buffer.file(), cx).clone()
227 })?;
228
229 let remove_trailing_whitespace = settings.remove_trailing_whitespace_on_save;
230 let ensure_final_newline = settings.ensure_final_newline_on_save;
231
232 // First, format buffer's whitespace according to the settings.
233 let trailing_whitespace_diff = if remove_trailing_whitespace {
234 Some(
235 buffer
236 .handle
237 .update(&mut cx, |b, cx| b.remove_trailing_whitespace(cx))?
238 .await,
239 )
240 } else {
241 None
242 };
243 let whitespace_transaction_id = buffer.handle.update(&mut cx, |buffer, cx| {
244 buffer.finalize_last_transaction();
245 buffer.start_transaction();
246 if let Some(diff) = trailing_whitespace_diff {
247 buffer.apply_diff(diff, cx);
248 }
249 if ensure_final_newline {
250 buffer.ensure_final_newline(cx);
251 }
252 buffer.end_transaction(cx)
253 })?;
254
255 // Apply the `code_actions_on_format` before we run the formatter.
256 let code_actions = deserialize_code_actions(&settings.code_actions_on_format);
257 #[allow(clippy::nonminimal_bool)]
258 if !code_actions.is_empty()
259 && !(trigger == FormatTrigger::Save && settings.format_on_save == FormatOnSave::Off)
260 {
261 LspStore::execute_code_actions_on_servers(
262 &lsp_store,
263 &adapters_and_servers,
264 code_actions,
265 &buffer.handle,
266 push_to_history,
267 &mut project_transaction,
268 &mut cx,
269 )
270 .await?;
271 }
272
273 // Apply language-specific formatting using either the primary language server
274 // or external command.
275 // Except for code actions, which are applied with all connected language servers.
276 let primary_language_server =
277 primary_adapter_and_server.map(|(_adapter, server)| server.clone());
278 let server_and_buffer = primary_language_server
279 .as_ref()
280 .zip(buffer.abs_path.as_ref());
281
282 let prettier_settings = buffer.handle.read_with(&cx, |buffer, cx| {
283 language_settings(buffer.language(), buffer.file(), cx)
284 .prettier
285 .clone()
286 })?;
287
288 let mut format_operations: Vec<FormatOperation> = vec![];
289 {
290 match trigger {
291 FormatTrigger::Save => {
292 match &settings.format_on_save {
293 FormatOnSave::Off => {
294 // nothing
295 }
296 FormatOnSave::On => {
297 match &settings.formatter {
298 SelectedFormatter::Auto => {
299 // do the auto-format: prefer prettier, fallback to primary language server
300 let diff = {
301 if prettier_settings.allowed {
302 Self::perform_format(
303 &Formatter::Prettier,
304 &target,
305 server_and_buffer,
306 lsp_store.clone(),
307 buffer,
308 &settings,
309 &adapters_and_servers,
310 push_to_history,
311 &mut project_transaction,
312 &mut cx,
313 )
314 .await
315 } else {
316 Self::perform_format(
317 &Formatter::LanguageServer { name: None },
318 &target,
319 server_and_buffer,
320 lsp_store.clone(),
321 buffer,
322 &settings,
323 &adapters_and_servers,
324 push_to_history,
325 &mut project_transaction,
326 &mut cx,
327 )
328 .await
329 }
330 }?;
331
332 if let Some(op) = diff {
333 format_operations.push(op);
334 }
335 }
336 SelectedFormatter::List(formatters) => {
337 for formatter in formatters.as_ref() {
338 let diff = Self::perform_format(
339 formatter,
340 &target,
341 server_and_buffer,
342 lsp_store.clone(),
343 buffer,
344 &settings,
345 &adapters_and_servers,
346 push_to_history,
347 &mut project_transaction,
348 &mut cx,
349 )
350 .await?;
351 if let Some(op) = diff {
352 format_operations.push(op);
353 }
354
355 // format with formatter
356 }
357 }
358 }
359 }
360 FormatOnSave::List(formatters) => {
361 for formatter in formatters.as_ref() {
362 let diff = Self::perform_format(
363 formatter,
364 &target,
365 server_and_buffer,
366 lsp_store.clone(),
367 buffer,
368 &settings,
369 &adapters_and_servers,
370 push_to_history,
371 &mut project_transaction,
372 &mut cx,
373 )
374 .await?;
375 if let Some(op) = diff {
376 format_operations.push(op);
377 }
378 }
379 }
380 }
381 }
382 FormatTrigger::Manual => {
383 match &settings.formatter {
384 SelectedFormatter::Auto => {
385 // do the auto-format: prefer prettier, fallback to primary language server
386 let diff = {
387 if prettier_settings.allowed {
388 Self::perform_format(
389 &Formatter::Prettier,
390 &target,
391 server_and_buffer,
392 lsp_store.clone(),
393 buffer,
394 &settings,
395 &adapters_and_servers,
396 push_to_history,
397 &mut project_transaction,
398 &mut cx,
399 )
400 .await
401 } else {
402 let formatter = Formatter::LanguageServer {
403 name: primary_language_server
404 .as_ref()
405 .map(|server| server.name().to_string()),
406 };
407 Self::perform_format(
408 &formatter,
409 &target,
410 server_and_buffer,
411 lsp_store.clone(),
412 buffer,
413 &settings,
414 &adapters_and_servers,
415 push_to_history,
416 &mut project_transaction,
417 &mut cx,
418 )
419 .await
420 }
421 }?;
422
423 if let Some(op) = diff {
424 format_operations.push(op)
425 }
426 }
427 SelectedFormatter::List(formatters) => {
428 for formatter in formatters.as_ref() {
429 // format with formatter
430 let diff = Self::perform_format(
431 formatter,
432 &target,
433 server_and_buffer,
434 lsp_store.clone(),
435 buffer,
436 &settings,
437 &adapters_and_servers,
438 push_to_history,
439 &mut project_transaction,
440 &mut cx,
441 )
442 .await?;
443 if let Some(op) = diff {
444 format_operations.push(op);
445 }
446 }
447 }
448 }
449 }
450 }
451 }
452
453 buffer.handle.update(&mut cx, |b, cx| {
454 // If the buffer had its whitespace formatted and was edited while the language-specific
455 // formatting was being computed, avoid applying the language-specific formatting, because
456 // it can't be grouped with the whitespace formatting in the undo history.
457 if let Some(transaction_id) = whitespace_transaction_id {
458 if b.peek_undo_stack()
459 .map_or(true, |e| e.transaction_id() != transaction_id)
460 {
461 format_operations.clear();
462 }
463 }
464
465 // Apply any language-specific formatting, and group the two formatting operations
466 // in the buffer's undo history.
467 for operation in format_operations {
468 match operation {
469 FormatOperation::Lsp(edits) => {
470 b.edit(edits, None, cx);
471 }
472 FormatOperation::External(diff) => {
473 b.apply_diff(diff, cx);
474 }
475 FormatOperation::Prettier(diff) => {
476 b.apply_diff(diff, cx);
477 }
478 }
479
480 if let Some(transaction_id) = whitespace_transaction_id {
481 b.group_until_transaction(transaction_id);
482 } else if let Some(transaction) = project_transaction.0.get(&buffer.handle) {
483 b.group_until_transaction(transaction.id)
484 }
485 }
486
487 if let Some(transaction) = b.finalize_last_transaction().cloned() {
488 if !push_to_history {
489 b.forget_transaction(transaction.id);
490 }
491 project_transaction
492 .0
493 .insert(buffer.handle.clone(), transaction);
494 }
495 })?;
496 }
497
498 Ok(project_transaction)
499 }
500
501 #[allow(clippy::too_many_arguments)]
502 async fn perform_format(
503 formatter: &Formatter,
504 format_target: &FormatTarget,
505 primary_server_and_buffer: Option<(&Arc<LanguageServer>, &PathBuf)>,
506 lsp_store: WeakModel<LspStore>,
507 buffer: &FormattableBuffer,
508 settings: &LanguageSettings,
509 adapters_and_servers: &[(Arc<CachedLspAdapter>, Arc<LanguageServer>)],
510 push_to_history: bool,
511 transaction: &mut ProjectTransaction,
512 cx: &mut AsyncAppContext,
513 ) -> Result<Option<FormatOperation>, anyhow::Error> {
514 let result = match formatter {
515 Formatter::LanguageServer { name } => {
516 if let Some((language_server, buffer_abs_path)) = primary_server_and_buffer {
517 let language_server = if let Some(name) = name {
518 adapters_and_servers
519 .iter()
520 .find_map(|(adapter, server)| {
521 adapter.name.0.as_ref().eq(name.as_str()).then_some(server)
522 })
523 .unwrap_or(language_server)
524 } else {
525 language_server
526 };
527
528 match format_target {
529 FormatTarget::Buffer => Some(FormatOperation::Lsp(
530 LspStore::format_via_lsp(
531 &lsp_store,
532 &buffer.handle,
533 buffer_abs_path,
534 language_server,
535 settings,
536 cx,
537 )
538 .await
539 .context("failed to format via language server")?,
540 )),
541 FormatTarget::Ranges(selections) => Some(FormatOperation::Lsp(
542 LspStore::format_range_via_lsp(
543 &lsp_store,
544 &buffer.handle,
545 selections.as_slice(),
546 buffer_abs_path,
547 language_server,
548 settings,
549 cx,
550 )
551 .await
552 .context("failed to format ranges via language server")?,
553 )),
554 }
555 } else {
556 None
557 }
558 }
559 Formatter::Prettier => {
560 let prettier = lsp_store.update(cx, |lsp_store, _cx| {
561 lsp_store.prettier_store().unwrap().downgrade()
562 })?;
563 prettier_store::format_with_prettier(&prettier, &buffer.handle, cx)
564 .await
565 .transpose()
566 .ok()
567 .flatten()
568 }
569 Formatter::External { command, arguments } => {
570 Self::format_via_external_command(buffer, command, arguments.as_deref(), cx)
571 .await
572 .context(format!(
573 "failed to format via external command {:?}",
574 command
575 ))?
576 .map(FormatOperation::External)
577 }
578 Formatter::CodeActions(code_actions) => {
579 let code_actions = deserialize_code_actions(code_actions);
580 if !code_actions.is_empty() {
581 LspStore::execute_code_actions_on_servers(
582 &lsp_store,
583 adapters_and_servers,
584 code_actions,
585 &buffer.handle,
586 push_to_history,
587 transaction,
588 cx,
589 )
590 .await?;
591 }
592 None
593 }
594 };
595 anyhow::Ok(result)
596 }
597
598 async fn format_via_external_command(
599 buffer: &FormattableBuffer,
600 command: &str,
601 arguments: Option<&[String]>,
602 cx: &mut AsyncAppContext,
603 ) -> Result<Option<Diff>> {
604 let working_dir_path = buffer.handle.update(cx, |buffer, cx| {
605 let file = File::from_dyn(buffer.file())?;
606 let worktree = file.worktree.read(cx);
607 let mut worktree_path = worktree.abs_path().to_path_buf();
608 if worktree.root_entry()?.is_file() {
609 worktree_path.pop();
610 }
611 Some(worktree_path)
612 })?;
613
614 let mut child = smol::process::Command::new(command);
615 #[cfg(target_os = "windows")]
616 {
617 use smol::process::windows::CommandExt;
618 child.creation_flags(windows::Win32::System::Threading::CREATE_NO_WINDOW.0);
619 }
620
621 if let Some(buffer_env) = buffer.env.as_ref() {
622 child.envs(buffer_env);
623 }
624
625 if let Some(working_dir_path) = working_dir_path {
626 child.current_dir(working_dir_path);
627 }
628
629 if let Some(arguments) = arguments {
630 child.args(arguments.iter().map(|arg| {
631 if let Some(buffer_abs_path) = buffer.abs_path.as_ref() {
632 arg.replace("{buffer_path}", &buffer_abs_path.to_string_lossy())
633 } else {
634 arg.replace("{buffer_path}", "Untitled")
635 }
636 }));
637 }
638
639 let mut child = child
640 .stdin(smol::process::Stdio::piped())
641 .stdout(smol::process::Stdio::piped())
642 .stderr(smol::process::Stdio::piped())
643 .spawn()?;
644
645 let stdin = child
646 .stdin
647 .as_mut()
648 .ok_or_else(|| anyhow!("failed to acquire stdin"))?;
649 let text = buffer
650 .handle
651 .update(cx, |buffer, _| buffer.as_rope().clone())?;
652 for chunk in text.chunks() {
653 stdin.write_all(chunk.as_bytes()).await?;
654 }
655 stdin.flush().await?;
656
657 let output = child.output().await?;
658 if !output.status.success() {
659 return Err(anyhow!(
660 "command failed with exit code {:?}:\nstdout: {}\nstderr: {}",
661 output.status.code(),
662 String::from_utf8_lossy(&output.stdout),
663 String::from_utf8_lossy(&output.stderr),
664 ));
665 }
666
667 let stdout = String::from_utf8(output.stdout)?;
668 Ok(Some(
669 buffer
670 .handle
671 .update(cx, |buffer, cx| buffer.diff(stdout, cx))?
672 .await,
673 ))
674 }
675}
676
677pub struct FormattableBuffer {
678 handle: Model<Buffer>,
679 abs_path: Option<PathBuf>,
680 env: Option<HashMap<String, String>>,
681}
682
683pub struct RemoteLspStore {
684 upstream_client: Option<AnyProtoClient>,
685 upstream_project_id: u64,
686}
687
688#[allow(clippy::large_enum_variant)]
689pub enum LspStoreMode {
690 Local(LocalLspStore), // ssh host and collab host
691 Remote(RemoteLspStore), // collab guest
692}
693
694impl LspStoreMode {
695 fn is_local(&self) -> bool {
696 matches!(self, LspStoreMode::Local(_))
697 }
698
699 fn is_remote(&self) -> bool {
700 matches!(self, LspStoreMode::Remote(_))
701 }
702}
703
704pub struct LspStore {
705 mode: LspStoreMode,
706 downstream_client: Option<(AnyProtoClient, u64)>,
707 nonce: u128,
708 buffer_store: Model<BufferStore>,
709 worktree_store: Model<WorktreeStore>,
710 buffer_snapshots: HashMap<BufferId, HashMap<LanguageServerId, Vec<LspBufferSnapshot>>>, // buffer_id -> server_id -> vec of snapshots
711 pub languages: Arc<LanguageRegistry>,
712 language_server_ids: HashMap<(WorktreeId, LanguageServerName), LanguageServerId>,
713 pub language_server_statuses: BTreeMap<LanguageServerId, LanguageServerStatus>,
714 active_entry: Option<ProjectEntryId>,
715 _maintain_workspace_config: Task<Result<()>>,
716 _maintain_buffer_languages: Task<()>,
717 next_diagnostic_group_id: usize,
718 diagnostic_summaries:
719 HashMap<WorktreeId, HashMap<Arc<Path>, HashMap<LanguageServerId, DiagnosticSummary>>>,
720 diagnostics: HashMap<
721 WorktreeId,
722 HashMap<
723 Arc<Path>,
724 Vec<(
725 LanguageServerId,
726 Vec<DiagnosticEntry<Unclipped<PointUtf16>>>,
727 )>,
728 >,
729 >,
730}
731
732pub enum LspStoreEvent {
733 LanguageServerAdded(LanguageServerId, LanguageServerName, Option<WorktreeId>),
734 LanguageServerRemoved(LanguageServerId),
735 LanguageServerUpdate {
736 language_server_id: LanguageServerId,
737 message: proto::update_language_server::Variant,
738 },
739 LanguageServerLog(LanguageServerId, LanguageServerLogType, String),
740 LanguageServerPrompt(LanguageServerPromptRequest),
741 LanguageDetected {
742 buffer: Model<Buffer>,
743 new_language: Option<Arc<Language>>,
744 },
745 Notification(String),
746 RefreshInlayHints,
747 DiagnosticsUpdated {
748 language_server_id: LanguageServerId,
749 path: ProjectPath,
750 },
751 DiskBasedDiagnosticsStarted {
752 language_server_id: LanguageServerId,
753 },
754 DiskBasedDiagnosticsFinished {
755 language_server_id: LanguageServerId,
756 },
757 SnippetEdit {
758 buffer_id: BufferId,
759 edits: Vec<(lsp::Range, Snippet)>,
760 most_recent_edit: clock::Lamport,
761 },
762}
763
764#[derive(Clone, Debug, Serialize)]
765pub struct LanguageServerStatus {
766 pub name: String,
767 pub pending_work: BTreeMap<String, LanguageServerProgress>,
768 pub has_pending_diagnostic_updates: bool,
769 progress_tokens: HashSet<String>,
770}
771
772#[derive(Clone, Debug)]
773struct CoreSymbol {
774 pub language_server_name: LanguageServerName,
775 pub source_worktree_id: WorktreeId,
776 pub path: ProjectPath,
777 pub name: String,
778 pub kind: lsp::SymbolKind,
779 pub range: Range<Unclipped<PointUtf16>>,
780 pub signature: [u8; 32],
781}
782
783impl LspStore {
784 pub fn init(client: &AnyProtoClient) {
785 client.add_model_request_handler(Self::handle_multi_lsp_query);
786 client.add_model_request_handler(Self::handle_restart_language_servers);
787 client.add_model_message_handler(Self::handle_start_language_server);
788 client.add_model_message_handler(Self::handle_update_language_server);
789 client.add_model_message_handler(Self::handle_language_server_log);
790 client.add_model_message_handler(Self::handle_update_diagnostic_summary);
791 client.add_model_request_handler(Self::handle_format_buffers);
792 client.add_model_request_handler(Self::handle_resolve_completion_documentation);
793 client.add_model_request_handler(Self::handle_apply_code_action);
794 client.add_model_request_handler(Self::handle_inlay_hints);
795 client.add_model_request_handler(Self::handle_get_project_symbols);
796 client.add_model_request_handler(Self::handle_resolve_inlay_hint);
797 client.add_model_request_handler(Self::handle_open_buffer_for_symbol);
798 client.add_model_request_handler(Self::handle_refresh_inlay_hints);
799 client.add_model_request_handler(Self::handle_on_type_formatting);
800 client.add_model_request_handler(Self::handle_apply_additional_edits_for_completion);
801 client.add_model_request_handler(Self::handle_lsp_command::<GetCodeActions>);
802 client.add_model_request_handler(Self::handle_lsp_command::<GetCompletions>);
803 client.add_model_request_handler(Self::handle_lsp_command::<GetHover>);
804 client.add_model_request_handler(Self::handle_lsp_command::<GetDefinition>);
805 client.add_model_request_handler(Self::handle_lsp_command::<GetDeclaration>);
806 client.add_model_request_handler(Self::handle_lsp_command::<GetTypeDefinition>);
807 client.add_model_request_handler(Self::handle_lsp_command::<GetDocumentHighlights>);
808 client.add_model_request_handler(Self::handle_lsp_command::<GetReferences>);
809 client.add_model_request_handler(Self::handle_lsp_command::<PrepareRename>);
810 client.add_model_request_handler(Self::handle_lsp_command::<PerformRename>);
811 client.add_model_request_handler(Self::handle_lsp_command::<lsp_ext_command::ExpandMacro>);
812 client.add_model_request_handler(Self::handle_lsp_command::<LinkedEditingRange>);
813 }
814
815 pub fn as_remote(&self) -> Option<&RemoteLspStore> {
816 match &self.mode {
817 LspStoreMode::Remote(remote_lsp_store) => Some(remote_lsp_store),
818 _ => None,
819 }
820 }
821
822 pub fn as_local(&self) -> Option<&LocalLspStore> {
823 match &self.mode {
824 LspStoreMode::Local(local_lsp_store) => Some(local_lsp_store),
825 _ => None,
826 }
827 }
828
829 pub fn as_local_mut(&mut self) -> Option<&mut LocalLspStore> {
830 match &mut self.mode {
831 LspStoreMode::Local(local_lsp_store) => Some(local_lsp_store),
832 _ => None,
833 }
834 }
835
836 pub fn upstream_client(&self) -> Option<(AnyProtoClient, u64)> {
837 match &self.mode {
838 LspStoreMode::Remote(RemoteLspStore {
839 upstream_client: Some(upstream_client),
840 upstream_project_id,
841 ..
842 }) => Some((upstream_client.clone(), *upstream_project_id)),
843
844 LspStoreMode::Remote(RemoteLspStore {
845 upstream_client: None,
846 ..
847 }) => None,
848 LspStoreMode::Local(_) => None,
849 }
850 }
851
852 pub fn swap_current_lsp_settings(
853 &mut self,
854 new_settings: HashMap<LanguageServerName, LspSettings>,
855 ) -> Option<HashMap<LanguageServerName, LspSettings>> {
856 match &mut self.mode {
857 LspStoreMode::Local(LocalLspStore {
858 current_lsp_settings,
859 ..
860 }) => {
861 let ret = mem::take(current_lsp_settings);
862 *current_lsp_settings = new_settings;
863 Some(ret)
864 }
865 LspStoreMode::Remote(_) => None,
866 }
867 }
868
869 #[allow(clippy::too_many_arguments)]
870 pub fn new_local(
871 buffer_store: Model<BufferStore>,
872 worktree_store: Model<WorktreeStore>,
873 prettier_store: Model<PrettierStore>,
874 environment: Model<ProjectEnvironment>,
875 languages: Arc<LanguageRegistry>,
876 http_client: Arc<dyn HttpClient>,
877 fs: Arc<dyn Fs>,
878 cx: &mut ModelContext<Self>,
879 ) -> Self {
880 let yarn = YarnPathStore::new(fs.clone(), cx);
881 cx.subscribe(&buffer_store, Self::on_buffer_store_event)
882 .detach();
883 cx.subscribe(&worktree_store, Self::on_worktree_store_event)
884 .detach();
885 cx.subscribe(&prettier_store, Self::on_prettier_store_event)
886 .detach();
887 cx.observe_global::<SettingsStore>(Self::on_settings_changed)
888 .detach();
889
890 Self {
891 mode: LspStoreMode::Local(LocalLspStore {
892 supplementary_language_servers: Default::default(),
893 language_servers: Default::default(),
894 last_workspace_edits_by_language_server: Default::default(),
895 language_server_watched_paths: Default::default(),
896 language_server_watcher_registrations: Default::default(),
897 current_lsp_settings: ProjectSettings::get_global(cx).lsp.clone(),
898 buffers_being_formatted: Default::default(),
899 last_formatting_failure: None,
900 prettier_store,
901 environment,
902 http_client,
903 fs,
904 yarn,
905 _subscription: cx.on_app_quit(|this, cx| {
906 this.as_local_mut().unwrap().shutdown_language_servers(cx)
907 }),
908 }),
909 downstream_client: None,
910 buffer_store,
911 worktree_store,
912 languages: languages.clone(),
913 language_server_ids: Default::default(),
914 language_server_statuses: Default::default(),
915 nonce: StdRng::from_entropy().gen(),
916 buffer_snapshots: Default::default(),
917 next_diagnostic_group_id: Default::default(),
918 diagnostic_summaries: Default::default(),
919 diagnostics: Default::default(),
920 active_entry: None,
921
922 _maintain_workspace_config: Self::maintain_workspace_config(cx),
923 _maintain_buffer_languages: Self::maintain_buffer_languages(languages.clone(), cx),
924 }
925 }
926
927 fn send_lsp_proto_request<R: LspCommand>(
928 &self,
929 buffer: Model<Buffer>,
930 client: AnyProtoClient,
931 upstream_project_id: u64,
932 request: R,
933 cx: &mut ModelContext<'_, LspStore>,
934 ) -> Task<anyhow::Result<<R as LspCommand>::Response>> {
935 let message = request.to_proto(upstream_project_id, buffer.read(cx));
936 cx.spawn(move |this, cx| async move {
937 let response = client.request(message).await?;
938 let this = this.upgrade().context("project dropped")?;
939 request
940 .response_from_proto(response, this, buffer, cx)
941 .await
942 })
943 }
944
945 pub fn new_remote(
946 buffer_store: Model<BufferStore>,
947 worktree_store: Model<WorktreeStore>,
948 languages: Arc<LanguageRegistry>,
949 upstream_client: AnyProtoClient,
950 project_id: u64,
951 cx: &mut ModelContext<Self>,
952 ) -> Self {
953 cx.subscribe(&buffer_store, Self::on_buffer_store_event)
954 .detach();
955 cx.subscribe(&worktree_store, Self::on_worktree_store_event)
956 .detach();
957
958 Self {
959 mode: LspStoreMode::Remote(RemoteLspStore {
960 upstream_client: Some(upstream_client),
961 upstream_project_id: project_id,
962 }),
963 downstream_client: None,
964 buffer_store,
965 worktree_store,
966 languages: languages.clone(),
967 language_server_ids: Default::default(),
968 language_server_statuses: Default::default(),
969 nonce: StdRng::from_entropy().gen(),
970 buffer_snapshots: Default::default(),
971 next_diagnostic_group_id: Default::default(),
972 diagnostic_summaries: Default::default(),
973 diagnostics: Default::default(),
974 active_entry: None,
975 _maintain_workspace_config: Self::maintain_workspace_config(cx),
976 _maintain_buffer_languages: Self::maintain_buffer_languages(languages.clone(), cx),
977 }
978 }
979
980 fn worktree_for_id(
981 &self,
982 worktree_id: WorktreeId,
983 cx: &ModelContext<Self>,
984 ) -> Result<Model<Worktree>> {
985 self.worktree_store
986 .read(cx)
987 .worktree_for_id(worktree_id, cx)
988 .ok_or_else(|| anyhow!("worktree not found"))
989 }
990
991 fn on_buffer_store_event(
992 &mut self,
993 _: Model<BufferStore>,
994 event: &BufferStoreEvent,
995 cx: &mut ModelContext<Self>,
996 ) {
997 match event {
998 BufferStoreEvent::BufferAdded(buffer) => {
999 self.register_buffer(buffer, cx).log_err();
1000 }
1001 BufferStoreEvent::BufferChangedFilePath { buffer, old_file } => {
1002 if let Some(old_file) = File::from_dyn(old_file.as_ref()) {
1003 self.unregister_buffer_from_language_servers(buffer, old_file, cx);
1004 }
1005
1006 self.register_buffer_with_language_servers(buffer, cx);
1007 }
1008 BufferStoreEvent::BufferDropped(_) => {}
1009 }
1010 }
1011
1012 fn on_worktree_store_event(
1013 &mut self,
1014 _: Model<WorktreeStore>,
1015 event: &WorktreeStoreEvent,
1016 cx: &mut ModelContext<Self>,
1017 ) {
1018 match event {
1019 WorktreeStoreEvent::WorktreeAdded(worktree) => {
1020 if !worktree.read(cx).is_local() {
1021 return;
1022 }
1023 cx.subscribe(worktree, |this, worktree, event, cx| match event {
1024 worktree::Event::UpdatedEntries(changes) => {
1025 this.update_local_worktree_language_servers(&worktree, changes, cx);
1026 }
1027 worktree::Event::UpdatedGitRepositories(_)
1028 | worktree::Event::DeletedEntry(_) => {}
1029 })
1030 .detach()
1031 }
1032 WorktreeStoreEvent::WorktreeRemoved(_, id) => self.remove_worktree(*id, cx),
1033 WorktreeStoreEvent::WorktreeOrderChanged => {}
1034 WorktreeStoreEvent::WorktreeUpdateSent(worktree) => {
1035 worktree.update(cx, |worktree, _cx| self.send_diagnostic_summaries(worktree));
1036 }
1037 }
1038 }
1039
1040 fn on_prettier_store_event(
1041 &mut self,
1042 _: Model<PrettierStore>,
1043 event: &PrettierStoreEvent,
1044 cx: &mut ModelContext<Self>,
1045 ) {
1046 match event {
1047 PrettierStoreEvent::LanguageServerRemoved(prettier_server_id) => {
1048 self.unregister_supplementary_language_server(*prettier_server_id, cx);
1049 }
1050 PrettierStoreEvent::LanguageServerAdded {
1051 new_server_id,
1052 name,
1053 prettier_server,
1054 } => {
1055 self.register_supplementary_language_server(
1056 *new_server_id,
1057 name.clone(),
1058 prettier_server.clone(),
1059 cx,
1060 );
1061 }
1062 }
1063 }
1064
1065 // todo!
1066 pub fn prettier_store(&self) -> Option<Model<PrettierStore>> {
1067 self.as_local().map(|local| local.prettier_store.clone())
1068 }
1069
1070 fn on_buffer_event(
1071 &mut self,
1072 buffer: Model<Buffer>,
1073 event: &language::BufferEvent,
1074 cx: &mut ModelContext<Self>,
1075 ) {
1076 match event {
1077 language::BufferEvent::Edited { .. } => {
1078 self.on_buffer_edited(buffer, cx);
1079 }
1080
1081 language::BufferEvent::Saved => {
1082 self.on_buffer_saved(buffer, cx);
1083 }
1084
1085 _ => {}
1086 }
1087 }
1088
1089 fn register_buffer(
1090 &mut self,
1091 buffer: &Model<Buffer>,
1092 cx: &mut ModelContext<Self>,
1093 ) -> Result<()> {
1094 buffer.update(cx, |buffer, _| {
1095 buffer.set_language_registry(self.languages.clone())
1096 });
1097
1098 cx.subscribe(buffer, |this, buffer, event, cx| {
1099 this.on_buffer_event(buffer, event, cx);
1100 })
1101 .detach();
1102
1103 self.register_buffer_with_language_servers(buffer, cx);
1104 cx.observe_release(buffer, |this, buffer, cx| {
1105 if let Some(file) = File::from_dyn(buffer.file()) {
1106 if file.is_local() {
1107 let uri = lsp::Url::from_file_path(file.abs_path(cx)).unwrap();
1108 for server in this.language_servers_for_buffer(buffer, cx) {
1109 server
1110 .1
1111 .notify::<lsp::notification::DidCloseTextDocument>(
1112 lsp::DidCloseTextDocumentParams {
1113 text_document: lsp::TextDocumentIdentifier::new(uri.clone()),
1114 },
1115 )
1116 .log_err();
1117 }
1118 }
1119 }
1120 })
1121 .detach();
1122
1123 Ok(())
1124 }
1125
1126 fn maintain_buffer_languages(
1127 languages: Arc<LanguageRegistry>,
1128 cx: &mut ModelContext<Self>,
1129 ) -> Task<()> {
1130 let mut subscription = languages.subscribe();
1131 let mut prev_reload_count = languages.reload_count();
1132 cx.spawn(move |this, mut cx| async move {
1133 while let Some(()) = subscription.next().await {
1134 if let Some(this) = this.upgrade() {
1135 // If the language registry has been reloaded, then remove and
1136 // re-assign the languages on all open buffers.
1137 let reload_count = languages.reload_count();
1138 if reload_count > prev_reload_count {
1139 prev_reload_count = reload_count;
1140 this.update(&mut cx, |this, cx| {
1141 this.buffer_store.clone().update(cx, |buffer_store, cx| {
1142 for buffer in buffer_store.buffers() {
1143 if let Some(f) = File::from_dyn(buffer.read(cx).file()).cloned()
1144 {
1145 this.unregister_buffer_from_language_servers(
1146 &buffer, &f, cx,
1147 );
1148 buffer
1149 .update(cx, |buffer, cx| buffer.set_language(None, cx));
1150 }
1151 }
1152 });
1153 })
1154 .ok();
1155 }
1156
1157 this.update(&mut cx, |this, cx| {
1158 let mut plain_text_buffers = Vec::new();
1159 let mut buffers_with_unknown_injections = Vec::new();
1160 for handle in this.buffer_store.read(cx).buffers() {
1161 let buffer = handle.read(cx);
1162 if buffer.language().is_none()
1163 || buffer.language() == Some(&*language::PLAIN_TEXT)
1164 {
1165 plain_text_buffers.push(handle);
1166 } else if buffer.contains_unknown_injections() {
1167 buffers_with_unknown_injections.push(handle);
1168 }
1169 }
1170 for buffer in plain_text_buffers {
1171 this.register_buffer_with_language_servers(&buffer, cx);
1172 }
1173
1174 for buffer in buffers_with_unknown_injections {
1175 buffer.update(cx, |buffer, cx| buffer.reparse(cx));
1176 }
1177 })
1178 .ok();
1179 }
1180 }
1181 })
1182 }
1183
1184 fn detect_language_for_buffer(
1185 &mut self,
1186 buffer_handle: &Model<Buffer>,
1187 cx: &mut ModelContext<Self>,
1188 ) -> Option<language::AvailableLanguage> {
1189 // If the buffer has a language, set it and start the language server if we haven't already.
1190 let buffer = buffer_handle.read(cx);
1191 let file = buffer.file()?;
1192
1193 let content = buffer.as_rope();
1194 let available_language = self.languages.language_for_file(file, Some(content), cx);
1195 if let Some(available_language) = &available_language {
1196 if let Some(Ok(Ok(new_language))) = self
1197 .languages
1198 .load_language(available_language)
1199 .now_or_never()
1200 {
1201 self.set_language_for_buffer(buffer_handle, new_language, cx);
1202 }
1203 } else {
1204 cx.emit(LspStoreEvent::LanguageDetected {
1205 buffer: buffer_handle.clone(),
1206 new_language: None,
1207 });
1208 }
1209
1210 available_language
1211 }
1212
1213 pub fn set_language_for_buffer(
1214 &mut self,
1215 buffer: &Model<Buffer>,
1216 new_language: Arc<Language>,
1217 cx: &mut ModelContext<Self>,
1218 ) {
1219 buffer.update(cx, |buffer, cx| {
1220 if buffer.language().map_or(true, |old_language| {
1221 !Arc::ptr_eq(old_language, &new_language)
1222 }) {
1223 buffer.set_language(Some(new_language.clone()), cx);
1224 }
1225 });
1226
1227 let buffer_file = buffer.read(cx).file().cloned();
1228 let settings = language_settings(Some(&new_language), buffer_file.as_ref(), cx).clone();
1229 let buffer_file = File::from_dyn(buffer_file.as_ref());
1230
1231 let worktree_id = if let Some(file) = buffer_file {
1232 let worktree = file.worktree.clone();
1233 self.start_language_servers(&worktree, new_language.name(), cx);
1234
1235 Some(worktree.read(cx).id())
1236 } else {
1237 None
1238 };
1239
1240 if settings.prettier.allowed {
1241 if let Some(prettier_plugins) = prettier_store::prettier_plugins_for_language(&settings)
1242 {
1243 let prettier_store = self.as_local().map(|s| s.prettier_store.clone());
1244 if let Some(prettier_store) = prettier_store {
1245 prettier_store.update(cx, |prettier_store, cx| {
1246 prettier_store.install_default_prettier(
1247 worktree_id,
1248 prettier_plugins.iter().map(|s| Arc::from(s.as_str())),
1249 cx,
1250 )
1251 })
1252 }
1253 }
1254 }
1255
1256 cx.emit(LspStoreEvent::LanguageDetected {
1257 buffer: buffer.clone(),
1258 new_language: Some(new_language),
1259 })
1260 }
1261
1262 pub fn buffer_store(&self) -> Model<BufferStore> {
1263 self.buffer_store.clone()
1264 }
1265
1266 pub fn set_active_entry(&mut self, active_entry: Option<ProjectEntryId>) {
1267 self.active_entry = active_entry;
1268 }
1269
1270 pub(crate) fn send_diagnostic_summaries(&self, worktree: &mut Worktree) {
1271 if let Some((client, downstream_project_id)) = self.downstream_client.clone() {
1272 if let Some(summaries) = self.diagnostic_summaries.get(&worktree.id()) {
1273 for (path, summaries) in summaries {
1274 for (&server_id, summary) in summaries {
1275 client
1276 .send(proto::UpdateDiagnosticSummary {
1277 project_id: downstream_project_id,
1278 worktree_id: worktree.id().to_proto(),
1279 summary: Some(summary.to_proto(server_id, path)),
1280 })
1281 .log_err();
1282 }
1283 }
1284 }
1285 }
1286 }
1287
1288 pub fn request_lsp<R: LspCommand>(
1289 &self,
1290 buffer_handle: Model<Buffer>,
1291 server: LanguageServerToQuery,
1292 request: R,
1293 cx: &mut ModelContext<Self>,
1294 ) -> Task<Result<R::Response>>
1295 where
1296 <R::LspRequest as lsp::request::Request>::Result: Send,
1297 <R::LspRequest as lsp::request::Request>::Params: Send,
1298 {
1299 let buffer = buffer_handle.read(cx);
1300
1301 if let Some((upstream_client, upstream_project_id)) = self.upstream_client() {
1302 return self.send_lsp_proto_request(
1303 buffer_handle,
1304 upstream_client,
1305 upstream_project_id,
1306 request,
1307 cx,
1308 );
1309 }
1310
1311 let language_server = match server {
1312 LanguageServerToQuery::Primary => {
1313 match self.primary_language_server_for_buffer(buffer, cx) {
1314 Some((_, server)) => Some(Arc::clone(server)),
1315 None => return Task::ready(Ok(Default::default())),
1316 }
1317 }
1318 LanguageServerToQuery::Other(id) => self
1319 .language_server_for_buffer(buffer, id, cx)
1320 .map(|(_, server)| Arc::clone(server)),
1321 };
1322 let file = File::from_dyn(buffer.file()).and_then(File::as_local);
1323 if let (Some(file), Some(language_server)) = (file, language_server) {
1324 let lsp_params = request.to_lsp(&file.abs_path(cx), buffer, &language_server, cx);
1325 let status = request.status();
1326 return cx.spawn(move |this, cx| async move {
1327 if !request.check_capabilities(language_server.adapter_server_capabilities()) {
1328 return Ok(Default::default());
1329 }
1330
1331 let lsp_request = language_server.request::<R::LspRequest>(lsp_params);
1332
1333 let id = lsp_request.id();
1334 let _cleanup = if status.is_some() {
1335 cx.update(|cx| {
1336 this.update(cx, |this, cx| {
1337 this.on_lsp_work_start(
1338 language_server.server_id(),
1339 id.to_string(),
1340 LanguageServerProgress {
1341 is_disk_based_diagnostics_progress: false,
1342 is_cancellable: false,
1343 title: None,
1344 message: status.clone(),
1345 percentage: None,
1346 last_update_at: cx.background_executor().now(),
1347 },
1348 cx,
1349 );
1350 })
1351 })
1352 .log_err();
1353
1354 Some(defer(|| {
1355 cx.update(|cx| {
1356 this.update(cx, |this, cx| {
1357 this.on_lsp_work_end(
1358 language_server.server_id(),
1359 id.to_string(),
1360 cx,
1361 );
1362 })
1363 })
1364 .log_err();
1365 }))
1366 } else {
1367 None
1368 };
1369
1370 let result = lsp_request.await;
1371
1372 let response = result.map_err(|err| {
1373 log::warn!(
1374 "Generic lsp request to {} failed: {}",
1375 language_server.name(),
1376 err
1377 );
1378 err
1379 })?;
1380
1381 request
1382 .response_from_lsp(
1383 response,
1384 this.upgrade().ok_or_else(|| anyhow!("no app context"))?,
1385 buffer_handle,
1386 language_server.server_id(),
1387 cx.clone(),
1388 )
1389 .await
1390 });
1391 }
1392
1393 Task::ready(Ok(Default::default()))
1394 }
1395
1396 fn on_settings_changed(&mut self, cx: &mut ModelContext<Self>) {
1397 let mut language_servers_to_start = Vec::new();
1398 let mut language_formatters_to_check = Vec::new();
1399 for buffer in self.buffer_store.read(cx).buffers() {
1400 let buffer = buffer.read(cx);
1401 let buffer_file = File::from_dyn(buffer.file());
1402 let buffer_language = buffer.language();
1403 let settings = language_settings(buffer_language, buffer.file(), cx);
1404 if let Some(language) = buffer_language {
1405 if settings.enable_language_server {
1406 if let Some(file) = buffer_file {
1407 language_servers_to_start.push((file.worktree.clone(), language.name()));
1408 }
1409 }
1410 language_formatters_to_check
1411 .push((buffer_file.map(|f| f.worktree_id(cx)), settings.clone()));
1412 }
1413 }
1414
1415 let mut language_servers_to_stop = Vec::new();
1416 let mut language_servers_to_restart = Vec::new();
1417 let languages = self.languages.to_vec();
1418
1419 let new_lsp_settings = ProjectSettings::get_global(cx).lsp.clone();
1420 let Some(current_lsp_settings) = self.swap_current_lsp_settings(new_lsp_settings.clone())
1421 else {
1422 return;
1423 };
1424 for (worktree_id, started_lsp_name) in self.started_language_servers() {
1425 let language = languages.iter().find_map(|l| {
1426 let adapter = self
1427 .languages
1428 .lsp_adapters(&l.name())
1429 .iter()
1430 .find(|adapter| adapter.name == started_lsp_name)?
1431 .clone();
1432 Some((l, adapter))
1433 });
1434 if let Some((language, adapter)) = language {
1435 let worktree = self.worktree_for_id(worktree_id, cx).ok();
1436 let file = worktree.as_ref().and_then(|tree| {
1437 tree.update(cx, |tree, cx| tree.root_file(cx).map(|f| f as _))
1438 });
1439 if !language_settings(Some(language), file.as_ref(), cx).enable_language_server {
1440 language_servers_to_stop.push((worktree_id, started_lsp_name.clone()));
1441 } else if let Some(worktree) = worktree {
1442 let server_name = &adapter.name;
1443 match (
1444 current_lsp_settings.get(server_name),
1445 new_lsp_settings.get(server_name),
1446 ) {
1447 (None, None) => {}
1448 (Some(_), None) | (None, Some(_)) => {
1449 language_servers_to_restart.push((worktree, language.name()));
1450 }
1451 (Some(current_lsp_settings), Some(new_lsp_settings)) => {
1452 if current_lsp_settings != new_lsp_settings {
1453 language_servers_to_restart.push((worktree, language.name()));
1454 }
1455 }
1456 }
1457 }
1458 }
1459 }
1460
1461 for (worktree_id, adapter_name) in language_servers_to_stop {
1462 self.stop_local_language_server(worktree_id, adapter_name, cx)
1463 .detach();
1464 }
1465
1466 if let Some(prettier_store) = self.as_local().map(|s| s.prettier_store.clone()) {
1467 prettier_store.update(cx, |prettier_store, cx| {
1468 prettier_store.on_settings_changed(language_formatters_to_check, cx)
1469 })
1470 }
1471
1472 // Start all the newly-enabled language servers.
1473 for (worktree, language) in language_servers_to_start {
1474 self.start_language_servers(&worktree, language, cx);
1475 }
1476
1477 // Restart all language servers with changed initialization options.
1478 for (worktree, language) in language_servers_to_restart {
1479 self.restart_local_language_servers(worktree, language, cx);
1480 }
1481
1482 cx.notify();
1483 }
1484
1485 pub async fn execute_code_actions_on_servers(
1486 this: &WeakModel<LspStore>,
1487 adapters_and_servers: &[(Arc<CachedLspAdapter>, Arc<LanguageServer>)],
1488 code_actions: Vec<lsp::CodeActionKind>,
1489 buffer: &Model<Buffer>,
1490 push_to_history: bool,
1491 project_transaction: &mut ProjectTransaction,
1492 cx: &mut AsyncAppContext,
1493 ) -> Result<(), anyhow::Error> {
1494 for (lsp_adapter, language_server) in adapters_and_servers.iter() {
1495 let code_actions = code_actions.clone();
1496
1497 let actions = this
1498 .update(cx, move |this, cx| {
1499 let request = GetCodeActions {
1500 range: text::Anchor::MIN..text::Anchor::MAX,
1501 kinds: Some(code_actions),
1502 };
1503 let server = LanguageServerToQuery::Other(language_server.server_id());
1504 this.request_lsp(buffer.clone(), server, request, cx)
1505 })?
1506 .await?;
1507
1508 for mut action in actions {
1509 Self::try_resolve_code_action(language_server, &mut action)
1510 .await
1511 .context("resolving a formatting code action")?;
1512
1513 if let Some(edit) = action.lsp_action.edit {
1514 if edit.changes.is_none() && edit.document_changes.is_none() {
1515 continue;
1516 }
1517
1518 let new = Self::deserialize_workspace_edit(
1519 this.upgrade().ok_or_else(|| anyhow!("project dropped"))?,
1520 edit,
1521 push_to_history,
1522 lsp_adapter.clone(),
1523 language_server.clone(),
1524 cx,
1525 )
1526 .await?;
1527 project_transaction.0.extend(new.0);
1528 }
1529
1530 if let Some(command) = action.lsp_action.command {
1531 this.update(cx, |this, _| {
1532 if let LspStoreMode::Local(mode) = &mut this.mode {
1533 mode.last_workspace_edits_by_language_server
1534 .remove(&language_server.server_id());
1535 }
1536 })?;
1537
1538 language_server
1539 .request::<lsp::request::ExecuteCommand>(lsp::ExecuteCommandParams {
1540 command: command.command,
1541 arguments: command.arguments.unwrap_or_default(),
1542 ..Default::default()
1543 })
1544 .await?;
1545
1546 this.update(cx, |this, _| {
1547 if let LspStoreMode::Local(mode) = &mut this.mode {
1548 project_transaction.0.extend(
1549 mode.last_workspace_edits_by_language_server
1550 .remove(&language_server.server_id())
1551 .unwrap_or_default()
1552 .0,
1553 )
1554 }
1555 })?;
1556 }
1557 }
1558 }
1559
1560 Ok(())
1561 }
1562
1563 async fn try_resolve_code_action(
1564 lang_server: &LanguageServer,
1565 action: &mut CodeAction,
1566 ) -> anyhow::Result<()> {
1567 if GetCodeActions::can_resolve_actions(&lang_server.capabilities())
1568 && action.lsp_action.data.is_some()
1569 && (action.lsp_action.command.is_none() || action.lsp_action.edit.is_none())
1570 {
1571 action.lsp_action = lang_server
1572 .request::<lsp::request::CodeActionResolveRequest>(action.lsp_action.clone())
1573 .await?;
1574 }
1575
1576 anyhow::Ok(())
1577 }
1578
1579 pub fn apply_code_action(
1580 &self,
1581 buffer_handle: Model<Buffer>,
1582 mut action: CodeAction,
1583 push_to_history: bool,
1584 cx: &mut ModelContext<Self>,
1585 ) -> Task<Result<ProjectTransaction>> {
1586 if let Some((upstream_client, project_id)) = self.upstream_client() {
1587 let request = proto::ApplyCodeAction {
1588 project_id,
1589 buffer_id: buffer_handle.read(cx).remote_id().into(),
1590 action: Some(Self::serialize_code_action(&action)),
1591 };
1592 let buffer_store = self.buffer_store();
1593 cx.spawn(move |_, mut cx| async move {
1594 let response = upstream_client
1595 .request(request)
1596 .await?
1597 .transaction
1598 .ok_or_else(|| anyhow!("missing transaction"))?;
1599
1600 buffer_store
1601 .update(&mut cx, |buffer_store, cx| {
1602 buffer_store.deserialize_project_transaction(response, push_to_history, cx)
1603 })?
1604 .await
1605 })
1606 } else {
1607 let buffer = buffer_handle.read(cx);
1608 let (lsp_adapter, lang_server) = if let Some((adapter, server)) =
1609 self.language_server_for_buffer(buffer, action.server_id, cx)
1610 {
1611 (adapter.clone(), server.clone())
1612 } else {
1613 return Task::ready(Ok(Default::default()));
1614 };
1615 cx.spawn(move |this, mut cx| async move {
1616 Self::try_resolve_code_action(&lang_server, &mut action)
1617 .await
1618 .context("resolving a code action")?;
1619 if let Some(edit) = action.lsp_action.edit {
1620 if edit.changes.is_some() || edit.document_changes.is_some() {
1621 return Self::deserialize_workspace_edit(
1622 this.upgrade().ok_or_else(|| anyhow!("no app present"))?,
1623 edit,
1624 push_to_history,
1625 lsp_adapter.clone(),
1626 lang_server.clone(),
1627 &mut cx,
1628 )
1629 .await;
1630 }
1631 }
1632
1633 if let Some(command) = action.lsp_action.command {
1634 this.update(&mut cx, |this, _| {
1635 this.as_local_mut()
1636 .unwrap()
1637 .last_workspace_edits_by_language_server
1638 .remove(&lang_server.server_id());
1639 })?;
1640
1641 let result = lang_server
1642 .request::<lsp::request::ExecuteCommand>(lsp::ExecuteCommandParams {
1643 command: command.command,
1644 arguments: command.arguments.unwrap_or_default(),
1645 ..Default::default()
1646 })
1647 .await;
1648
1649 result?;
1650
1651 return this.update(&mut cx, |this, _| {
1652 this.as_local_mut()
1653 .unwrap()
1654 .last_workspace_edits_by_language_server
1655 .remove(&lang_server.server_id())
1656 .unwrap_or_default()
1657 });
1658 }
1659
1660 Ok(ProjectTransaction::default())
1661 })
1662 }
1663 }
1664
1665 pub fn resolve_inlay_hint(
1666 &self,
1667 hint: InlayHint,
1668 buffer_handle: Model<Buffer>,
1669 server_id: LanguageServerId,
1670 cx: &mut ModelContext<Self>,
1671 ) -> Task<anyhow::Result<InlayHint>> {
1672 if let Some((upstream_client, project_id)) = self.upstream_client() {
1673 let request = proto::ResolveInlayHint {
1674 project_id,
1675 buffer_id: buffer_handle.read(cx).remote_id().into(),
1676 language_server_id: server_id.0 as u64,
1677 hint: Some(InlayHints::project_to_proto_hint(hint.clone())),
1678 };
1679 cx.spawn(move |_, _| async move {
1680 let response = upstream_client
1681 .request(request)
1682 .await
1683 .context("inlay hints proto request")?;
1684 match response.hint {
1685 Some(resolved_hint) => InlayHints::proto_to_project_hint(resolved_hint)
1686 .context("inlay hints proto resolve response conversion"),
1687 None => Ok(hint),
1688 }
1689 })
1690 } else {
1691 let buffer = buffer_handle.read(cx);
1692 let (_, lang_server) = if let Some((adapter, server)) =
1693 self.language_server_for_buffer(buffer, server_id, cx)
1694 {
1695 (adapter.clone(), server.clone())
1696 } else {
1697 return Task::ready(Ok(hint));
1698 };
1699 if !InlayHints::can_resolve_inlays(&lang_server.capabilities()) {
1700 return Task::ready(Ok(hint));
1701 }
1702
1703 let buffer_snapshot = buffer.snapshot();
1704 cx.spawn(move |_, mut cx| async move {
1705 let resolve_task = lang_server.request::<lsp::request::InlayHintResolveRequest>(
1706 InlayHints::project_to_lsp_hint(hint, &buffer_snapshot),
1707 );
1708 let resolved_hint = resolve_task
1709 .await
1710 .context("inlay hint resolve LSP request")?;
1711 let resolved_hint = InlayHints::lsp_to_project_hint(
1712 resolved_hint,
1713 &buffer_handle,
1714 server_id,
1715 ResolveState::Resolved,
1716 false,
1717 &mut cx,
1718 )
1719 .await?;
1720 Ok(resolved_hint)
1721 })
1722 }
1723 }
1724
1725 pub(crate) fn linked_edit(
1726 &self,
1727 buffer: &Model<Buffer>,
1728 position: Anchor,
1729 cx: &mut ModelContext<Self>,
1730 ) -> Task<Result<Vec<Range<Anchor>>>> {
1731 let snapshot = buffer.read(cx).snapshot();
1732 let scope = snapshot.language_scope_at(position);
1733 let Some(server_id) = self
1734 .language_servers_for_buffer(buffer.read(cx), cx)
1735 .filter(|(_, server)| {
1736 server
1737 .capabilities()
1738 .linked_editing_range_provider
1739 .is_some()
1740 })
1741 .filter(|(adapter, _)| {
1742 scope
1743 .as_ref()
1744 .map(|scope| scope.language_allowed(&adapter.name))
1745 .unwrap_or(true)
1746 })
1747 .map(|(_, server)| LanguageServerToQuery::Other(server.server_id()))
1748 .next()
1749 .or_else(|| {
1750 self.upstream_client()
1751 .is_some()
1752 .then_some(LanguageServerToQuery::Primary)
1753 })
1754 .filter(|_| {
1755 maybe!({
1756 let language_name = buffer.read(cx).language_at(position)?.name();
1757 Some(
1758 AllLanguageSettings::get_global(cx)
1759 .language(Some(&language_name))
1760 .linked_edits,
1761 )
1762 }) == Some(true)
1763 })
1764 else {
1765 return Task::ready(Ok(vec![]));
1766 };
1767
1768 self.request_lsp(
1769 buffer.clone(),
1770 server_id,
1771 LinkedEditingRange { position },
1772 cx,
1773 )
1774 }
1775
1776 fn apply_on_type_formatting(
1777 &mut self,
1778 buffer: Model<Buffer>,
1779 position: Anchor,
1780 trigger: String,
1781 cx: &mut ModelContext<Self>,
1782 ) -> Task<Result<Option<Transaction>>> {
1783 if let Some((client, project_id)) = self.upstream_client() {
1784 let request = proto::OnTypeFormatting {
1785 project_id,
1786 buffer_id: buffer.read(cx).remote_id().into(),
1787 position: Some(serialize_anchor(&position)),
1788 trigger,
1789 version: serialize_version(&buffer.read(cx).version()),
1790 };
1791 cx.spawn(move |_, _| async move {
1792 client
1793 .request(request)
1794 .await?
1795 .transaction
1796 .map(language::proto::deserialize_transaction)
1797 .transpose()
1798 })
1799 } else if let Some(local) = self.as_local_mut() {
1800 let buffer_id = buffer.read(cx).remote_id();
1801 local.buffers_being_formatted.insert(buffer_id);
1802 cx.spawn(move |this, mut cx| async move {
1803 let _cleanup = defer({
1804 let this = this.clone();
1805 let mut cx = cx.clone();
1806 move || {
1807 this.update(&mut cx, |this, _| {
1808 if let Some(local) = this.as_local_mut() {
1809 local.buffers_being_formatted.remove(&buffer_id);
1810 }
1811 })
1812 .ok();
1813 }
1814 });
1815
1816 buffer
1817 .update(&mut cx, |buffer, _| {
1818 buffer.wait_for_edits(Some(position.timestamp))
1819 })?
1820 .await?;
1821 this.update(&mut cx, |this, cx| {
1822 let position = position.to_point_utf16(buffer.read(cx));
1823 this.on_type_format(buffer, position, trigger, false, cx)
1824 })?
1825 .await
1826 })
1827 } else {
1828 Task::ready(Err(anyhow!("No upstream client or local language server")))
1829 }
1830 }
1831
1832 pub fn on_type_format<T: ToPointUtf16>(
1833 &mut self,
1834 buffer: Model<Buffer>,
1835 position: T,
1836 trigger: String,
1837 push_to_history: bool,
1838 cx: &mut ModelContext<Self>,
1839 ) -> Task<Result<Option<Transaction>>> {
1840 let position = position.to_point_utf16(buffer.read(cx));
1841 self.on_type_format_impl(buffer, position, trigger, push_to_history, cx)
1842 }
1843
1844 fn on_type_format_impl(
1845 &mut self,
1846 buffer: Model<Buffer>,
1847 position: PointUtf16,
1848 trigger: String,
1849 push_to_history: bool,
1850 cx: &mut ModelContext<Self>,
1851 ) -> Task<Result<Option<Transaction>>> {
1852 let options = buffer.update(cx, |buffer, cx| {
1853 lsp_command::lsp_formatting_options(language_settings(
1854 buffer.language_at(position).as_ref(),
1855 buffer.file(),
1856 cx,
1857 ))
1858 });
1859 self.request_lsp(
1860 buffer.clone(),
1861 LanguageServerToQuery::Primary,
1862 OnTypeFormatting {
1863 position,
1864 trigger,
1865 options,
1866 push_to_history,
1867 },
1868 cx,
1869 )
1870 }
1871
1872 pub async fn format_via_lsp(
1873 this: &WeakModel<Self>,
1874 buffer: &Model<Buffer>,
1875 abs_path: &Path,
1876 language_server: &Arc<LanguageServer>,
1877 settings: &LanguageSettings,
1878 cx: &mut AsyncAppContext,
1879 ) -> Result<Vec<(Range<Anchor>, String)>> {
1880 let uri = lsp::Url::from_file_path(abs_path)
1881 .map_err(|_| anyhow!("failed to convert abs path to uri"))?;
1882 let text_document = lsp::TextDocumentIdentifier::new(uri);
1883 let capabilities = &language_server.capabilities();
1884
1885 let formatting_provider = capabilities.document_formatting_provider.as_ref();
1886 let range_formatting_provider = capabilities.document_range_formatting_provider.as_ref();
1887
1888 let lsp_edits = if matches!(formatting_provider, Some(p) if *p != OneOf::Left(false)) {
1889 language_server
1890 .request::<lsp::request::Formatting>(lsp::DocumentFormattingParams {
1891 text_document,
1892 options: lsp_command::lsp_formatting_options(settings),
1893 work_done_progress_params: Default::default(),
1894 })
1895 .await?
1896 } else if matches!(range_formatting_provider, Some(p) if *p != OneOf::Left(false)) {
1897 let buffer_start = lsp::Position::new(0, 0);
1898 let buffer_end = buffer.update(cx, |b, _| point_to_lsp(b.max_point_utf16()))?;
1899 language_server
1900 .request::<lsp::request::RangeFormatting>(lsp::DocumentRangeFormattingParams {
1901 text_document: text_document.clone(),
1902 range: lsp::Range::new(buffer_start, buffer_end),
1903 options: lsp_command::lsp_formatting_options(settings),
1904 work_done_progress_params: Default::default(),
1905 })
1906 .await?
1907 } else {
1908 None
1909 };
1910
1911 if let Some(lsp_edits) = lsp_edits {
1912 this.update(cx, |this, cx| {
1913 this.edits_from_lsp(buffer, lsp_edits, language_server.server_id(), None, cx)
1914 })?
1915 .await
1916 } else {
1917 Ok(Vec::with_capacity(0))
1918 }
1919 }
1920 pub async fn format_range_via_lsp(
1921 this: &WeakModel<Self>,
1922 buffer: &Model<Buffer>,
1923 selections: &[Selection<Point>],
1924 abs_path: &Path,
1925 language_server: &Arc<LanguageServer>,
1926 settings: &LanguageSettings,
1927 cx: &mut AsyncAppContext,
1928 ) -> Result<Vec<(Range<Anchor>, String)>> {
1929 let capabilities = &language_server.capabilities();
1930 let range_formatting_provider = capabilities.document_range_formatting_provider.as_ref();
1931 if range_formatting_provider.map_or(false, |provider| provider == &OneOf::Left(false)) {
1932 return Err(anyhow!(
1933 "{} language server does not support range formatting",
1934 language_server.name()
1935 ));
1936 }
1937
1938 let uri = lsp::Url::from_file_path(abs_path)
1939 .map_err(|_| anyhow!("failed to convert abs path to uri"))?;
1940 let text_document = lsp::TextDocumentIdentifier::new(uri);
1941
1942 let lsp_edits = {
1943 let ranges = selections.into_iter().map(|s| {
1944 let start = lsp::Position::new(s.start.row, s.start.column);
1945 let end = lsp::Position::new(s.end.row, s.end.column);
1946 lsp::Range::new(start, end)
1947 });
1948
1949 let mut edits = None;
1950 for range in ranges {
1951 if let Some(mut edit) = language_server
1952 .request::<lsp::request::RangeFormatting>(lsp::DocumentRangeFormattingParams {
1953 text_document: text_document.clone(),
1954 range,
1955 options: lsp_command::lsp_formatting_options(settings),
1956 work_done_progress_params: Default::default(),
1957 })
1958 .await?
1959 {
1960 edits.get_or_insert_with(Vec::new).append(&mut edit);
1961 }
1962 }
1963 edits
1964 };
1965
1966 if let Some(lsp_edits) = lsp_edits {
1967 this.update(cx, |this, cx| {
1968 this.edits_from_lsp(buffer, lsp_edits, language_server.server_id(), None, cx)
1969 })?
1970 .await
1971 } else {
1972 Ok(Vec::with_capacity(0))
1973 }
1974 }
1975
1976 pub fn code_actions(
1977 &mut self,
1978 buffer_handle: &Model<Buffer>,
1979 range: Range<Anchor>,
1980 cx: &mut ModelContext<Self>,
1981 ) -> Task<Result<Vec<CodeAction>>> {
1982 if let Some((upstream_client, project_id)) = self.upstream_client() {
1983 let request_task = upstream_client.request(proto::MultiLspQuery {
1984 buffer_id: buffer_handle.read(cx).remote_id().into(),
1985 version: serialize_version(&buffer_handle.read(cx).version()),
1986 project_id,
1987 strategy: Some(proto::multi_lsp_query::Strategy::All(
1988 proto::AllLanguageServers {},
1989 )),
1990 request: Some(proto::multi_lsp_query::Request::GetCodeActions(
1991 GetCodeActions {
1992 range: range.clone(),
1993 kinds: None,
1994 }
1995 .to_proto(project_id, buffer_handle.read(cx)),
1996 )),
1997 });
1998 let buffer = buffer_handle.clone();
1999 cx.spawn(|weak_project, cx| async move {
2000 let Some(project) = weak_project.upgrade() else {
2001 return Ok(Vec::new());
2002 };
2003 let responses = request_task.await?.responses;
2004 let actions = join_all(
2005 responses
2006 .into_iter()
2007 .filter_map(|lsp_response| match lsp_response.response? {
2008 proto::lsp_response::Response::GetCodeActionsResponse(response) => {
2009 Some(response)
2010 }
2011 unexpected => {
2012 debug_panic!("Unexpected response: {unexpected:?}");
2013 None
2014 }
2015 })
2016 .map(|code_actions_response| {
2017 GetCodeActions {
2018 range: range.clone(),
2019 kinds: None,
2020 }
2021 .response_from_proto(
2022 code_actions_response,
2023 project.clone(),
2024 buffer.clone(),
2025 cx.clone(),
2026 )
2027 }),
2028 )
2029 .await;
2030
2031 Ok(actions
2032 .into_iter()
2033 .collect::<Result<Vec<Vec<_>>>>()?
2034 .into_iter()
2035 .flatten()
2036 .collect())
2037 })
2038 } else {
2039 let all_actions_task = self.request_multiple_lsp_locally(
2040 buffer_handle,
2041 Some(range.start),
2042 GetCodeActions {
2043 range: range.clone(),
2044 kinds: None,
2045 },
2046 cx,
2047 );
2048 cx.spawn(
2049 |_, _| async move { Ok(all_actions_task.await.into_iter().flatten().collect()) },
2050 )
2051 }
2052 }
2053
2054 #[inline(never)]
2055 pub fn completions(
2056 &self,
2057 buffer: &Model<Buffer>,
2058 position: PointUtf16,
2059 context: CompletionContext,
2060 cx: &mut ModelContext<Self>,
2061 ) -> Task<Result<Vec<Completion>>> {
2062 let language_registry = self.languages.clone();
2063
2064 if let Some((upstream_client, project_id)) = self.upstream_client() {
2065 let task = self.send_lsp_proto_request(
2066 buffer.clone(),
2067 upstream_client,
2068 project_id,
2069 GetCompletions { position, context },
2070 cx,
2071 );
2072 let language = buffer.read(cx).language().cloned();
2073
2074 // In the future, we should provide project guests with the names of LSP adapters,
2075 // so that they can use the correct LSP adapter when computing labels. For now,
2076 // guests just use the first LSP adapter associated with the buffer's language.
2077 let lsp_adapter = language.as_ref().and_then(|language| {
2078 language_registry
2079 .lsp_adapters(&language.name())
2080 .first()
2081 .cloned()
2082 });
2083
2084 cx.foreground_executor().spawn(async move {
2085 let completions = task.await?;
2086 let mut result = Vec::new();
2087 populate_labels_for_completions(
2088 completions,
2089 &language_registry,
2090 language,
2091 lsp_adapter,
2092 &mut result,
2093 )
2094 .await;
2095 Ok(result)
2096 })
2097 } else {
2098 let snapshot = buffer.read(cx).snapshot();
2099 let offset = position.to_offset(&snapshot);
2100 let scope = snapshot.language_scope_at(offset);
2101 let language = snapshot.language().cloned();
2102
2103 let server_ids: Vec<_> = self
2104 .language_servers_for_buffer(buffer.read(cx), cx)
2105 .filter(|(_, server)| server.capabilities().completion_provider.is_some())
2106 .filter(|(adapter, _)| {
2107 scope
2108 .as_ref()
2109 .map(|scope| scope.language_allowed(&adapter.name))
2110 .unwrap_or(true)
2111 })
2112 .map(|(_, server)| server.server_id())
2113 .collect();
2114
2115 let buffer = buffer.clone();
2116 cx.spawn(move |this, mut cx| async move {
2117 let mut tasks = Vec::with_capacity(server_ids.len());
2118 this.update(&mut cx, |this, cx| {
2119 for server_id in server_ids {
2120 let lsp_adapter = this.language_server_adapter_for_id(server_id);
2121 tasks.push((
2122 lsp_adapter,
2123 this.request_lsp(
2124 buffer.clone(),
2125 LanguageServerToQuery::Other(server_id),
2126 GetCompletions {
2127 position,
2128 context: context.clone(),
2129 },
2130 cx,
2131 ),
2132 ));
2133 }
2134 })?;
2135
2136 let mut completions = Vec::new();
2137 for (lsp_adapter, task) in tasks {
2138 if let Ok(new_completions) = task.await {
2139 populate_labels_for_completions(
2140 new_completions,
2141 &language_registry,
2142 language.clone(),
2143 lsp_adapter,
2144 &mut completions,
2145 )
2146 .await;
2147 }
2148 }
2149
2150 Ok(completions)
2151 })
2152 }
2153 }
2154
2155 pub fn resolve_completions(
2156 &self,
2157 buffer: Model<Buffer>,
2158 completion_indices: Vec<usize>,
2159 completions: Arc<RwLock<Box<[Completion]>>>,
2160 cx: &mut ModelContext<Self>,
2161 ) -> Task<Result<bool>> {
2162 let client = self.upstream_client();
2163 let language_registry = self.languages.clone();
2164
2165 let buffer_id = buffer.read(cx).remote_id();
2166 let buffer_snapshot = buffer.read(cx).snapshot();
2167
2168 cx.spawn(move |this, cx| async move {
2169 let mut did_resolve = false;
2170 if let Some((client, project_id)) = client {
2171 for completion_index in completion_indices {
2172 let (server_id, completion) = {
2173 let completions_guard = completions.read();
2174 let completion = &completions_guard[completion_index];
2175 did_resolve = true;
2176 let server_id = completion.server_id;
2177 let completion = completion.lsp_completion.clone();
2178
2179 (server_id, completion)
2180 };
2181
2182 Self::resolve_completion_remote(
2183 project_id,
2184 server_id,
2185 buffer_id,
2186 completions.clone(),
2187 completion_index,
2188 completion,
2189 client.clone(),
2190 language_registry.clone(),
2191 )
2192 .await;
2193 }
2194 } else {
2195 for completion_index in completion_indices {
2196 let (server_id, completion) = {
2197 let completions_guard = completions.read();
2198 let completion = &completions_guard[completion_index];
2199 let server_id = completion.server_id;
2200 let completion = completion.lsp_completion.clone();
2201
2202 (server_id, completion)
2203 };
2204
2205 let server = this
2206 .read_with(&cx, |this, _| this.language_server_for_id(server_id))
2207 .ok()
2208 .flatten();
2209 let Some(server) = server else {
2210 continue;
2211 };
2212
2213 did_resolve = true;
2214 Self::resolve_completion_local(
2215 server,
2216 &buffer_snapshot,
2217 completions.clone(),
2218 completion_index,
2219 completion,
2220 language_registry.clone(),
2221 )
2222 .await;
2223 }
2224 }
2225
2226 Ok(did_resolve)
2227 })
2228 }
2229
2230 async fn resolve_completion_local(
2231 server: Arc<lsp::LanguageServer>,
2232 snapshot: &BufferSnapshot,
2233 completions: Arc<RwLock<Box<[Completion]>>>,
2234 completion_index: usize,
2235 completion: lsp::CompletionItem,
2236 language_registry: Arc<LanguageRegistry>,
2237 ) {
2238 let can_resolve = server
2239 .capabilities()
2240 .completion_provider
2241 .as_ref()
2242 .and_then(|options| options.resolve_provider)
2243 .unwrap_or(false);
2244 if !can_resolve {
2245 return;
2246 }
2247
2248 let request = server.request::<lsp::request::ResolveCompletionItem>(completion);
2249 let Some(completion_item) = request.await.log_err() else {
2250 return;
2251 };
2252
2253 if let Some(lsp_documentation) = completion_item.documentation.as_ref() {
2254 let documentation = language::prepare_completion_documentation(
2255 lsp_documentation,
2256 &language_registry,
2257 None, // TODO: Try to reasonably work out which language the completion is for
2258 )
2259 .await;
2260
2261 let mut completions = completions.write();
2262 let completion = &mut completions[completion_index];
2263 completion.documentation = Some(documentation);
2264 } else {
2265 let mut completions = completions.write();
2266 let completion = &mut completions[completion_index];
2267 completion.documentation = Some(Documentation::Undocumented);
2268 }
2269
2270 if let Some(text_edit) = completion_item.text_edit.as_ref() {
2271 // Technically we don't have to parse the whole `text_edit`, since the only
2272 // language server we currently use that does update `text_edit` in `completionItem/resolve`
2273 // is `typescript-language-server` and they only update `text_edit.new_text`.
2274 // But we should not rely on that.
2275 let edit = parse_completion_text_edit(text_edit, snapshot);
2276
2277 if let Some((old_range, mut new_text)) = edit {
2278 LineEnding::normalize(&mut new_text);
2279
2280 let mut completions = completions.write();
2281 let completion = &mut completions[completion_index];
2282
2283 completion.new_text = new_text;
2284 completion.old_range = old_range;
2285 }
2286 }
2287 if completion_item.insert_text_format == Some(InsertTextFormat::SNIPPET) {
2288 // vtsls might change the type of completion after resolution.
2289 let mut completions = completions.write();
2290 let completion = &mut completions[completion_index];
2291 if completion_item.insert_text_format != completion.lsp_completion.insert_text_format {
2292 completion.lsp_completion.insert_text_format = completion_item.insert_text_format;
2293 }
2294 }
2295
2296 let mut completions = completions.write();
2297 let completion = &mut completions[completion_index];
2298 completion.lsp_completion = completion_item;
2299 }
2300
2301 #[allow(clippy::too_many_arguments)]
2302 async fn resolve_completion_remote(
2303 project_id: u64,
2304 server_id: LanguageServerId,
2305 buffer_id: BufferId,
2306 completions: Arc<RwLock<Box<[Completion]>>>,
2307 completion_index: usize,
2308 completion: lsp::CompletionItem,
2309 client: AnyProtoClient,
2310 language_registry: Arc<LanguageRegistry>,
2311 ) {
2312 let request = proto::ResolveCompletionDocumentation {
2313 project_id,
2314 language_server_id: server_id.0 as u64,
2315 lsp_completion: serde_json::to_string(&completion).unwrap().into_bytes(),
2316 buffer_id: buffer_id.into(),
2317 };
2318
2319 let Some(response) = client
2320 .request(request)
2321 .await
2322 .context("completion documentation resolve proto request")
2323 .log_err()
2324 else {
2325 return;
2326 };
2327 let Some(lsp_completion) = serde_json::from_slice(&response.lsp_completion).log_err()
2328 else {
2329 return;
2330 };
2331
2332 let documentation = if response.documentation.is_empty() {
2333 Documentation::Undocumented
2334 } else if response.documentation_is_markdown {
2335 Documentation::MultiLineMarkdown(
2336 markdown::parse_markdown(&response.documentation, &language_registry, None).await,
2337 )
2338 } else if response.documentation.lines().count() <= 1 {
2339 Documentation::SingleLine(response.documentation)
2340 } else {
2341 Documentation::MultiLinePlainText(response.documentation)
2342 };
2343
2344 let mut completions = completions.write();
2345 let completion = &mut completions[completion_index];
2346 completion.documentation = Some(documentation);
2347 completion.lsp_completion = lsp_completion;
2348
2349 let old_range = response
2350 .old_start
2351 .and_then(deserialize_anchor)
2352 .zip(response.old_end.and_then(deserialize_anchor));
2353 if let Some((old_start, old_end)) = old_range {
2354 if !response.new_text.is_empty() {
2355 completion.new_text = response.new_text;
2356 completion.old_range = old_start..old_end;
2357 }
2358 }
2359 }
2360
2361 pub fn apply_additional_edits_for_completion(
2362 &self,
2363 buffer_handle: Model<Buffer>,
2364 completion: Completion,
2365 push_to_history: bool,
2366 cx: &mut ModelContext<Self>,
2367 ) -> Task<Result<Option<Transaction>>> {
2368 let buffer = buffer_handle.read(cx);
2369 let buffer_id = buffer.remote_id();
2370
2371 if let Some((client, project_id)) = self.upstream_client() {
2372 cx.spawn(move |_, mut cx| async move {
2373 let response = client
2374 .request(proto::ApplyCompletionAdditionalEdits {
2375 project_id,
2376 buffer_id: buffer_id.into(),
2377 completion: Some(Self::serialize_completion(&CoreCompletion {
2378 old_range: completion.old_range,
2379 new_text: completion.new_text,
2380 server_id: completion.server_id,
2381 lsp_completion: completion.lsp_completion,
2382 })),
2383 })
2384 .await?;
2385
2386 if let Some(transaction) = response.transaction {
2387 let transaction = language::proto::deserialize_transaction(transaction)?;
2388 buffer_handle
2389 .update(&mut cx, |buffer, _| {
2390 buffer.wait_for_edits(transaction.edit_ids.iter().copied())
2391 })?
2392 .await?;
2393 if push_to_history {
2394 buffer_handle.update(&mut cx, |buffer, _| {
2395 buffer.push_transaction(transaction.clone(), Instant::now());
2396 })?;
2397 }
2398 Ok(Some(transaction))
2399 } else {
2400 Ok(None)
2401 }
2402 })
2403 } else {
2404 let server_id = completion.server_id;
2405 let lang_server = match self.language_server_for_buffer(buffer, server_id, cx) {
2406 Some((_, server)) => server.clone(),
2407 _ => return Task::ready(Ok(Default::default())),
2408 };
2409
2410 cx.spawn(move |this, mut cx| async move {
2411 let can_resolve = lang_server
2412 .capabilities()
2413 .completion_provider
2414 .as_ref()
2415 .and_then(|options| options.resolve_provider)
2416 .unwrap_or(false);
2417 let additional_text_edits = if can_resolve {
2418 lang_server
2419 .request::<lsp::request::ResolveCompletionItem>(completion.lsp_completion)
2420 .await?
2421 .additional_text_edits
2422 } else {
2423 completion.lsp_completion.additional_text_edits
2424 };
2425 if let Some(edits) = additional_text_edits {
2426 let edits = this
2427 .update(&mut cx, |this, cx| {
2428 this.edits_from_lsp(
2429 &buffer_handle,
2430 edits,
2431 lang_server.server_id(),
2432 None,
2433 cx,
2434 )
2435 })?
2436 .await?;
2437
2438 buffer_handle.update(&mut cx, |buffer, cx| {
2439 buffer.finalize_last_transaction();
2440 buffer.start_transaction();
2441
2442 for (range, text) in edits {
2443 let primary = &completion.old_range;
2444 let start_within = primary.start.cmp(&range.start, buffer).is_le()
2445 && primary.end.cmp(&range.start, buffer).is_ge();
2446 let end_within = range.start.cmp(&primary.end, buffer).is_le()
2447 && range.end.cmp(&primary.end, buffer).is_ge();
2448
2449 //Skip additional edits which overlap with the primary completion edit
2450 //https://github.com/zed-industries/zed/pull/1871
2451 if !start_within && !end_within {
2452 buffer.edit([(range, text)], None, cx);
2453 }
2454 }
2455
2456 let transaction = if buffer.end_transaction(cx).is_some() {
2457 let transaction = buffer.finalize_last_transaction().unwrap().clone();
2458 if !push_to_history {
2459 buffer.forget_transaction(transaction.id);
2460 }
2461 Some(transaction)
2462 } else {
2463 None
2464 };
2465 Ok(transaction)
2466 })?
2467 } else {
2468 Ok(None)
2469 }
2470 })
2471 }
2472 }
2473
2474 pub fn inlay_hints(
2475 &mut self,
2476 buffer_handle: Model<Buffer>,
2477 range: Range<Anchor>,
2478 cx: &mut ModelContext<Self>,
2479 ) -> Task<anyhow::Result<Vec<InlayHint>>> {
2480 let buffer = buffer_handle.read(cx);
2481 let range_start = range.start;
2482 let range_end = range.end;
2483 let buffer_id = buffer.remote_id().into();
2484 let lsp_request = InlayHints { range };
2485
2486 if let Some((client, project_id)) = self.upstream_client() {
2487 let request = proto::InlayHints {
2488 project_id,
2489 buffer_id,
2490 start: Some(serialize_anchor(&range_start)),
2491 end: Some(serialize_anchor(&range_end)),
2492 version: serialize_version(&buffer_handle.read(cx).version()),
2493 };
2494 cx.spawn(move |project, cx| async move {
2495 let response = client
2496 .request(request)
2497 .await
2498 .context("inlay hints proto request")?;
2499 LspCommand::response_from_proto(
2500 lsp_request,
2501 response,
2502 project.upgrade().ok_or_else(|| anyhow!("No project"))?,
2503 buffer_handle.clone(),
2504 cx.clone(),
2505 )
2506 .await
2507 .context("inlay hints proto response conversion")
2508 })
2509 } else {
2510 let lsp_request_task = self.request_lsp(
2511 buffer_handle.clone(),
2512 LanguageServerToQuery::Primary,
2513 lsp_request,
2514 cx,
2515 );
2516 cx.spawn(move |_, mut cx| async move {
2517 buffer_handle
2518 .update(&mut cx, |buffer, _| {
2519 buffer.wait_for_edits(vec![range_start.timestamp, range_end.timestamp])
2520 })?
2521 .await
2522 .context("waiting for inlay hint request range edits")?;
2523 lsp_request_task.await.context("inlay hints LSP request")
2524 })
2525 }
2526 }
2527
2528 pub fn signature_help<T: ToPointUtf16>(
2529 &self,
2530 buffer: &Model<Buffer>,
2531 position: T,
2532 cx: &mut ModelContext<Self>,
2533 ) -> Task<Vec<SignatureHelp>> {
2534 let position = position.to_point_utf16(buffer.read(cx));
2535
2536 if let Some((client, upstream_project_id)) = self.upstream_client() {
2537 let request_task = client.request(proto::MultiLspQuery {
2538 buffer_id: buffer.read(cx).remote_id().into(),
2539 version: serialize_version(&buffer.read(cx).version()),
2540 project_id: upstream_project_id,
2541 strategy: Some(proto::multi_lsp_query::Strategy::All(
2542 proto::AllLanguageServers {},
2543 )),
2544 request: Some(proto::multi_lsp_query::Request::GetSignatureHelp(
2545 GetSignatureHelp { position }.to_proto(upstream_project_id, buffer.read(cx)),
2546 )),
2547 });
2548 let buffer = buffer.clone();
2549 cx.spawn(|weak_project, cx| async move {
2550 let Some(project) = weak_project.upgrade() else {
2551 return Vec::new();
2552 };
2553 join_all(
2554 request_task
2555 .await
2556 .log_err()
2557 .map(|response| response.responses)
2558 .unwrap_or_default()
2559 .into_iter()
2560 .filter_map(|lsp_response| match lsp_response.response? {
2561 proto::lsp_response::Response::GetSignatureHelpResponse(response) => {
2562 Some(response)
2563 }
2564 unexpected => {
2565 debug_panic!("Unexpected response: {unexpected:?}");
2566 None
2567 }
2568 })
2569 .map(|signature_response| {
2570 let response = GetSignatureHelp { position }.response_from_proto(
2571 signature_response,
2572 project.clone(),
2573 buffer.clone(),
2574 cx.clone(),
2575 );
2576 async move { response.await.log_err().flatten() }
2577 }),
2578 )
2579 .await
2580 .into_iter()
2581 .flatten()
2582 .collect()
2583 })
2584 } else {
2585 let all_actions_task = self.request_multiple_lsp_locally(
2586 buffer,
2587 Some(position),
2588 GetSignatureHelp { position },
2589 cx,
2590 );
2591 cx.spawn(|_, _| async move {
2592 all_actions_task
2593 .await
2594 .into_iter()
2595 .flatten()
2596 .filter(|help| !help.markdown.is_empty())
2597 .collect::<Vec<_>>()
2598 })
2599 }
2600 }
2601
2602 pub fn hover(
2603 &self,
2604 buffer: &Model<Buffer>,
2605 position: PointUtf16,
2606 cx: &mut ModelContext<Self>,
2607 ) -> Task<Vec<Hover>> {
2608 if let Some((client, upstream_project_id)) = self.upstream_client() {
2609 let request_task = client.request(proto::MultiLspQuery {
2610 buffer_id: buffer.read(cx).remote_id().into(),
2611 version: serialize_version(&buffer.read(cx).version()),
2612 project_id: upstream_project_id,
2613 strategy: Some(proto::multi_lsp_query::Strategy::All(
2614 proto::AllLanguageServers {},
2615 )),
2616 request: Some(proto::multi_lsp_query::Request::GetHover(
2617 GetHover { position }.to_proto(upstream_project_id, buffer.read(cx)),
2618 )),
2619 });
2620 let buffer = buffer.clone();
2621 cx.spawn(|weak_project, cx| async move {
2622 let Some(project) = weak_project.upgrade() else {
2623 return Vec::new();
2624 };
2625 join_all(
2626 request_task
2627 .await
2628 .log_err()
2629 .map(|response| response.responses)
2630 .unwrap_or_default()
2631 .into_iter()
2632 .filter_map(|lsp_response| match lsp_response.response? {
2633 proto::lsp_response::Response::GetHoverResponse(response) => {
2634 Some(response)
2635 }
2636 unexpected => {
2637 debug_panic!("Unexpected response: {unexpected:?}");
2638 None
2639 }
2640 })
2641 .map(|hover_response| {
2642 let response = GetHover { position }.response_from_proto(
2643 hover_response,
2644 project.clone(),
2645 buffer.clone(),
2646 cx.clone(),
2647 );
2648 async move {
2649 response
2650 .await
2651 .log_err()
2652 .flatten()
2653 .and_then(remove_empty_hover_blocks)
2654 }
2655 }),
2656 )
2657 .await
2658 .into_iter()
2659 .flatten()
2660 .collect()
2661 })
2662 } else {
2663 let all_actions_task = self.request_multiple_lsp_locally(
2664 buffer,
2665 Some(position),
2666 GetHover { position },
2667 cx,
2668 );
2669 cx.spawn(|_, _| async move {
2670 all_actions_task
2671 .await
2672 .into_iter()
2673 .filter_map(|hover| remove_empty_hover_blocks(hover?))
2674 .collect::<Vec<Hover>>()
2675 })
2676 }
2677 }
2678
2679 pub fn symbols(&self, query: &str, cx: &mut ModelContext<Self>) -> Task<Result<Vec<Symbol>>> {
2680 let language_registry = self.languages.clone();
2681
2682 if let Some((upstream_client, project_id)) = self.upstream_client().as_ref() {
2683 let request = upstream_client.request(proto::GetProjectSymbols {
2684 project_id: *project_id,
2685 query: query.to_string(),
2686 });
2687 cx.foreground_executor().spawn(async move {
2688 let response = request.await?;
2689 let mut symbols = Vec::new();
2690 let core_symbols = response
2691 .symbols
2692 .into_iter()
2693 .filter_map(|symbol| Self::deserialize_symbol(symbol).log_err())
2694 .collect::<Vec<_>>();
2695 populate_labels_for_symbols(
2696 core_symbols,
2697 &language_registry,
2698 None,
2699 None,
2700 &mut symbols,
2701 )
2702 .await;
2703 Ok(symbols)
2704 })
2705 } else {
2706 struct WorkspaceSymbolsResult {
2707 lsp_adapter: Arc<CachedLspAdapter>,
2708 language: LanguageName,
2709 worktree: WeakModel<Worktree>,
2710 worktree_abs_path: Arc<Path>,
2711 lsp_symbols: Vec<(String, SymbolKind, lsp::Location)>,
2712 }
2713
2714 let mut requests = Vec::new();
2715 for ((worktree_id, _), server_id) in self.language_server_ids.iter() {
2716 let Some(worktree_handle) = self
2717 .worktree_store
2718 .read(cx)
2719 .worktree_for_id(*worktree_id, cx)
2720 else {
2721 continue;
2722 };
2723 let worktree = worktree_handle.read(cx);
2724 if !worktree.is_visible() {
2725 continue;
2726 }
2727 let worktree_abs_path = worktree.abs_path().clone();
2728
2729 let (lsp_adapter, language, server) =
2730 match self.as_local().unwrap().language_servers.get(server_id) {
2731 Some(LanguageServerState::Running {
2732 adapter,
2733 language,
2734 server,
2735 ..
2736 }) => (adapter.clone(), language.clone(), server),
2737
2738 _ => continue,
2739 };
2740
2741 requests.push(
2742 server
2743 .request::<lsp::request::WorkspaceSymbolRequest>(
2744 lsp::WorkspaceSymbolParams {
2745 query: query.to_string(),
2746 ..Default::default()
2747 },
2748 )
2749 .log_err()
2750 .map(move |response| {
2751 let lsp_symbols = response.flatten().map(|symbol_response| match symbol_response {
2752 lsp::WorkspaceSymbolResponse::Flat(flat_responses) => {
2753 flat_responses.into_iter().map(|lsp_symbol| {
2754 (lsp_symbol.name, lsp_symbol.kind, lsp_symbol.location)
2755 }).collect::<Vec<_>>()
2756 }
2757 lsp::WorkspaceSymbolResponse::Nested(nested_responses) => {
2758 nested_responses.into_iter().filter_map(|lsp_symbol| {
2759 let location = match lsp_symbol.location {
2760 OneOf::Left(location) => location,
2761 OneOf::Right(_) => {
2762 log::error!("Unexpected: client capabilities forbid symbol resolutions in workspace.symbol.resolveSupport");
2763 return None
2764 }
2765 };
2766 Some((lsp_symbol.name, lsp_symbol.kind, location))
2767 }).collect::<Vec<_>>()
2768 }
2769 }).unwrap_or_default();
2770
2771 WorkspaceSymbolsResult {
2772 lsp_adapter,
2773 language,
2774 worktree: worktree_handle.downgrade(),
2775 worktree_abs_path,
2776 lsp_symbols,
2777 }
2778 }),
2779 );
2780 }
2781
2782 cx.spawn(move |this, mut cx| async move {
2783 let responses = futures::future::join_all(requests).await;
2784 let this = match this.upgrade() {
2785 Some(this) => this,
2786 None => return Ok(Vec::new()),
2787 };
2788
2789 let mut symbols = Vec::new();
2790 for result in responses {
2791 let core_symbols = this.update(&mut cx, |this, cx| {
2792 result
2793 .lsp_symbols
2794 .into_iter()
2795 .filter_map(|(symbol_name, symbol_kind, symbol_location)| {
2796 let abs_path = symbol_location.uri.to_file_path().ok()?;
2797 let source_worktree = result.worktree.upgrade()?;
2798 let source_worktree_id = source_worktree.read(cx).id();
2799
2800 let path;
2801 let worktree;
2802 if let Some((tree, rel_path)) =
2803 this.worktree_store.read(cx).find_worktree(&abs_path, cx)
2804 {
2805 worktree = tree;
2806 path = rel_path;
2807 } else {
2808 worktree = source_worktree.clone();
2809 path = relativize_path(&result.worktree_abs_path, &abs_path);
2810 }
2811
2812 let worktree_id = worktree.read(cx).id();
2813 let project_path = ProjectPath {
2814 worktree_id,
2815 path: path.into(),
2816 };
2817 let signature = this.symbol_signature(&project_path);
2818 Some(CoreSymbol {
2819 language_server_name: result.lsp_adapter.name.clone(),
2820 source_worktree_id,
2821 path: project_path,
2822 kind: symbol_kind,
2823 name: symbol_name,
2824 range: range_from_lsp(symbol_location.range),
2825 signature,
2826 })
2827 })
2828 .collect()
2829 })?;
2830
2831 populate_labels_for_symbols(
2832 core_symbols,
2833 &language_registry,
2834 Some(result.language),
2835 Some(result.lsp_adapter),
2836 &mut symbols,
2837 )
2838 .await;
2839 }
2840
2841 Ok(symbols)
2842 })
2843 }
2844 }
2845
2846 pub fn diagnostic_summaries<'a>(
2847 &'a self,
2848 include_ignored: bool,
2849 cx: &'a AppContext,
2850 ) -> impl Iterator<Item = (ProjectPath, LanguageServerId, DiagnosticSummary)> + 'a {
2851 self.worktree_store
2852 .read(cx)
2853 .visible_worktrees(cx)
2854 .filter_map(|worktree| {
2855 let worktree = worktree.read(cx);
2856 Some((worktree, self.diagnostic_summaries.get(&worktree.id())?))
2857 })
2858 .flat_map(move |(worktree, summaries)| {
2859 let worktree_id = worktree.id();
2860 summaries
2861 .iter()
2862 .filter(move |(path, _)| {
2863 include_ignored
2864 || worktree
2865 .entry_for_path(path.as_ref())
2866 .map_or(false, |entry| !entry.is_ignored)
2867 })
2868 .flat_map(move |(path, summaries)| {
2869 summaries.iter().map(move |(server_id, summary)| {
2870 (
2871 ProjectPath {
2872 worktree_id,
2873 path: path.clone(),
2874 },
2875 *server_id,
2876 *summary,
2877 )
2878 })
2879 })
2880 })
2881 }
2882
2883 pub fn started_language_servers(&self) -> Vec<(WorktreeId, LanguageServerName)> {
2884 self.language_server_ids.keys().cloned().collect()
2885 }
2886
2887 pub fn on_buffer_edited(
2888 &mut self,
2889 buffer: Model<Buffer>,
2890 cx: &mut ModelContext<Self>,
2891 ) -> Option<()> {
2892 let buffer = buffer.read(cx);
2893 let file = File::from_dyn(buffer.file())?;
2894 let abs_path = file.as_local()?.abs_path(cx);
2895 let uri = lsp::Url::from_file_path(abs_path).unwrap();
2896 let next_snapshot = buffer.text_snapshot();
2897
2898 let language_servers: Vec<_> = self
2899 .language_servers_for_buffer(buffer, cx)
2900 .map(|i| i.1.clone())
2901 .collect();
2902
2903 for language_server in language_servers {
2904 let language_server = language_server.clone();
2905
2906 let buffer_snapshots = self
2907 .buffer_snapshots
2908 .get_mut(&buffer.remote_id())
2909 .and_then(|m| m.get_mut(&language_server.server_id()))?;
2910 let previous_snapshot = buffer_snapshots.last()?;
2911
2912 let build_incremental_change = || {
2913 buffer
2914 .edits_since::<(PointUtf16, usize)>(previous_snapshot.snapshot.version())
2915 .map(|edit| {
2916 let edit_start = edit.new.start.0;
2917 let edit_end = edit_start + (edit.old.end.0 - edit.old.start.0);
2918 let new_text = next_snapshot
2919 .text_for_range(edit.new.start.1..edit.new.end.1)
2920 .collect();
2921 lsp::TextDocumentContentChangeEvent {
2922 range: Some(lsp::Range::new(
2923 point_to_lsp(edit_start),
2924 point_to_lsp(edit_end),
2925 )),
2926 range_length: None,
2927 text: new_text,
2928 }
2929 })
2930 .collect()
2931 };
2932
2933 let document_sync_kind = language_server
2934 .capabilities()
2935 .text_document_sync
2936 .as_ref()
2937 .and_then(|sync| match sync {
2938 lsp::TextDocumentSyncCapability::Kind(kind) => Some(*kind),
2939 lsp::TextDocumentSyncCapability::Options(options) => options.change,
2940 });
2941
2942 let content_changes: Vec<_> = match document_sync_kind {
2943 Some(lsp::TextDocumentSyncKind::FULL) => {
2944 vec![lsp::TextDocumentContentChangeEvent {
2945 range: None,
2946 range_length: None,
2947 text: next_snapshot.text(),
2948 }]
2949 }
2950 Some(lsp::TextDocumentSyncKind::INCREMENTAL) => build_incremental_change(),
2951 _ => {
2952 #[cfg(any(test, feature = "test-support"))]
2953 {
2954 build_incremental_change()
2955 }
2956
2957 #[cfg(not(any(test, feature = "test-support")))]
2958 {
2959 continue;
2960 }
2961 }
2962 };
2963
2964 let next_version = previous_snapshot.version + 1;
2965 buffer_snapshots.push(LspBufferSnapshot {
2966 version: next_version,
2967 snapshot: next_snapshot.clone(),
2968 });
2969
2970 language_server
2971 .notify::<lsp::notification::DidChangeTextDocument>(
2972 lsp::DidChangeTextDocumentParams {
2973 text_document: lsp::VersionedTextDocumentIdentifier::new(
2974 uri.clone(),
2975 next_version,
2976 ),
2977 content_changes,
2978 },
2979 )
2980 .log_err();
2981 }
2982
2983 None
2984 }
2985
2986 pub fn on_buffer_saved(
2987 &mut self,
2988 buffer: Model<Buffer>,
2989 cx: &mut ModelContext<Self>,
2990 ) -> Option<()> {
2991 let file = File::from_dyn(buffer.read(cx).file())?;
2992 let worktree_id = file.worktree_id(cx);
2993 let abs_path = file.as_local()?.abs_path(cx);
2994 let text_document = lsp::TextDocumentIdentifier {
2995 uri: lsp::Url::from_file_path(abs_path).log_err()?,
2996 };
2997
2998 for server in self.language_servers_for_worktree(worktree_id) {
2999 if let Some(include_text) = include_text(server.as_ref()) {
3000 let text = if include_text {
3001 Some(buffer.read(cx).text())
3002 } else {
3003 None
3004 };
3005 server
3006 .notify::<lsp::notification::DidSaveTextDocument>(
3007 lsp::DidSaveTextDocumentParams {
3008 text_document: text_document.clone(),
3009 text,
3010 },
3011 )
3012 .log_err();
3013 }
3014 }
3015
3016 for language_server_id in self.language_server_ids_for_buffer(buffer.read(cx), cx) {
3017 self.simulate_disk_based_diagnostics_events_if_needed(language_server_id, cx);
3018 }
3019
3020 None
3021 }
3022
3023 fn maintain_workspace_config(cx: &mut ModelContext<Self>) -> Task<Result<()>> {
3024 let (mut settings_changed_tx, mut settings_changed_rx) = watch::channel();
3025 let _ = postage::stream::Stream::try_recv(&mut settings_changed_rx);
3026
3027 let settings_observation = cx.observe_global::<SettingsStore>(move |_, _| {
3028 *settings_changed_tx.borrow_mut() = ();
3029 });
3030
3031 cx.spawn(move |this, mut cx| async move {
3032 while let Some(()) = settings_changed_rx.next().await {
3033 let servers = this.update(&mut cx, |this, cx| {
3034 this.language_server_ids
3035 .iter()
3036 .filter_map(|((worktree_id, _), server_id)| {
3037 let worktree = this
3038 .worktree_store
3039 .read(cx)
3040 .worktree_for_id(*worktree_id, cx)?;
3041 let state = this.as_local()?.language_servers.get(server_id)?;
3042 let delegate = LocalLspAdapterDelegate::for_local(this, &worktree, cx);
3043 match state {
3044 LanguageServerState::Starting(_) => None,
3045 LanguageServerState::Running {
3046 adapter, server, ..
3047 } => Some((
3048 adapter.adapter.clone(),
3049 server.clone(),
3050 delegate as Arc<dyn LspAdapterDelegate>,
3051 )),
3052 }
3053 })
3054 .collect::<Vec<_>>()
3055 })?;
3056
3057 for (adapter, server, delegate) in servers {
3058 let settings = adapter.workspace_configuration(&delegate, &mut cx).await?;
3059
3060 server
3061 .notify::<lsp::notification::DidChangeConfiguration>(
3062 lsp::DidChangeConfigurationParams { settings },
3063 )
3064 .ok();
3065 }
3066 }
3067
3068 drop(settings_observation);
3069 anyhow::Ok(())
3070 })
3071 }
3072
3073 fn primary_language_server_for_buffer<'a>(
3074 &'a self,
3075 buffer: &'a Buffer,
3076 cx: &'a AppContext,
3077 ) -> Option<(&'a Arc<CachedLspAdapter>, &'a Arc<LanguageServer>)> {
3078 // The list of language servers is ordered based on the `language_servers` setting
3079 // for each language, thus we can consider the first one in the list to be the
3080 // primary one.
3081 self.language_servers_for_buffer(buffer, cx).next()
3082 }
3083
3084 pub fn language_server_for_buffer<'a>(
3085 &'a self,
3086 buffer: &'a Buffer,
3087 server_id: LanguageServerId,
3088 cx: &'a AppContext,
3089 ) -> Option<(&'a Arc<CachedLspAdapter>, &'a Arc<LanguageServer>)> {
3090 self.language_servers_for_buffer(buffer, cx)
3091 .find(|(_, s)| s.server_id() == server_id)
3092 }
3093
3094 fn language_servers_for_worktree(
3095 &self,
3096 worktree_id: WorktreeId,
3097 ) -> impl Iterator<Item = &Arc<LanguageServer>> {
3098 self.language_server_ids
3099 .iter()
3100 .filter_map(move |((language_server_worktree_id, _), id)| {
3101 if *language_server_worktree_id == worktree_id {
3102 if let Some(LanguageServerState::Running { server, .. }) =
3103 self.as_local()?.language_servers.get(id)
3104 {
3105 return Some(server);
3106 }
3107 }
3108 None
3109 })
3110 }
3111
3112 fn remove_worktree(&mut self, id_to_remove: WorktreeId, cx: &mut ModelContext<Self>) {
3113 self.diagnostics.remove(&id_to_remove);
3114 self.diagnostic_summaries.remove(&id_to_remove);
3115
3116 let mut servers_to_remove = HashMap::default();
3117 let mut servers_to_preserve = HashSet::default();
3118 for ((worktree_id, server_name), &server_id) in &self.language_server_ids {
3119 if worktree_id == &id_to_remove {
3120 servers_to_remove.insert(server_id, server_name.clone());
3121 } else {
3122 servers_to_preserve.insert(server_id);
3123 }
3124 }
3125 servers_to_remove.retain(|server_id, _| !servers_to_preserve.contains(server_id));
3126 for (server_id_to_remove, server_name) in servers_to_remove {
3127 self.language_server_ids
3128 .remove(&(id_to_remove, server_name));
3129 self.language_server_statuses.remove(&server_id_to_remove);
3130 if let Some(local_lsp_store) = self.as_local_mut() {
3131 local_lsp_store
3132 .language_server_watched_paths
3133 .remove(&server_id_to_remove);
3134 local_lsp_store
3135 .last_workspace_edits_by_language_server
3136 .remove(&server_id_to_remove);
3137 local_lsp_store
3138 .language_servers
3139 .remove(&server_id_to_remove);
3140 }
3141 cx.emit(LspStoreEvent::LanguageServerRemoved(server_id_to_remove));
3142 }
3143
3144 if let Some(local) = self.as_local() {
3145 local.prettier_store.update(cx, |prettier_store, cx| {
3146 prettier_store.remove_worktree(id_to_remove, cx);
3147 })
3148 }
3149 }
3150
3151 pub fn shared(
3152 &mut self,
3153 project_id: u64,
3154 downstream_client: AnyProtoClient,
3155 _: &mut ModelContext<Self>,
3156 ) {
3157 self.downstream_client = Some((downstream_client.clone(), project_id));
3158
3159 for (server_id, status) in &self.language_server_statuses {
3160 downstream_client
3161 .send(proto::StartLanguageServer {
3162 project_id,
3163 server: Some(proto::LanguageServer {
3164 id: server_id.0 as u64,
3165 name: status.name.clone(),
3166 worktree_id: None,
3167 }),
3168 })
3169 .log_err();
3170 }
3171 }
3172
3173 pub fn disconnected_from_host(&mut self) {
3174 self.downstream_client.take();
3175 }
3176
3177 pub fn disconnected_from_ssh_remote(&mut self) {
3178 if let LspStoreMode::Remote(RemoteLspStore {
3179 upstream_client, ..
3180 }) = &mut self.mode
3181 {
3182 upstream_client.take();
3183 }
3184 }
3185
3186 pub(crate) fn set_language_server_statuses_from_proto(
3187 &mut self,
3188 language_servers: Vec<proto::LanguageServer>,
3189 ) {
3190 self.language_server_statuses = language_servers
3191 .into_iter()
3192 .map(|server| {
3193 (
3194 LanguageServerId(server.id as usize),
3195 LanguageServerStatus {
3196 name: server.name,
3197 pending_work: Default::default(),
3198 has_pending_diagnostic_updates: false,
3199 progress_tokens: Default::default(),
3200 },
3201 )
3202 })
3203 .collect();
3204 }
3205
3206 pub(crate) fn register_language_server(
3207 &mut self,
3208 worktree_id: WorktreeId,
3209 language_server_name: LanguageServerName,
3210 language_server_id: LanguageServerId,
3211 ) {
3212 self.language_server_ids
3213 .insert((worktree_id, language_server_name), language_server_id);
3214 }
3215
3216 #[track_caller]
3217 pub(crate) fn register_buffer_with_language_servers(
3218 &mut self,
3219 buffer_handle: &Model<Buffer>,
3220 cx: &mut ModelContext<Self>,
3221 ) {
3222 let available_language = self.detect_language_for_buffer(buffer_handle, cx);
3223
3224 let buffer = buffer_handle.read(cx);
3225 let buffer_id = buffer.remote_id();
3226
3227 if let Some(file) = File::from_dyn(buffer.file()) {
3228 if !file.is_local() {
3229 return;
3230 }
3231
3232 let abs_path = file.abs_path(cx);
3233 let Some(uri) = lsp::Url::from_file_path(&abs_path).log_err() else {
3234 return;
3235 };
3236 let initial_snapshot = buffer.text_snapshot();
3237 let worktree_id = file.worktree_id(cx);
3238
3239 if let Some(diagnostics) = self.diagnostics.get(&worktree_id) {
3240 for (server_id, diagnostics) in
3241 diagnostics.get(file.path()).cloned().unwrap_or_default()
3242 {
3243 self.update_buffer_diagnostics(buffer_handle, server_id, None, diagnostics, cx)
3244 .log_err();
3245 }
3246 }
3247
3248 if let Some(language) = available_language {
3249 for adapter in self.languages.lsp_adapters(&language.name()) {
3250 let server = self
3251 .language_server_ids
3252 .get(&(worktree_id, adapter.name.clone()))
3253 .and_then(|id| self.as_local()?.language_servers.get(id))
3254 .and_then(|server_state| {
3255 if let LanguageServerState::Running { server, .. } = server_state {
3256 Some(server.clone())
3257 } else {
3258 None
3259 }
3260 });
3261 let server = match server {
3262 Some(server) => server,
3263 None => continue,
3264 };
3265
3266 server
3267 .notify::<lsp::notification::DidOpenTextDocument>(
3268 lsp::DidOpenTextDocumentParams {
3269 text_document: lsp::TextDocumentItem::new(
3270 uri.clone(),
3271 adapter.language_id(&language.name()),
3272 0,
3273 initial_snapshot.text(),
3274 ),
3275 },
3276 )
3277 .log_err();
3278
3279 buffer_handle.update(cx, |buffer, cx| {
3280 buffer.set_completion_triggers(
3281 server
3282 .capabilities()
3283 .completion_provider
3284 .as_ref()
3285 .and_then(|provider| provider.trigger_characters.clone())
3286 .unwrap_or_default(),
3287 cx,
3288 );
3289 });
3290
3291 let snapshot = LspBufferSnapshot {
3292 version: 0,
3293 snapshot: initial_snapshot.clone(),
3294 };
3295 self.buffer_snapshots
3296 .entry(buffer_id)
3297 .or_default()
3298 .insert(server.server_id(), vec![snapshot]);
3299 }
3300 }
3301 }
3302 }
3303
3304 pub(crate) fn unregister_buffer_from_language_servers(
3305 &mut self,
3306 buffer: &Model<Buffer>,
3307 old_file: &File,
3308 cx: &mut AppContext,
3309 ) {
3310 let old_path = match old_file.as_local() {
3311 Some(local) => local.abs_path(cx),
3312 None => return,
3313 };
3314
3315 buffer.update(cx, |buffer, cx| {
3316 let worktree_id = old_file.worktree_id(cx);
3317
3318 let ids = &self.language_server_ids;
3319
3320 if let Some(language) = buffer.language().cloned() {
3321 for adapter in self.languages.lsp_adapters(&language.name()) {
3322 if let Some(server_id) = ids.get(&(worktree_id, adapter.name.clone())) {
3323 buffer.update_diagnostics(*server_id, DiagnosticSet::new([], buffer), cx);
3324 }
3325 }
3326 }
3327
3328 self.buffer_snapshots.remove(&buffer.remote_id());
3329 let file_url = lsp::Url::from_file_path(old_path).unwrap();
3330 for (_, language_server) in self.language_servers_for_buffer(buffer, cx) {
3331 language_server
3332 .notify::<lsp::notification::DidCloseTextDocument>(
3333 lsp::DidCloseTextDocumentParams {
3334 text_document: lsp::TextDocumentIdentifier::new(file_url.clone()),
3335 },
3336 )
3337 .log_err();
3338 }
3339 });
3340 }
3341
3342 pub fn update_diagnostic_entries(
3343 &mut self,
3344 server_id: LanguageServerId,
3345 abs_path: PathBuf,
3346 version: Option<i32>,
3347 diagnostics: Vec<DiagnosticEntry<Unclipped<PointUtf16>>>,
3348 cx: &mut ModelContext<Self>,
3349 ) -> Result<(), anyhow::Error> {
3350 let (worktree, relative_path) =
3351 self.worktree_store
3352 .read(cx)
3353 .find_worktree(&abs_path, cx)
3354 .ok_or_else(|| anyhow!("no worktree found for diagnostics path {abs_path:?}"))?;
3355
3356 let project_path = ProjectPath {
3357 worktree_id: worktree.read(cx).id(),
3358 path: relative_path.into(),
3359 };
3360
3361 if let Some(buffer) = self.buffer_store.read(cx).get_by_path(&project_path, cx) {
3362 self.update_buffer_diagnostics(&buffer, server_id, version, diagnostics.clone(), cx)?;
3363 }
3364
3365 let updated = worktree.update(cx, |worktree, cx| {
3366 self.update_worktree_diagnostics(
3367 worktree.id(),
3368 server_id,
3369 project_path.path.clone(),
3370 diagnostics,
3371 cx,
3372 )
3373 })?;
3374 if updated {
3375 cx.emit(LspStoreEvent::DiagnosticsUpdated {
3376 language_server_id: server_id,
3377 path: project_path,
3378 })
3379 }
3380 Ok(())
3381 }
3382
3383 fn update_worktree_diagnostics(
3384 &mut self,
3385 worktree_id: WorktreeId,
3386 server_id: LanguageServerId,
3387 worktree_path: Arc<Path>,
3388 diagnostics: Vec<DiagnosticEntry<Unclipped<PointUtf16>>>,
3389 _: &mut ModelContext<Worktree>,
3390 ) -> Result<bool> {
3391 let summaries_for_tree = self.diagnostic_summaries.entry(worktree_id).or_default();
3392 let diagnostics_for_tree = self.diagnostics.entry(worktree_id).or_default();
3393 let summaries_by_server_id = summaries_for_tree.entry(worktree_path.clone()).or_default();
3394
3395 let old_summary = summaries_by_server_id
3396 .remove(&server_id)
3397 .unwrap_or_default();
3398
3399 let new_summary = DiagnosticSummary::new(&diagnostics);
3400 if new_summary.is_empty() {
3401 if let Some(diagnostics_by_server_id) = diagnostics_for_tree.get_mut(&worktree_path) {
3402 if let Ok(ix) = diagnostics_by_server_id.binary_search_by_key(&server_id, |e| e.0) {
3403 diagnostics_by_server_id.remove(ix);
3404 }
3405 if diagnostics_by_server_id.is_empty() {
3406 diagnostics_for_tree.remove(&worktree_path);
3407 }
3408 }
3409 } else {
3410 summaries_by_server_id.insert(server_id, new_summary);
3411 let diagnostics_by_server_id = diagnostics_for_tree
3412 .entry(worktree_path.clone())
3413 .or_default();
3414 match diagnostics_by_server_id.binary_search_by_key(&server_id, |e| e.0) {
3415 Ok(ix) => {
3416 diagnostics_by_server_id[ix] = (server_id, diagnostics);
3417 }
3418 Err(ix) => {
3419 diagnostics_by_server_id.insert(ix, (server_id, diagnostics));
3420 }
3421 }
3422 }
3423
3424 if !old_summary.is_empty() || !new_summary.is_empty() {
3425 if let Some((downstream_client, project_id)) = &self.downstream_client {
3426 downstream_client
3427 .send(proto::UpdateDiagnosticSummary {
3428 project_id: *project_id,
3429 worktree_id: worktree_id.to_proto(),
3430 summary: Some(proto::DiagnosticSummary {
3431 path: worktree_path.to_string_lossy().to_string(),
3432 language_server_id: server_id.0 as u64,
3433 error_count: new_summary.error_count as u32,
3434 warning_count: new_summary.warning_count as u32,
3435 }),
3436 })
3437 .log_err();
3438 }
3439 }
3440
3441 Ok(!old_summary.is_empty() || !new_summary.is_empty())
3442 }
3443
3444 pub fn open_buffer_for_symbol(
3445 &mut self,
3446 symbol: &Symbol,
3447 cx: &mut ModelContext<Self>,
3448 ) -> Task<Result<Model<Buffer>>> {
3449 if let Some((client, project_id)) = self.upstream_client() {
3450 let request = client.request(proto::OpenBufferForSymbol {
3451 project_id,
3452 symbol: Some(Self::serialize_symbol(symbol)),
3453 });
3454 cx.spawn(move |this, mut cx| async move {
3455 let response = request.await?;
3456 let buffer_id = BufferId::new(response.buffer_id)?;
3457 this.update(&mut cx, |this, cx| {
3458 this.wait_for_remote_buffer(buffer_id, cx)
3459 })?
3460 .await
3461 })
3462 } else {
3463 let Some(&language_server_id) = self.language_server_ids.get(&(
3464 symbol.source_worktree_id,
3465 symbol.language_server_name.clone(),
3466 )) else {
3467 return Task::ready(Err(anyhow!(
3468 "language server for worktree and language not found"
3469 )));
3470 };
3471
3472 let worktree_abs_path = if let Some(worktree_abs_path) = self
3473 .worktree_store
3474 .read(cx)
3475 .worktree_for_id(symbol.path.worktree_id, cx)
3476 .map(|worktree| worktree.read(cx).abs_path())
3477 {
3478 worktree_abs_path
3479 } else {
3480 return Task::ready(Err(anyhow!("worktree not found for symbol")));
3481 };
3482
3483 let symbol_abs_path = resolve_path(&worktree_abs_path, &symbol.path.path);
3484 let symbol_uri = if let Ok(uri) = lsp::Url::from_file_path(symbol_abs_path) {
3485 uri
3486 } else {
3487 return Task::ready(Err(anyhow!("invalid symbol path")));
3488 };
3489
3490 self.open_local_buffer_via_lsp(
3491 symbol_uri,
3492 language_server_id,
3493 symbol.language_server_name.clone(),
3494 cx,
3495 )
3496 }
3497 }
3498
3499 pub fn open_local_buffer_via_lsp(
3500 &mut self,
3501 mut abs_path: lsp::Url,
3502 language_server_id: LanguageServerId,
3503 language_server_name: LanguageServerName,
3504 cx: &mut ModelContext<Self>,
3505 ) -> Task<Result<Model<Buffer>>> {
3506 cx.spawn(move |lsp_store, mut cx| async move {
3507 // Escape percent-encoded string.
3508 let current_scheme = abs_path.scheme().to_owned();
3509 let _ = abs_path.set_scheme("file");
3510
3511 let abs_path = abs_path
3512 .to_file_path()
3513 .map_err(|_| anyhow!("can't convert URI to path"))?;
3514 let p = abs_path.clone();
3515 let yarn_worktree = lsp_store
3516 .update(&mut cx, move |lsp_store, cx| match lsp_store.as_local() {
3517 Some(local_lsp_store) => local_lsp_store.yarn.update(cx, |_, cx| {
3518 cx.spawn(|this, mut cx| async move {
3519 let t = this
3520 .update(&mut cx, |this, cx| {
3521 this.process_path(&p, ¤t_scheme, cx)
3522 })
3523 .ok()?;
3524 t.await
3525 })
3526 }),
3527 None => Task::ready(None),
3528 })?
3529 .await;
3530 let (worktree_root_target, known_relative_path) =
3531 if let Some((zip_root, relative_path)) = yarn_worktree {
3532 (zip_root, Some(relative_path))
3533 } else {
3534 (Arc::<Path>::from(abs_path.as_path()), None)
3535 };
3536 let (worktree, relative_path) = if let Some(result) =
3537 lsp_store.update(&mut cx, |lsp_store, cx| {
3538 lsp_store.worktree_store.update(cx, |worktree_store, cx| {
3539 worktree_store.find_worktree(&worktree_root_target, cx)
3540 })
3541 })? {
3542 let relative_path =
3543 known_relative_path.unwrap_or_else(|| Arc::<Path>::from(result.1));
3544 (result.0, relative_path)
3545 } else {
3546 let worktree = lsp_store
3547 .update(&mut cx, |lsp_store, cx| {
3548 lsp_store.worktree_store.update(cx, |worktree_store, cx| {
3549 worktree_store.create_worktree(&worktree_root_target, false, cx)
3550 })
3551 })?
3552 .await?;
3553 if worktree.update(&mut cx, |worktree, _| worktree.is_local())? {
3554 lsp_store
3555 .update(&mut cx, |lsp_store, cx| {
3556 lsp_store.register_language_server(
3557 worktree.read(cx).id(),
3558 language_server_name,
3559 language_server_id,
3560 )
3561 })
3562 .ok();
3563 }
3564 let worktree_root = worktree.update(&mut cx, |worktree, _| worktree.abs_path())?;
3565 let relative_path = if let Some(known_path) = known_relative_path {
3566 known_path
3567 } else {
3568 abs_path.strip_prefix(worktree_root)?.into()
3569 };
3570 (worktree, relative_path)
3571 };
3572 let project_path = ProjectPath {
3573 worktree_id: worktree.update(&mut cx, |worktree, _| worktree.id())?,
3574 path: relative_path,
3575 };
3576 lsp_store
3577 .update(&mut cx, |lsp_store, cx| {
3578 lsp_store.buffer_store().update(cx, |buffer_store, cx| {
3579 buffer_store.open_buffer(project_path, cx)
3580 })
3581 })?
3582 .await
3583 })
3584 }
3585
3586 pub(crate) fn update_buffer_diagnostics(
3587 &mut self,
3588 buffer: &Model<Buffer>,
3589 server_id: LanguageServerId,
3590 version: Option<i32>,
3591 mut diagnostics: Vec<DiagnosticEntry<Unclipped<PointUtf16>>>,
3592 cx: &mut ModelContext<Self>,
3593 ) -> Result<()> {
3594 fn compare_diagnostics(a: &Diagnostic, b: &Diagnostic) -> Ordering {
3595 Ordering::Equal
3596 .then_with(|| b.is_primary.cmp(&a.is_primary))
3597 .then_with(|| a.is_disk_based.cmp(&b.is_disk_based))
3598 .then_with(|| a.severity.cmp(&b.severity))
3599 .then_with(|| a.message.cmp(&b.message))
3600 }
3601
3602 let snapshot = self.buffer_snapshot_for_lsp_version(buffer, server_id, version, cx)?;
3603
3604 diagnostics.sort_unstable_by(|a, b| {
3605 Ordering::Equal
3606 .then_with(|| a.range.start.cmp(&b.range.start))
3607 .then_with(|| b.range.end.cmp(&a.range.end))
3608 .then_with(|| compare_diagnostics(&a.diagnostic, &b.diagnostic))
3609 });
3610
3611 let mut sanitized_diagnostics = Vec::new();
3612 let edits_since_save = Patch::new(
3613 snapshot
3614 .edits_since::<Unclipped<PointUtf16>>(buffer.read(cx).saved_version())
3615 .collect(),
3616 );
3617 for entry in diagnostics {
3618 let start;
3619 let end;
3620 if entry.diagnostic.is_disk_based {
3621 // Some diagnostics are based on files on disk instead of buffers'
3622 // current contents. Adjust these diagnostics' ranges to reflect
3623 // any unsaved edits.
3624 start = edits_since_save.old_to_new(entry.range.start);
3625 end = edits_since_save.old_to_new(entry.range.end);
3626 } else {
3627 start = entry.range.start;
3628 end = entry.range.end;
3629 }
3630
3631 let mut range = snapshot.clip_point_utf16(start, Bias::Left)
3632 ..snapshot.clip_point_utf16(end, Bias::Right);
3633
3634 // Expand empty ranges by one codepoint
3635 if range.start == range.end {
3636 // This will be go to the next boundary when being clipped
3637 range.end.column += 1;
3638 range.end = snapshot.clip_point_utf16(Unclipped(range.end), Bias::Right);
3639 if range.start == range.end && range.end.column > 0 {
3640 range.start.column -= 1;
3641 range.start = snapshot.clip_point_utf16(Unclipped(range.start), Bias::Left);
3642 }
3643 }
3644
3645 sanitized_diagnostics.push(DiagnosticEntry {
3646 range,
3647 diagnostic: entry.diagnostic,
3648 });
3649 }
3650 drop(edits_since_save);
3651
3652 let set = DiagnosticSet::new(sanitized_diagnostics, &snapshot);
3653 buffer.update(cx, |buffer, cx| {
3654 buffer.update_diagnostics(server_id, set, cx)
3655 });
3656 Ok(())
3657 }
3658
3659 fn request_multiple_lsp_locally<P, R>(
3660 &self,
3661 buffer: &Model<Buffer>,
3662 position: Option<P>,
3663 request: R,
3664 cx: &mut ModelContext<'_, Self>,
3665 ) -> Task<Vec<R::Response>>
3666 where
3667 P: ToOffset,
3668 R: LspCommand + Clone,
3669 <R::LspRequest as lsp::request::Request>::Result: Send,
3670 <R::LspRequest as lsp::request::Request>::Params: Send,
3671 {
3672 debug_assert!(self.upstream_client().is_none());
3673
3674 let snapshot = buffer.read(cx).snapshot();
3675 let scope = position.and_then(|position| snapshot.language_scope_at(position));
3676 let server_ids = self
3677 .language_servers_for_buffer(buffer.read(cx), cx)
3678 .filter(|(adapter, _)| {
3679 scope
3680 .as_ref()
3681 .map(|scope| scope.language_allowed(&adapter.name))
3682 .unwrap_or(true)
3683 })
3684 .map(|(_, server)| server.server_id())
3685 .collect::<Vec<_>>();
3686
3687 let mut response_results = server_ids
3688 .into_iter()
3689 .map(|server_id| {
3690 self.request_lsp(
3691 buffer.clone(),
3692 LanguageServerToQuery::Other(server_id),
3693 request.clone(),
3694 cx,
3695 )
3696 })
3697 .collect::<FuturesUnordered<_>>();
3698
3699 cx.spawn(|_, _| async move {
3700 let mut responses = Vec::with_capacity(response_results.len());
3701 while let Some(response_result) = response_results.next().await {
3702 if let Some(response) = response_result.log_err() {
3703 responses.push(response);
3704 }
3705 }
3706 responses
3707 })
3708 }
3709
3710 async fn handle_lsp_command<T: LspCommand>(
3711 this: Model<Self>,
3712 envelope: TypedEnvelope<T::ProtoRequest>,
3713 mut cx: AsyncAppContext,
3714 ) -> Result<<T::ProtoRequest as proto::RequestMessage>::Response>
3715 where
3716 <T::LspRequest as lsp::request::Request>::Params: Send,
3717 <T::LspRequest as lsp::request::Request>::Result: Send,
3718 {
3719 let sender_id = envelope.original_sender_id().unwrap_or_default();
3720 let buffer_id = T::buffer_id_from_proto(&envelope.payload)?;
3721 let buffer_handle = this.update(&mut cx, |this, cx| {
3722 this.buffer_store.read(cx).get_existing(buffer_id)
3723 })??;
3724 let request = T::from_proto(
3725 envelope.payload,
3726 this.clone(),
3727 buffer_handle.clone(),
3728 cx.clone(),
3729 )
3730 .await?;
3731 let response = this
3732 .update(&mut cx, |this, cx| {
3733 this.request_lsp(
3734 buffer_handle.clone(),
3735 LanguageServerToQuery::Primary,
3736 request,
3737 cx,
3738 )
3739 })?
3740 .await?;
3741 this.update(&mut cx, |this, cx| {
3742 Ok(T::response_to_proto(
3743 response,
3744 this,
3745 sender_id,
3746 &buffer_handle.read(cx).version(),
3747 cx,
3748 ))
3749 })?
3750 }
3751
3752 async fn handle_multi_lsp_query(
3753 this: Model<Self>,
3754 envelope: TypedEnvelope<proto::MultiLspQuery>,
3755 mut cx: AsyncAppContext,
3756 ) -> Result<proto::MultiLspQueryResponse> {
3757 let response_from_ssh = this.update(&mut cx, |this, _| {
3758 let (upstream_client, project_id) = this.upstream_client()?;
3759 let mut payload = envelope.payload.clone();
3760 payload.project_id = project_id;
3761
3762 Some(upstream_client.request(payload))
3763 })?;
3764 if let Some(response_from_ssh) = response_from_ssh {
3765 return response_from_ssh.await;
3766 }
3767
3768 let sender_id = envelope.original_sender_id().unwrap_or_default();
3769 let buffer_id = BufferId::new(envelope.payload.buffer_id)?;
3770 let version = deserialize_version(&envelope.payload.version);
3771 let buffer = this.update(&mut cx, |this, cx| {
3772 this.buffer_store.read(cx).get_existing(buffer_id)
3773 })??;
3774 buffer
3775 .update(&mut cx, |buffer, _| {
3776 buffer.wait_for_version(version.clone())
3777 })?
3778 .await?;
3779 let buffer_version = buffer.update(&mut cx, |buffer, _| buffer.version())?;
3780 match envelope
3781 .payload
3782 .strategy
3783 .context("invalid request without the strategy")?
3784 {
3785 proto::multi_lsp_query::Strategy::All(_) => {
3786 // currently, there's only one multiple language servers query strategy,
3787 // so just ensure it's specified correctly
3788 }
3789 }
3790 match envelope.payload.request {
3791 Some(proto::multi_lsp_query::Request::GetHover(get_hover)) => {
3792 let get_hover =
3793 GetHover::from_proto(get_hover, this.clone(), buffer.clone(), cx.clone())
3794 .await?;
3795 let all_hovers = this
3796 .update(&mut cx, |this, cx| {
3797 this.request_multiple_lsp_locally(
3798 &buffer,
3799 Some(get_hover.position),
3800 get_hover,
3801 cx,
3802 )
3803 })?
3804 .await
3805 .into_iter()
3806 .filter_map(|hover| remove_empty_hover_blocks(hover?));
3807 this.update(&mut cx, |project, cx| proto::MultiLspQueryResponse {
3808 responses: all_hovers
3809 .map(|hover| proto::LspResponse {
3810 response: Some(proto::lsp_response::Response::GetHoverResponse(
3811 GetHover::response_to_proto(
3812 Some(hover),
3813 project,
3814 sender_id,
3815 &buffer_version,
3816 cx,
3817 ),
3818 )),
3819 })
3820 .collect(),
3821 })
3822 }
3823 Some(proto::multi_lsp_query::Request::GetCodeActions(get_code_actions)) => {
3824 let get_code_actions = GetCodeActions::from_proto(
3825 get_code_actions,
3826 this.clone(),
3827 buffer.clone(),
3828 cx.clone(),
3829 )
3830 .await?;
3831
3832 let all_actions = this
3833 .update(&mut cx, |project, cx| {
3834 project.request_multiple_lsp_locally(
3835 &buffer,
3836 Some(get_code_actions.range.start),
3837 get_code_actions,
3838 cx,
3839 )
3840 })?
3841 .await
3842 .into_iter();
3843
3844 this.update(&mut cx, |project, cx| proto::MultiLspQueryResponse {
3845 responses: all_actions
3846 .map(|code_actions| proto::LspResponse {
3847 response: Some(proto::lsp_response::Response::GetCodeActionsResponse(
3848 GetCodeActions::response_to_proto(
3849 code_actions,
3850 project,
3851 sender_id,
3852 &buffer_version,
3853 cx,
3854 ),
3855 )),
3856 })
3857 .collect(),
3858 })
3859 }
3860 Some(proto::multi_lsp_query::Request::GetSignatureHelp(get_signature_help)) => {
3861 let get_signature_help = GetSignatureHelp::from_proto(
3862 get_signature_help,
3863 this.clone(),
3864 buffer.clone(),
3865 cx.clone(),
3866 )
3867 .await?;
3868
3869 let all_signatures = this
3870 .update(&mut cx, |project, cx| {
3871 project.request_multiple_lsp_locally(
3872 &buffer,
3873 Some(get_signature_help.position),
3874 get_signature_help,
3875 cx,
3876 )
3877 })?
3878 .await
3879 .into_iter();
3880
3881 this.update(&mut cx, |project, cx| proto::MultiLspQueryResponse {
3882 responses: all_signatures
3883 .map(|signature_help| proto::LspResponse {
3884 response: Some(
3885 proto::lsp_response::Response::GetSignatureHelpResponse(
3886 GetSignatureHelp::response_to_proto(
3887 signature_help,
3888 project,
3889 sender_id,
3890 &buffer_version,
3891 cx,
3892 ),
3893 ),
3894 ),
3895 })
3896 .collect(),
3897 })
3898 }
3899 None => anyhow::bail!("empty multi lsp query request"),
3900 }
3901 }
3902
3903 async fn handle_apply_code_action(
3904 this: Model<Self>,
3905 envelope: TypedEnvelope<proto::ApplyCodeAction>,
3906 mut cx: AsyncAppContext,
3907 ) -> Result<proto::ApplyCodeActionResponse> {
3908 let sender_id = envelope.original_sender_id().unwrap_or_default();
3909 let action = Self::deserialize_code_action(
3910 envelope
3911 .payload
3912 .action
3913 .ok_or_else(|| anyhow!("invalid action"))?,
3914 )?;
3915 let apply_code_action = this.update(&mut cx, |this, cx| {
3916 let buffer_id = BufferId::new(envelope.payload.buffer_id)?;
3917 let buffer = this.buffer_store.read(cx).get_existing(buffer_id)?;
3918 anyhow::Ok(this.apply_code_action(buffer, action, false, cx))
3919 })??;
3920
3921 let project_transaction = apply_code_action.await?;
3922 let project_transaction = this.update(&mut cx, |this, cx| {
3923 this.buffer_store.update(cx, |buffer_store, cx| {
3924 buffer_store.serialize_project_transaction_for_peer(
3925 project_transaction,
3926 sender_id,
3927 cx,
3928 )
3929 })
3930 })?;
3931 Ok(proto::ApplyCodeActionResponse {
3932 transaction: Some(project_transaction),
3933 })
3934 }
3935
3936 async fn handle_update_diagnostic_summary(
3937 this: Model<Self>,
3938 envelope: TypedEnvelope<proto::UpdateDiagnosticSummary>,
3939 mut cx: AsyncAppContext,
3940 ) -> Result<()> {
3941 this.update(&mut cx, |this, cx| {
3942 let worktree_id = WorktreeId::from_proto(envelope.payload.worktree_id);
3943 if let Some(message) = envelope.payload.summary {
3944 let project_path = ProjectPath {
3945 worktree_id,
3946 path: Path::new(&message.path).into(),
3947 };
3948 let path = project_path.path.clone();
3949 let server_id = LanguageServerId(message.language_server_id as usize);
3950 let summary = DiagnosticSummary {
3951 error_count: message.error_count as usize,
3952 warning_count: message.warning_count as usize,
3953 };
3954
3955 if summary.is_empty() {
3956 if let Some(worktree_summaries) =
3957 this.diagnostic_summaries.get_mut(&worktree_id)
3958 {
3959 if let Some(summaries) = worktree_summaries.get_mut(&path) {
3960 summaries.remove(&server_id);
3961 if summaries.is_empty() {
3962 worktree_summaries.remove(&path);
3963 }
3964 }
3965 }
3966 } else {
3967 this.diagnostic_summaries
3968 .entry(worktree_id)
3969 .or_default()
3970 .entry(path)
3971 .or_default()
3972 .insert(server_id, summary);
3973 }
3974 cx.emit(LspStoreEvent::DiagnosticsUpdated {
3975 language_server_id: LanguageServerId(message.language_server_id as usize),
3976 path: project_path,
3977 });
3978 }
3979 Ok(())
3980 })?
3981 }
3982
3983 async fn handle_start_language_server(
3984 this: Model<Self>,
3985 envelope: TypedEnvelope<proto::StartLanguageServer>,
3986 mut cx: AsyncAppContext,
3987 ) -> Result<()> {
3988 let server = envelope
3989 .payload
3990 .server
3991 .ok_or_else(|| anyhow!("invalid server"))?;
3992
3993 this.update(&mut cx, |this, cx| {
3994 let server_id = LanguageServerId(server.id as usize);
3995 this.language_server_statuses.insert(
3996 server_id,
3997 LanguageServerStatus {
3998 name: server.name.clone(),
3999 pending_work: Default::default(),
4000 has_pending_diagnostic_updates: false,
4001 progress_tokens: Default::default(),
4002 },
4003 );
4004 cx.emit(LspStoreEvent::LanguageServerAdded(
4005 server_id,
4006 LanguageServerName(server.name.into()),
4007 server.worktree_id.map(WorktreeId::from_proto),
4008 ));
4009 cx.notify();
4010 })?;
4011 Ok(())
4012 }
4013
4014 async fn handle_update_language_server(
4015 this: Model<Self>,
4016 envelope: TypedEnvelope<proto::UpdateLanguageServer>,
4017 mut cx: AsyncAppContext,
4018 ) -> Result<()> {
4019 this.update(&mut cx, |this, cx| {
4020 let language_server_id = LanguageServerId(envelope.payload.language_server_id as usize);
4021
4022 match envelope
4023 .payload
4024 .variant
4025 .ok_or_else(|| anyhow!("invalid variant"))?
4026 {
4027 proto::update_language_server::Variant::WorkStart(payload) => {
4028 this.on_lsp_work_start(
4029 language_server_id,
4030 payload.token,
4031 LanguageServerProgress {
4032 title: payload.title,
4033 is_disk_based_diagnostics_progress: false,
4034 is_cancellable: false,
4035 message: payload.message,
4036 percentage: payload.percentage.map(|p| p as usize),
4037 last_update_at: cx.background_executor().now(),
4038 },
4039 cx,
4040 );
4041 }
4042
4043 proto::update_language_server::Variant::WorkProgress(payload) => {
4044 this.on_lsp_work_progress(
4045 language_server_id,
4046 payload.token,
4047 LanguageServerProgress {
4048 title: None,
4049 is_disk_based_diagnostics_progress: false,
4050 is_cancellable: false,
4051 message: payload.message,
4052 percentage: payload.percentage.map(|p| p as usize),
4053 last_update_at: cx.background_executor().now(),
4054 },
4055 cx,
4056 );
4057 }
4058
4059 proto::update_language_server::Variant::WorkEnd(payload) => {
4060 this.on_lsp_work_end(language_server_id, payload.token, cx);
4061 }
4062
4063 proto::update_language_server::Variant::DiskBasedDiagnosticsUpdating(_) => {
4064 this.disk_based_diagnostics_started(language_server_id, cx);
4065 }
4066
4067 proto::update_language_server::Variant::DiskBasedDiagnosticsUpdated(_) => {
4068 this.disk_based_diagnostics_finished(language_server_id, cx)
4069 }
4070 }
4071
4072 Ok(())
4073 })?
4074 }
4075
4076 async fn handle_language_server_log(
4077 this: Model<Self>,
4078 envelope: TypedEnvelope<proto::LanguageServerLog>,
4079 mut cx: AsyncAppContext,
4080 ) -> Result<()> {
4081 let language_server_id = LanguageServerId(envelope.payload.language_server_id as usize);
4082 let log_type = envelope
4083 .payload
4084 .log_type
4085 .map(LanguageServerLogType::from_proto)
4086 .context("invalid language server log type")?;
4087
4088 let message = envelope.payload.message;
4089
4090 this.update(&mut cx, |_, cx| {
4091 cx.emit(LspStoreEvent::LanguageServerLog(
4092 language_server_id,
4093 log_type,
4094 message,
4095 ));
4096 })
4097 }
4098
4099 pub fn disk_based_diagnostics_started(
4100 &mut self,
4101 language_server_id: LanguageServerId,
4102 cx: &mut ModelContext<Self>,
4103 ) {
4104 if let Some(language_server_status) =
4105 self.language_server_statuses.get_mut(&language_server_id)
4106 {
4107 language_server_status.has_pending_diagnostic_updates = true;
4108 }
4109
4110 cx.emit(LspStoreEvent::DiskBasedDiagnosticsStarted { language_server_id });
4111 cx.emit(LspStoreEvent::LanguageServerUpdate {
4112 language_server_id,
4113 message: proto::update_language_server::Variant::DiskBasedDiagnosticsUpdating(
4114 Default::default(),
4115 ),
4116 })
4117 }
4118
4119 pub fn disk_based_diagnostics_finished(
4120 &mut self,
4121 language_server_id: LanguageServerId,
4122 cx: &mut ModelContext<Self>,
4123 ) {
4124 if let Some(language_server_status) =
4125 self.language_server_statuses.get_mut(&language_server_id)
4126 {
4127 language_server_status.has_pending_diagnostic_updates = false;
4128 }
4129
4130 cx.emit(LspStoreEvent::DiskBasedDiagnosticsFinished { language_server_id });
4131 cx.emit(LspStoreEvent::LanguageServerUpdate {
4132 language_server_id,
4133 message: proto::update_language_server::Variant::DiskBasedDiagnosticsUpdated(
4134 Default::default(),
4135 ),
4136 })
4137 }
4138
4139 // After saving a buffer using a language server that doesn't provide a disk-based progress token,
4140 // kick off a timer that will reset every time the buffer is saved. If the timer eventually fires,
4141 // simulate disk-based diagnostics being finished so that other pieces of UI (e.g., project
4142 // diagnostics view, diagnostic status bar) can update. We don't emit an event right away because
4143 // the language server might take some time to publish diagnostics.
4144 fn simulate_disk_based_diagnostics_events_if_needed(
4145 &mut self,
4146 language_server_id: LanguageServerId,
4147 cx: &mut ModelContext<Self>,
4148 ) {
4149 const DISK_BASED_DIAGNOSTICS_DEBOUNCE: Duration = Duration::from_secs(1);
4150
4151 let Some(LanguageServerState::Running {
4152 simulate_disk_based_diagnostics_completion,
4153 adapter,
4154 ..
4155 }) = self
4156 .as_local_mut()
4157 .and_then(|local_store| local_store.language_servers.get_mut(&language_server_id))
4158 else {
4159 return;
4160 };
4161
4162 if adapter.disk_based_diagnostics_progress_token.is_some() {
4163 return;
4164 }
4165
4166 let prev_task = simulate_disk_based_diagnostics_completion.replace(cx.spawn(
4167 move |this, mut cx| async move {
4168 cx.background_executor()
4169 .timer(DISK_BASED_DIAGNOSTICS_DEBOUNCE)
4170 .await;
4171
4172 this.update(&mut cx, |this, cx| {
4173 this.disk_based_diagnostics_finished(language_server_id, cx);
4174
4175 if let Some(LanguageServerState::Running {
4176 simulate_disk_based_diagnostics_completion,
4177 ..
4178 }) = this.as_local_mut().and_then(|local_store| {
4179 local_store.language_servers.get_mut(&language_server_id)
4180 }) {
4181 *simulate_disk_based_diagnostics_completion = None;
4182 }
4183 })
4184 .ok();
4185 },
4186 ));
4187
4188 if prev_task.is_none() {
4189 self.disk_based_diagnostics_started(language_server_id, cx);
4190 }
4191 }
4192
4193 pub fn language_server_statuses(
4194 &self,
4195 ) -> impl DoubleEndedIterator<Item = (LanguageServerId, &LanguageServerStatus)> {
4196 self.language_server_statuses
4197 .iter()
4198 .map(|(key, value)| (*key, value))
4199 }
4200
4201 fn lsp_notify_abs_paths_changed(
4202 &mut self,
4203 server_id: LanguageServerId,
4204 changes: Vec<PathEvent>,
4205 ) {
4206 maybe!({
4207 let server = self.language_server_for_id(server_id)?;
4208 let changes = changes
4209 .into_iter()
4210 .filter_map(|event| {
4211 let typ = match event.kind? {
4212 PathEventKind::Created => lsp::FileChangeType::CREATED,
4213 PathEventKind::Removed => lsp::FileChangeType::DELETED,
4214 PathEventKind::Changed => lsp::FileChangeType::CHANGED,
4215 };
4216 Some(lsp::FileEvent {
4217 uri: lsp::Url::from_file_path(&event.path).ok()?,
4218 typ,
4219 })
4220 })
4221 .collect::<Vec<_>>();
4222 if !changes.is_empty() {
4223 server
4224 .notify::<lsp::notification::DidChangeWatchedFiles>(
4225 lsp::DidChangeWatchedFilesParams { changes },
4226 )
4227 .log_err();
4228 }
4229 Some(())
4230 });
4231 }
4232
4233 fn rebuild_watched_paths(
4234 &mut self,
4235 language_server_id: LanguageServerId,
4236 cx: &mut ModelContext<Self>,
4237 ) {
4238 let worktrees = self
4239 .worktree_store
4240 .read(cx)
4241 .worktrees()
4242 .filter_map(|worktree| {
4243 self.language_servers_for_worktree(worktree.read(cx).id())
4244 .find(|server| server.server_id() == language_server_id)
4245 .map(|_| worktree)
4246 })
4247 .collect::<Vec<_>>();
4248
4249 let local_lsp_store = self.as_local_mut().unwrap();
4250
4251 let Some(watchers) = local_lsp_store
4252 .language_server_watcher_registrations
4253 .get(&language_server_id)
4254 else {
4255 return;
4256 };
4257
4258 let mut worktree_globs = HashMap::default();
4259 let mut abs_globs = HashMap::default();
4260 log::trace!(
4261 "Processing new watcher paths for language server with id {}",
4262 language_server_id
4263 );
4264
4265 enum PathToWatch {
4266 Worktree {
4267 literal_prefix: Arc<Path>,
4268 pattern: String,
4269 },
4270 Absolute {
4271 path: Arc<Path>,
4272 pattern: String,
4273 },
4274 }
4275 for watcher in watchers.values().flatten() {
4276 let mut found_host = false;
4277 for worktree in &worktrees {
4278 let glob_is_inside_worktree = worktree.update(cx, |tree, _| {
4279 if let Some(worktree_root_path) = tree.abs_path().to_str() {
4280 let path_to_watch = match &watcher.glob_pattern {
4281 lsp::GlobPattern::String(s) => {
4282 match s.strip_prefix(worktree_root_path) {
4283 Some(relative) => {
4284 let pattern = relative
4285 .strip_prefix(std::path::MAIN_SEPARATOR)
4286 .unwrap_or(relative)
4287 .to_owned();
4288 let literal_prefix = glob_literal_prefix(&pattern);
4289
4290 let literal_prefix = Arc::from(PathBuf::from(
4291 literal_prefix
4292 .strip_prefix(std::path::MAIN_SEPARATOR)
4293 .unwrap_or(literal_prefix),
4294 ));
4295 PathToWatch::Worktree {
4296 literal_prefix,
4297 pattern,
4298 }
4299 }
4300 None => {
4301 let path = glob_literal_prefix(s);
4302 let glob = &s[path.len()..];
4303 let pattern = glob
4304 .strip_prefix(std::path::MAIN_SEPARATOR)
4305 .unwrap_or(glob)
4306 .to_owned();
4307 let path = if Path::new(path).components().next().is_none()
4308 {
4309 Arc::from(Path::new(worktree_root_path))
4310 } else {
4311 PathBuf::from(path).into()
4312 };
4313
4314 PathToWatch::Absolute { path, pattern }
4315 }
4316 }
4317 }
4318 lsp::GlobPattern::Relative(rp) => {
4319 let Ok(mut base_uri) = match &rp.base_uri {
4320 lsp::OneOf::Left(workspace_folder) => &workspace_folder.uri,
4321 lsp::OneOf::Right(base_uri) => base_uri,
4322 }
4323 .to_file_path() else {
4324 return false;
4325 };
4326
4327 match base_uri.strip_prefix(worktree_root_path) {
4328 Ok(relative) => {
4329 let mut literal_prefix = relative.to_owned();
4330 literal_prefix.push(glob_literal_prefix(&rp.pattern));
4331
4332 PathToWatch::Worktree {
4333 literal_prefix: literal_prefix.into(),
4334 pattern: rp.pattern.clone(),
4335 }
4336 }
4337 Err(_) => {
4338 let path = glob_literal_prefix(&rp.pattern);
4339 let glob = &rp.pattern[path.len()..];
4340 let pattern = glob
4341 .strip_prefix(std::path::MAIN_SEPARATOR)
4342 .unwrap_or(glob)
4343 .to_owned();
4344 base_uri.push(path);
4345
4346 let path = if base_uri.components().next().is_none() {
4347 Arc::from(Path::new("/"))
4348 } else {
4349 base_uri.into()
4350 };
4351 PathToWatch::Absolute { path, pattern }
4352 }
4353 }
4354 }
4355 };
4356 match path_to_watch {
4357 PathToWatch::Worktree {
4358 literal_prefix,
4359 pattern,
4360 } => {
4361 if let Some((tree, glob)) =
4362 tree.as_local_mut().zip(Glob::new(&pattern).log_err())
4363 {
4364 tree.add_path_prefix_to_scan(literal_prefix);
4365 worktree_globs
4366 .entry(tree.id())
4367 .or_insert_with(GlobSetBuilder::new)
4368 .add(glob);
4369 } else {
4370 return false;
4371 }
4372 }
4373 PathToWatch::Absolute { path, pattern } => {
4374 if let Some(glob) = Glob::new(&pattern).log_err() {
4375 abs_globs
4376 .entry(path)
4377 .or_insert_with(GlobSetBuilder::new)
4378 .add(glob);
4379 }
4380 }
4381 }
4382 return true;
4383 }
4384 false
4385 });
4386 if glob_is_inside_worktree {
4387 log::trace!(
4388 "Watcher pattern `{}` has been attached to the worktree at `{}`",
4389 serde_json::to_string(&watcher.glob_pattern).unwrap(),
4390 worktree.read(cx).abs_path().display()
4391 );
4392 found_host = true;
4393 }
4394 }
4395 if !found_host {
4396 log::error!(
4397 "Watcher pattern `{}` has not been attached to any worktree or absolute path",
4398 serde_json::to_string(&watcher.glob_pattern).unwrap()
4399 )
4400 }
4401 }
4402
4403 let mut watch_builder = LanguageServerWatchedPathsBuilder::default();
4404 for (worktree_id, builder) in worktree_globs {
4405 if let Ok(globset) = builder.build() {
4406 watch_builder.watch_worktree(worktree_id, globset);
4407 }
4408 }
4409 for (abs_path, builder) in abs_globs {
4410 if let Ok(globset) = builder.build() {
4411 watch_builder.watch_abs_path(abs_path, globset);
4412 }
4413 }
4414 let watcher = watch_builder.build(local_lsp_store.fs.clone(), language_server_id, cx);
4415 local_lsp_store
4416 .language_server_watched_paths
4417 .insert(language_server_id, watcher);
4418
4419 cx.notify();
4420 }
4421
4422 pub fn language_server_for_id(&self, id: LanguageServerId) -> Option<Arc<LanguageServer>> {
4423 if let Some(local_lsp_store) = self.as_local() {
4424 if let Some(LanguageServerState::Running { server, .. }) =
4425 local_lsp_store.language_servers.get(&id)
4426 {
4427 Some(server.clone())
4428 } else if let Some((_, server)) =
4429 local_lsp_store.supplementary_language_servers.get(&id)
4430 {
4431 Some(Arc::clone(server))
4432 } else {
4433 None
4434 }
4435 } else {
4436 None
4437 }
4438 }
4439
4440 async fn on_lsp_workspace_edit(
4441 this: WeakModel<Self>,
4442 params: lsp::ApplyWorkspaceEditParams,
4443 server_id: LanguageServerId,
4444 adapter: Arc<CachedLspAdapter>,
4445 mut cx: AsyncAppContext,
4446 ) -> Result<lsp::ApplyWorkspaceEditResponse> {
4447 let this = this
4448 .upgrade()
4449 .ok_or_else(|| anyhow!("project project closed"))?;
4450 let language_server = this
4451 .update(&mut cx, |this, _| this.language_server_for_id(server_id))?
4452 .ok_or_else(|| anyhow!("language server not found"))?;
4453 let transaction = Self::deserialize_workspace_edit(
4454 this.clone(),
4455 params.edit,
4456 true,
4457 adapter.clone(),
4458 language_server.clone(),
4459 &mut cx,
4460 )
4461 .await
4462 .log_err();
4463 this.update(&mut cx, |this, _| {
4464 if let Some(transaction) = transaction {
4465 this.as_local_mut()
4466 .unwrap()
4467 .last_workspace_edits_by_language_server
4468 .insert(server_id, transaction);
4469 }
4470 })?;
4471 Ok(lsp::ApplyWorkspaceEditResponse {
4472 applied: true,
4473 failed_change: None,
4474 failure_reason: None,
4475 })
4476 }
4477
4478 fn on_lsp_progress(
4479 &mut self,
4480 progress: lsp::ProgressParams,
4481 language_server_id: LanguageServerId,
4482 disk_based_diagnostics_progress_token: Option<String>,
4483 cx: &mut ModelContext<Self>,
4484 ) {
4485 let token = match progress.token {
4486 lsp::NumberOrString::String(token) => token,
4487 lsp::NumberOrString::Number(token) => {
4488 log::info!("skipping numeric progress token {}", token);
4489 return;
4490 }
4491 };
4492
4493 let lsp::ProgressParamsValue::WorkDone(progress) = progress.value;
4494 let language_server_status =
4495 if let Some(status) = self.language_server_statuses.get_mut(&language_server_id) {
4496 status
4497 } else {
4498 return;
4499 };
4500
4501 if !language_server_status.progress_tokens.contains(&token) {
4502 return;
4503 }
4504
4505 let is_disk_based_diagnostics_progress = disk_based_diagnostics_progress_token
4506 .as_ref()
4507 .map_or(false, |disk_based_token| {
4508 token.starts_with(disk_based_token)
4509 });
4510
4511 match progress {
4512 lsp::WorkDoneProgress::Begin(report) => {
4513 if is_disk_based_diagnostics_progress {
4514 self.disk_based_diagnostics_started(language_server_id, cx);
4515 }
4516 self.on_lsp_work_start(
4517 language_server_id,
4518 token.clone(),
4519 LanguageServerProgress {
4520 title: Some(report.title),
4521 is_disk_based_diagnostics_progress,
4522 is_cancellable: report.cancellable.unwrap_or(false),
4523 message: report.message.clone(),
4524 percentage: report.percentage.map(|p| p as usize),
4525 last_update_at: cx.background_executor().now(),
4526 },
4527 cx,
4528 );
4529 }
4530 lsp::WorkDoneProgress::Report(report) => {
4531 if self.on_lsp_work_progress(
4532 language_server_id,
4533 token.clone(),
4534 LanguageServerProgress {
4535 title: None,
4536 is_disk_based_diagnostics_progress,
4537 is_cancellable: report.cancellable.unwrap_or(false),
4538 message: report.message.clone(),
4539 percentage: report.percentage.map(|p| p as usize),
4540 last_update_at: cx.background_executor().now(),
4541 },
4542 cx,
4543 ) {
4544 cx.emit(LspStoreEvent::LanguageServerUpdate {
4545 language_server_id,
4546 message: proto::update_language_server::Variant::WorkProgress(
4547 proto::LspWorkProgress {
4548 token,
4549 message: report.message,
4550 percentage: report.percentage,
4551 },
4552 ),
4553 })
4554 }
4555 }
4556 lsp::WorkDoneProgress::End(_) => {
4557 language_server_status.progress_tokens.remove(&token);
4558 self.on_lsp_work_end(language_server_id, token.clone(), cx);
4559 if is_disk_based_diagnostics_progress {
4560 self.disk_based_diagnostics_finished(language_server_id, cx);
4561 }
4562 }
4563 }
4564 }
4565
4566 fn on_lsp_work_start(
4567 &mut self,
4568 language_server_id: LanguageServerId,
4569 token: String,
4570 progress: LanguageServerProgress,
4571 cx: &mut ModelContext<Self>,
4572 ) {
4573 if let Some(status) = self.language_server_statuses.get_mut(&language_server_id) {
4574 status.pending_work.insert(token.clone(), progress.clone());
4575 cx.notify();
4576 }
4577 cx.emit(LspStoreEvent::LanguageServerUpdate {
4578 language_server_id,
4579 message: proto::update_language_server::Variant::WorkStart(proto::LspWorkStart {
4580 token,
4581 title: progress.title,
4582 message: progress.message,
4583 percentage: progress.percentage.map(|p| p as u32),
4584 }),
4585 })
4586 }
4587
4588 fn on_lsp_work_progress(
4589 &mut self,
4590 language_server_id: LanguageServerId,
4591 token: String,
4592 progress: LanguageServerProgress,
4593 cx: &mut ModelContext<Self>,
4594 ) -> bool {
4595 if let Some(status) = self.language_server_statuses.get_mut(&language_server_id) {
4596 match status.pending_work.entry(token) {
4597 btree_map::Entry::Vacant(entry) => {
4598 entry.insert(progress);
4599 cx.notify();
4600 return true;
4601 }
4602 btree_map::Entry::Occupied(mut entry) => {
4603 let entry = entry.get_mut();
4604 if (progress.last_update_at - entry.last_update_at)
4605 >= SERVER_PROGRESS_THROTTLE_TIMEOUT
4606 {
4607 entry.last_update_at = progress.last_update_at;
4608 if progress.message.is_some() {
4609 entry.message = progress.message;
4610 }
4611 if progress.percentage.is_some() {
4612 entry.percentage = progress.percentage;
4613 }
4614 cx.notify();
4615 return true;
4616 }
4617 }
4618 }
4619 }
4620
4621 false
4622 }
4623
4624 fn on_lsp_work_end(
4625 &mut self,
4626 language_server_id: LanguageServerId,
4627 token: String,
4628 cx: &mut ModelContext<Self>,
4629 ) {
4630 if let Some(status) = self.language_server_statuses.get_mut(&language_server_id) {
4631 if let Some(work) = status.pending_work.remove(&token) {
4632 if !work.is_disk_based_diagnostics_progress {
4633 cx.emit(LspStoreEvent::RefreshInlayHints);
4634 }
4635 }
4636 cx.notify();
4637 }
4638
4639 cx.emit(LspStoreEvent::LanguageServerUpdate {
4640 language_server_id,
4641 message: proto::update_language_server::Variant::WorkEnd(proto::LspWorkEnd { token }),
4642 })
4643 }
4644
4645 fn on_lsp_did_change_watched_files(
4646 &mut self,
4647 language_server_id: LanguageServerId,
4648 registration_id: &str,
4649 params: DidChangeWatchedFilesRegistrationOptions,
4650 cx: &mut ModelContext<Self>,
4651 ) {
4652 if let Some(local) = self.as_local_mut() {
4653 let registrations = local
4654 .language_server_watcher_registrations
4655 .entry(language_server_id)
4656 .or_default();
4657
4658 registrations.insert(registration_id.to_string(), params.watchers);
4659
4660 self.rebuild_watched_paths(language_server_id, cx);
4661 }
4662 }
4663
4664 fn on_lsp_unregister_did_change_watched_files(
4665 &mut self,
4666 language_server_id: LanguageServerId,
4667 registration_id: &str,
4668 cx: &mut ModelContext<Self>,
4669 ) {
4670 if let Some(local) = self.as_local_mut() {
4671 let registrations = local
4672 .language_server_watcher_registrations
4673 .entry(language_server_id)
4674 .or_default();
4675
4676 if registrations.remove(registration_id).is_some() {
4677 log::info!(
4678 "language server {}: unregistered workspace/DidChangeWatchedFiles capability with id {}",
4679 language_server_id,
4680 registration_id
4681 );
4682 } else {
4683 log::warn!(
4684 "language server {}: failed to unregister workspace/DidChangeWatchedFiles capability with id {}. not registered.",
4685 language_server_id,
4686 registration_id
4687 );
4688 }
4689
4690 self.rebuild_watched_paths(language_server_id, cx);
4691 }
4692 }
4693
4694 #[allow(clippy::type_complexity)]
4695 pub(crate) fn edits_from_lsp(
4696 &mut self,
4697 buffer: &Model<Buffer>,
4698 lsp_edits: impl 'static + Send + IntoIterator<Item = lsp::TextEdit>,
4699 server_id: LanguageServerId,
4700 version: Option<i32>,
4701 cx: &mut ModelContext<Self>,
4702 ) -> Task<Result<Vec<(Range<Anchor>, String)>>> {
4703 let snapshot = self.buffer_snapshot_for_lsp_version(buffer, server_id, version, cx);
4704 cx.background_executor().spawn(async move {
4705 let snapshot = snapshot?;
4706 let mut lsp_edits = lsp_edits
4707 .into_iter()
4708 .map(|edit| (range_from_lsp(edit.range), edit.new_text))
4709 .collect::<Vec<_>>();
4710 lsp_edits.sort_by_key(|(range, _)| range.start);
4711
4712 let mut lsp_edits = lsp_edits.into_iter().peekable();
4713 let mut edits = Vec::new();
4714 while let Some((range, mut new_text)) = lsp_edits.next() {
4715 // Clip invalid ranges provided by the language server.
4716 let mut range = snapshot.clip_point_utf16(range.start, Bias::Left)
4717 ..snapshot.clip_point_utf16(range.end, Bias::Left);
4718
4719 // Combine any LSP edits that are adjacent.
4720 //
4721 // Also, combine LSP edits that are separated from each other by only
4722 // a newline. This is important because for some code actions,
4723 // Rust-analyzer rewrites the entire buffer via a series of edits that
4724 // are separated by unchanged newline characters.
4725 //
4726 // In order for the diffing logic below to work properly, any edits that
4727 // cancel each other out must be combined into one.
4728 while let Some((next_range, next_text)) = lsp_edits.peek() {
4729 if next_range.start.0 > range.end {
4730 if next_range.start.0.row > range.end.row + 1
4731 || next_range.start.0.column > 0
4732 || snapshot.clip_point_utf16(
4733 Unclipped(PointUtf16::new(range.end.row, u32::MAX)),
4734 Bias::Left,
4735 ) > range.end
4736 {
4737 break;
4738 }
4739 new_text.push('\n');
4740 }
4741 range.end = snapshot.clip_point_utf16(next_range.end, Bias::Left);
4742 new_text.push_str(next_text);
4743 lsp_edits.next();
4744 }
4745
4746 // For multiline edits, perform a diff of the old and new text so that
4747 // we can identify the changes more precisely, preserving the locations
4748 // of any anchors positioned in the unchanged regions.
4749 if range.end.row > range.start.row {
4750 let mut offset = range.start.to_offset(&snapshot);
4751 let old_text = snapshot.text_for_range(range).collect::<String>();
4752
4753 let diff = TextDiff::from_lines(old_text.as_str(), &new_text);
4754 let mut moved_since_edit = true;
4755 for change in diff.iter_all_changes() {
4756 let tag = change.tag();
4757 let value = change.value();
4758 match tag {
4759 ChangeTag::Equal => {
4760 offset += value.len();
4761 moved_since_edit = true;
4762 }
4763 ChangeTag::Delete => {
4764 let start = snapshot.anchor_after(offset);
4765 let end = snapshot.anchor_before(offset + value.len());
4766 if moved_since_edit {
4767 edits.push((start..end, String::new()));
4768 } else {
4769 edits.last_mut().unwrap().0.end = end;
4770 }
4771 offset += value.len();
4772 moved_since_edit = false;
4773 }
4774 ChangeTag::Insert => {
4775 if moved_since_edit {
4776 let anchor = snapshot.anchor_after(offset);
4777 edits.push((anchor..anchor, value.to_string()));
4778 } else {
4779 edits.last_mut().unwrap().1.push_str(value);
4780 }
4781 moved_since_edit = false;
4782 }
4783 }
4784 }
4785 } else if range.end == range.start {
4786 let anchor = snapshot.anchor_after(range.start);
4787 edits.push((anchor..anchor, new_text));
4788 } else {
4789 let edit_start = snapshot.anchor_after(range.start);
4790 let edit_end = snapshot.anchor_before(range.end);
4791 edits.push((edit_start..edit_end, new_text));
4792 }
4793 }
4794
4795 Ok(edits)
4796 })
4797 }
4798
4799 pub async fn handle_resolve_completion_documentation(
4800 this: Model<Self>,
4801 envelope: TypedEnvelope<proto::ResolveCompletionDocumentation>,
4802 mut cx: AsyncAppContext,
4803 ) -> Result<proto::ResolveCompletionDocumentationResponse> {
4804 let lsp_completion = serde_json::from_slice(&envelope.payload.lsp_completion)?;
4805
4806 let completion = this
4807 .read_with(&cx, |this, cx| {
4808 let id = LanguageServerId(envelope.payload.language_server_id as usize);
4809 let Some(server) = this.language_server_for_id(id) else {
4810 return Err(anyhow!("No language server {id}"));
4811 };
4812
4813 Ok(cx.background_executor().spawn(async move {
4814 let can_resolve = server
4815 .capabilities()
4816 .completion_provider
4817 .as_ref()
4818 .and_then(|options| options.resolve_provider)
4819 .unwrap_or(false);
4820 if can_resolve {
4821 server
4822 .request::<lsp::request::ResolveCompletionItem>(lsp_completion)
4823 .await
4824 } else {
4825 anyhow::Ok(lsp_completion)
4826 }
4827 }))
4828 })??
4829 .await?;
4830
4831 let mut documentation_is_markdown = false;
4832 let lsp_completion = serde_json::to_string(&completion)?.into_bytes();
4833 let documentation = match completion.documentation {
4834 Some(lsp::Documentation::String(text)) => text,
4835
4836 Some(lsp::Documentation::MarkupContent(lsp::MarkupContent { kind, value })) => {
4837 documentation_is_markdown = kind == lsp::MarkupKind::Markdown;
4838 value
4839 }
4840
4841 _ => String::new(),
4842 };
4843
4844 // If we have a new buffer_id, that means we're talking to a new client
4845 // and want to check for new text_edits in the completion too.
4846 let mut old_start = None;
4847 let mut old_end = None;
4848 let mut new_text = String::default();
4849 if let Ok(buffer_id) = BufferId::new(envelope.payload.buffer_id) {
4850 let buffer_snapshot = this.update(&mut cx, |this, cx| {
4851 let buffer = this.buffer_store.read(cx).get_existing(buffer_id)?;
4852 anyhow::Ok(buffer.read(cx).snapshot())
4853 })??;
4854
4855 if let Some(text_edit) = completion.text_edit.as_ref() {
4856 let edit = parse_completion_text_edit(text_edit, &buffer_snapshot);
4857
4858 if let Some((old_range, mut text_edit_new_text)) = edit {
4859 LineEnding::normalize(&mut text_edit_new_text);
4860
4861 new_text = text_edit_new_text;
4862 old_start = Some(serialize_anchor(&old_range.start));
4863 old_end = Some(serialize_anchor(&old_range.end));
4864 }
4865 }
4866 }
4867
4868 Ok(proto::ResolveCompletionDocumentationResponse {
4869 documentation,
4870 documentation_is_markdown,
4871 old_start,
4872 old_end,
4873 new_text,
4874 lsp_completion,
4875 })
4876 }
4877
4878 async fn handle_on_type_formatting(
4879 this: Model<Self>,
4880 envelope: TypedEnvelope<proto::OnTypeFormatting>,
4881 mut cx: AsyncAppContext,
4882 ) -> Result<proto::OnTypeFormattingResponse> {
4883 let on_type_formatting = this.update(&mut cx, |this, cx| {
4884 let buffer_id = BufferId::new(envelope.payload.buffer_id)?;
4885 let buffer = this.buffer_store.read(cx).get_existing(buffer_id)?;
4886 let position = envelope
4887 .payload
4888 .position
4889 .and_then(deserialize_anchor)
4890 .ok_or_else(|| anyhow!("invalid position"))?;
4891 Ok::<_, anyhow::Error>(this.apply_on_type_formatting(
4892 buffer,
4893 position,
4894 envelope.payload.trigger.clone(),
4895 cx,
4896 ))
4897 })??;
4898
4899 let transaction = on_type_formatting
4900 .await?
4901 .as_ref()
4902 .map(language::proto::serialize_transaction);
4903 Ok(proto::OnTypeFormattingResponse { transaction })
4904 }
4905
4906 async fn handle_refresh_inlay_hints(
4907 this: Model<Self>,
4908 _: TypedEnvelope<proto::RefreshInlayHints>,
4909 mut cx: AsyncAppContext,
4910 ) -> Result<proto::Ack> {
4911 this.update(&mut cx, |_, cx| {
4912 cx.emit(LspStoreEvent::RefreshInlayHints);
4913 })?;
4914 Ok(proto::Ack {})
4915 }
4916
4917 async fn handle_inlay_hints(
4918 this: Model<Self>,
4919 envelope: TypedEnvelope<proto::InlayHints>,
4920 mut cx: AsyncAppContext,
4921 ) -> Result<proto::InlayHintsResponse> {
4922 let sender_id = envelope.original_sender_id().unwrap_or_default();
4923 let buffer_id = BufferId::new(envelope.payload.buffer_id)?;
4924 let buffer = this.update(&mut cx, |this, cx| {
4925 this.buffer_store.read(cx).get_existing(buffer_id)
4926 })??;
4927 buffer
4928 .update(&mut cx, |buffer, _| {
4929 buffer.wait_for_version(deserialize_version(&envelope.payload.version))
4930 })?
4931 .await
4932 .with_context(|| format!("waiting for version for buffer {}", buffer.entity_id()))?;
4933
4934 let start = envelope
4935 .payload
4936 .start
4937 .and_then(deserialize_anchor)
4938 .context("missing range start")?;
4939 let end = envelope
4940 .payload
4941 .end
4942 .and_then(deserialize_anchor)
4943 .context("missing range end")?;
4944 let buffer_hints = this
4945 .update(&mut cx, |lsp_store, cx| {
4946 lsp_store.inlay_hints(buffer.clone(), start..end, cx)
4947 })?
4948 .await
4949 .context("inlay hints fetch")?;
4950
4951 this.update(&mut cx, |project, cx| {
4952 InlayHints::response_to_proto(
4953 buffer_hints,
4954 project,
4955 sender_id,
4956 &buffer.read(cx).version(),
4957 cx,
4958 )
4959 })
4960 }
4961
4962 async fn handle_resolve_inlay_hint(
4963 this: Model<Self>,
4964 envelope: TypedEnvelope<proto::ResolveInlayHint>,
4965 mut cx: AsyncAppContext,
4966 ) -> Result<proto::ResolveInlayHintResponse> {
4967 let proto_hint = envelope
4968 .payload
4969 .hint
4970 .expect("incorrect protobuf resolve inlay hint message: missing the inlay hint");
4971 let hint = InlayHints::proto_to_project_hint(proto_hint)
4972 .context("resolved proto inlay hint conversion")?;
4973 let buffer = this.update(&mut cx, |this, cx| {
4974 let buffer_id = BufferId::new(envelope.payload.buffer_id)?;
4975 this.buffer_store.read(cx).get_existing(buffer_id)
4976 })??;
4977 let response_hint = this
4978 .update(&mut cx, |this, cx| {
4979 this.resolve_inlay_hint(
4980 hint,
4981 buffer,
4982 LanguageServerId(envelope.payload.language_server_id as usize),
4983 cx,
4984 )
4985 })?
4986 .await
4987 .context("inlay hints fetch")?;
4988 Ok(proto::ResolveInlayHintResponse {
4989 hint: Some(InlayHints::project_to_proto_hint(response_hint)),
4990 })
4991 }
4992
4993 async fn handle_open_buffer_for_symbol(
4994 this: Model<Self>,
4995 envelope: TypedEnvelope<proto::OpenBufferForSymbol>,
4996 mut cx: AsyncAppContext,
4997 ) -> Result<proto::OpenBufferForSymbolResponse> {
4998 let peer_id = envelope.original_sender_id().unwrap_or_default();
4999 let symbol = envelope
5000 .payload
5001 .symbol
5002 .ok_or_else(|| anyhow!("invalid symbol"))?;
5003 let symbol = Self::deserialize_symbol(symbol)?;
5004 let symbol = this.update(&mut cx, |this, _| {
5005 let signature = this.symbol_signature(&symbol.path);
5006 if signature == symbol.signature {
5007 Ok(symbol)
5008 } else {
5009 Err(anyhow!("invalid symbol signature"))
5010 }
5011 })??;
5012 let buffer = this
5013 .update(&mut cx, |this, cx| {
5014 this.open_buffer_for_symbol(
5015 &Symbol {
5016 language_server_name: symbol.language_server_name,
5017 source_worktree_id: symbol.source_worktree_id,
5018 path: symbol.path,
5019 name: symbol.name,
5020 kind: symbol.kind,
5021 range: symbol.range,
5022 signature: symbol.signature,
5023 label: CodeLabel {
5024 text: Default::default(),
5025 runs: Default::default(),
5026 filter_range: Default::default(),
5027 },
5028 },
5029 cx,
5030 )
5031 })?
5032 .await?;
5033
5034 this.update(&mut cx, |this, cx| {
5035 let is_private = buffer
5036 .read(cx)
5037 .file()
5038 .map(|f| f.is_private())
5039 .unwrap_or_default();
5040 if is_private {
5041 Err(anyhow!(rpc::ErrorCode::UnsharedItem))
5042 } else {
5043 this.buffer_store
5044 .update(cx, |buffer_store, cx| {
5045 buffer_store.create_buffer_for_peer(&buffer, peer_id, cx)
5046 })
5047 .detach_and_log_err(cx);
5048 let buffer_id = buffer.read(cx).remote_id().to_proto();
5049 Ok(proto::OpenBufferForSymbolResponse { buffer_id })
5050 }
5051 })?
5052 }
5053
5054 fn symbol_signature(&self, project_path: &ProjectPath) -> [u8; 32] {
5055 let mut hasher = Sha256::new();
5056 hasher.update(project_path.worktree_id.to_proto().to_be_bytes());
5057 hasher.update(project_path.path.to_string_lossy().as_bytes());
5058 hasher.update(self.nonce.to_be_bytes());
5059 hasher.finalize().as_slice().try_into().unwrap()
5060 }
5061
5062 pub async fn handle_get_project_symbols(
5063 this: Model<Self>,
5064 envelope: TypedEnvelope<proto::GetProjectSymbols>,
5065 mut cx: AsyncAppContext,
5066 ) -> Result<proto::GetProjectSymbolsResponse> {
5067 let symbols = this
5068 .update(&mut cx, |this, cx| {
5069 this.symbols(&envelope.payload.query, cx)
5070 })?
5071 .await?;
5072
5073 Ok(proto::GetProjectSymbolsResponse {
5074 symbols: symbols.iter().map(Self::serialize_symbol).collect(),
5075 })
5076 }
5077
5078 pub async fn handle_restart_language_servers(
5079 this: Model<Self>,
5080 envelope: TypedEnvelope<proto::RestartLanguageServers>,
5081 mut cx: AsyncAppContext,
5082 ) -> Result<proto::Ack> {
5083 this.update(&mut cx, |this, cx| {
5084 let buffers: Vec<_> = envelope
5085 .payload
5086 .buffer_ids
5087 .into_iter()
5088 .flat_map(|buffer_id| {
5089 this.buffer_store
5090 .read(cx)
5091 .get(BufferId::new(buffer_id).log_err()?)
5092 })
5093 .collect();
5094 this.restart_language_servers_for_buffers(buffers, cx)
5095 })?;
5096
5097 Ok(proto::Ack {})
5098 }
5099
5100 async fn handle_apply_additional_edits_for_completion(
5101 this: Model<Self>,
5102 envelope: TypedEnvelope<proto::ApplyCompletionAdditionalEdits>,
5103 mut cx: AsyncAppContext,
5104 ) -> Result<proto::ApplyCompletionAdditionalEditsResponse> {
5105 let (buffer, completion) = this.update(&mut cx, |this, cx| {
5106 let buffer_id = BufferId::new(envelope.payload.buffer_id)?;
5107 let buffer = this.buffer_store.read(cx).get_existing(buffer_id)?;
5108 let completion = Self::deserialize_completion(
5109 envelope
5110 .payload
5111 .completion
5112 .ok_or_else(|| anyhow!("invalid completion"))?,
5113 )?;
5114 anyhow::Ok((buffer, completion))
5115 })??;
5116
5117 let apply_additional_edits = this.update(&mut cx, |this, cx| {
5118 this.apply_additional_edits_for_completion(
5119 buffer,
5120 Completion {
5121 old_range: completion.old_range,
5122 new_text: completion.new_text,
5123 lsp_completion: completion.lsp_completion,
5124 server_id: completion.server_id,
5125 documentation: None,
5126 label: CodeLabel {
5127 text: Default::default(),
5128 runs: Default::default(),
5129 filter_range: Default::default(),
5130 },
5131 confirm: None,
5132 },
5133 false,
5134 cx,
5135 )
5136 })?;
5137
5138 Ok(proto::ApplyCompletionAdditionalEditsResponse {
5139 transaction: apply_additional_edits
5140 .await?
5141 .as_ref()
5142 .map(language::proto::serialize_transaction),
5143 })
5144 }
5145 pub fn last_formatting_failure(&self) -> Option<&str> {
5146 self.as_local()
5147 .and_then(|local| local.last_formatting_failure.as_deref())
5148 }
5149
5150 pub fn environment_for_buffer(
5151 &self,
5152 buffer: &Model<Buffer>,
5153 cx: &mut ModelContext<Self>,
5154 ) -> Shared<Task<Option<HashMap<String, String>>>> {
5155 let worktree_id = buffer.read(cx).file().map(|file| file.worktree_id(cx));
5156 let worktree_abs_path = worktree_id.and_then(|worktree_id| {
5157 self.worktree_store
5158 .read(cx)
5159 .worktree_for_id(worktree_id, cx)
5160 .map(|entry| entry.read(cx).abs_path().clone())
5161 });
5162
5163 if let Some(environment) = &self.as_local().map(|local| local.environment.clone()) {
5164 environment.update(cx, |env, cx| {
5165 env.get_environment(worktree_id, worktree_abs_path, cx)
5166 })
5167 } else {
5168 Task::ready(None).shared()
5169 }
5170 }
5171
5172 pub fn format(
5173 &mut self,
5174 buffers: HashSet<Model<Buffer>>,
5175 push_to_history: bool,
5176 trigger: FormatTrigger,
5177 target: FormatTarget,
5178 cx: &mut ModelContext<Self>,
5179 ) -> Task<anyhow::Result<ProjectTransaction>> {
5180 if let Some(_) = self.as_local() {
5181 let buffers_with_paths = buffers
5182 .into_iter()
5183 .map(|buffer_handle| {
5184 let buffer = buffer_handle.read(cx);
5185 let buffer_abs_path = File::from_dyn(buffer.file())
5186 .and_then(|file| file.as_local().map(|f| f.abs_path(cx)));
5187
5188 (buffer_handle, buffer_abs_path)
5189 })
5190 .collect::<Vec<_>>();
5191
5192 cx.spawn(move |lsp_store, mut cx| async move {
5193 let mut formattable_buffers = Vec::with_capacity(buffers_with_paths.len());
5194
5195 for (handle, abs_path) in buffers_with_paths {
5196 let env = lsp_store
5197 .update(&mut cx, |lsp_store, cx| {
5198 lsp_store.environment_for_buffer(&handle, cx)
5199 })?
5200 .await;
5201
5202 formattable_buffers.push(FormattableBuffer {
5203 handle,
5204 abs_path,
5205 env,
5206 });
5207 }
5208
5209 let result = LocalLspStore::format_locally(
5210 lsp_store.clone(),
5211 formattable_buffers,
5212 push_to_history,
5213 trigger,
5214 target,
5215 cx.clone(),
5216 )
5217 .await;
5218
5219 lsp_store.update(&mut cx, |lsp_store, _| {
5220 let local = lsp_store.as_local_mut().unwrap();
5221 match &result {
5222 Ok(_) => local.last_formatting_failure = None,
5223 Err(error) => {
5224 local.last_formatting_failure.replace(error.to_string());
5225 }
5226 }
5227 })?;
5228
5229 result
5230 })
5231 } else if let Some((client, project_id)) = self.upstream_client() {
5232 let buffer_store = self.buffer_store();
5233 cx.spawn(move |_, mut cx| async move {
5234 let response = client
5235 .request(proto::FormatBuffers {
5236 project_id,
5237 trigger: trigger as i32,
5238 buffer_ids: buffers
5239 .iter()
5240 .map(|buffer| {
5241 buffer.update(&mut cx, |buffer, _| buffer.remote_id().into())
5242 })
5243 .collect::<Result<_>>()?,
5244 })
5245 .await?
5246 .transaction
5247 .ok_or_else(|| anyhow!("missing transaction"))?;
5248
5249 buffer_store
5250 .update(&mut cx, |buffer_store, cx| {
5251 buffer_store.deserialize_project_transaction(response, push_to_history, cx)
5252 })?
5253 .await
5254 })
5255 } else {
5256 Task::ready(Ok(ProjectTransaction::default()))
5257 }
5258 }
5259
5260 async fn handle_format_buffers(
5261 this: Model<Self>,
5262 envelope: TypedEnvelope<proto::FormatBuffers>,
5263 mut cx: AsyncAppContext,
5264 ) -> Result<proto::FormatBuffersResponse> {
5265 let sender_id = envelope.original_sender_id().unwrap_or_default();
5266 let format = this.update(&mut cx, |this, cx| {
5267 let mut buffers = HashSet::default();
5268 for buffer_id in &envelope.payload.buffer_ids {
5269 let buffer_id = BufferId::new(*buffer_id)?;
5270 buffers.insert(this.buffer_store.read(cx).get_existing(buffer_id)?);
5271 }
5272 let trigger = FormatTrigger::from_proto(envelope.payload.trigger);
5273 Ok::<_, anyhow::Error>(this.format(buffers, false, trigger, FormatTarget::Buffer, cx))
5274 })??;
5275
5276 let project_transaction = format.await?;
5277 let project_transaction = this.update(&mut cx, |this, cx| {
5278 this.buffer_store.update(cx, |buffer_store, cx| {
5279 buffer_store.serialize_project_transaction_for_peer(
5280 project_transaction,
5281 sender_id,
5282 cx,
5283 )
5284 })
5285 })?;
5286 Ok(proto::FormatBuffersResponse {
5287 transaction: Some(project_transaction),
5288 })
5289 }
5290
5291 fn language_settings<'a>(
5292 &'a self,
5293 worktree: &'a Model<Worktree>,
5294 language: &LanguageName,
5295 cx: &'a mut ModelContext<Self>,
5296 ) -> &'a LanguageSettings {
5297 let root_file = worktree.update(cx, |tree, cx| tree.root_file(cx));
5298 all_language_settings(root_file.map(|f| f as _).as_ref(), cx).language(Some(language))
5299 }
5300
5301 pub fn start_language_servers(
5302 &mut self,
5303 worktree: &Model<Worktree>,
5304 language: LanguageName,
5305 cx: &mut ModelContext<Self>,
5306 ) {
5307 let settings = self.language_settings(worktree, &language, cx);
5308 if !settings.enable_language_server || self.mode.is_remote() {
5309 return;
5310 }
5311
5312 let available_lsp_adapters = self.languages.clone().lsp_adapters(&language);
5313 let available_language_servers = available_lsp_adapters
5314 .iter()
5315 .map(|lsp_adapter| lsp_adapter.name.clone())
5316 .collect::<Vec<_>>();
5317
5318 let desired_language_servers =
5319 settings.customized_language_servers(&available_language_servers);
5320
5321 let mut enabled_lsp_adapters: Vec<Arc<CachedLspAdapter>> = Vec::new();
5322 for desired_language_server in desired_language_servers {
5323 if let Some(adapter) = available_lsp_adapters
5324 .iter()
5325 .find(|adapter| adapter.name == desired_language_server)
5326 {
5327 enabled_lsp_adapters.push(adapter.clone());
5328 continue;
5329 }
5330
5331 if let Some(adapter) = self
5332 .languages
5333 .load_available_lsp_adapter(&desired_language_server)
5334 {
5335 self.languages
5336 .register_lsp_adapter(language.clone(), adapter.adapter.clone());
5337 enabled_lsp_adapters.push(adapter);
5338 continue;
5339 }
5340
5341 log::warn!(
5342 "no language server found matching '{}'",
5343 desired_language_server.0
5344 );
5345 }
5346
5347 for adapter in &enabled_lsp_adapters {
5348 self.start_language_server(worktree, adapter.clone(), language.clone(), cx);
5349 }
5350
5351 // After starting all the language servers, reorder them to reflect the desired order
5352 // based on the settings.
5353 //
5354 // This is done, in part, to ensure that language servers loaded at different points
5355 // (e.g., native vs extension) still end up in the right order at the end, rather than
5356 // it being based on which language server happened to be loaded in first.
5357 self.languages
5358 .reorder_language_servers(&language, enabled_lsp_adapters);
5359 }
5360
5361 fn get_language_server_binary(
5362 &self,
5363 adapter: Arc<CachedLspAdapter>,
5364 delegate: Arc<dyn LspAdapterDelegate>,
5365 allow_binary_download: bool,
5366 cx: &mut ModelContext<Self>,
5367 ) -> Task<Result<LanguageServerBinary>> {
5368 let settings = ProjectSettings::get(
5369 Some(SettingsLocation {
5370 worktree_id: delegate.worktree_id(),
5371 path: Path::new(""),
5372 }),
5373 cx,
5374 )
5375 .lsp
5376 .get(&adapter.name)
5377 .and_then(|s| s.binary.clone());
5378
5379 if settings.as_ref().is_some_and(|b| b.path.is_some()) {
5380 let settings = settings.unwrap();
5381 return cx.spawn(|_, _| async move {
5382 Ok(LanguageServerBinary {
5383 path: PathBuf::from(&settings.path.unwrap()),
5384 env: Some(delegate.shell_env().await),
5385 arguments: settings
5386 .arguments
5387 .unwrap_or_default()
5388 .iter()
5389 .map(Into::into)
5390 .collect(),
5391 })
5392 });
5393 }
5394 let lsp_binary_options = LanguageServerBinaryOptions {
5395 allow_path_lookup: !settings
5396 .as_ref()
5397 .and_then(|b| b.ignore_system_version)
5398 .unwrap_or_default(),
5399 allow_binary_download,
5400 };
5401 cx.spawn(|_, mut cx| async move {
5402 let binary_result = adapter
5403 .clone()
5404 .get_language_server_command(delegate.clone(), lsp_binary_options, &mut cx)
5405 .await;
5406
5407 delegate.update_status(adapter.name.clone(), LanguageServerBinaryStatus::None);
5408
5409 let mut binary = binary_result?;
5410 if let Some(arguments) = settings.and_then(|b| b.arguments) {
5411 binary.arguments = arguments.into_iter().map(Into::into).collect();
5412 }
5413
5414 // If we do have a project environment (either by spawning a shell in in the project directory
5415 // or by getting it from the CLI) and the language server command itself
5416 // doesn't have an environment, then we use the project environment.
5417 if binary.env.is_none() {
5418 log::info!(
5419 "using project environment for language server {:?}",
5420 adapter.name()
5421 );
5422 binary.env = Some(delegate.shell_env().await);
5423 }
5424 Ok(binary)
5425 })
5426 }
5427
5428 fn start_language_server(
5429 &mut self,
5430 worktree_handle: &Model<Worktree>,
5431 adapter: Arc<CachedLspAdapter>,
5432 language: LanguageName,
5433 cx: &mut ModelContext<Self>,
5434 ) {
5435 if self.mode.is_remote() {
5436 return;
5437 }
5438
5439 let worktree = worktree_handle.read(cx);
5440 let worktree_id = worktree.id();
5441 let worktree_path = worktree.abs_path();
5442 let key = (worktree_id, adapter.name.clone());
5443
5444 if self.language_server_ids.contains_key(&key) {
5445 return;
5446 }
5447
5448 let project_settings = ProjectSettings::get(
5449 Some(SettingsLocation {
5450 worktree_id,
5451 path: Path::new(""),
5452 }),
5453 cx,
5454 );
5455 let lsp = project_settings.lsp.get(&adapter.name);
5456 let override_options = lsp.and_then(|s| s.initialization_options.clone());
5457
5458 let stderr_capture = Arc::new(Mutex::new(Some(String::new())));
5459 let delegate = LocalLspAdapterDelegate::for_local(self, worktree_handle, cx)
5460 as Arc<dyn LspAdapterDelegate>;
5461
5462 let server_id = self.languages.next_language_server_id();
5463 let root_path = worktree_path.clone();
5464 log::info!(
5465 "attempting to start language server {:?}, path: {root_path:?}, id: {server_id}",
5466 adapter.name.0
5467 );
5468
5469 let binary = self.get_language_server_binary(adapter.clone(), delegate.clone(), true, cx);
5470
5471 let pending_server = cx.spawn({
5472 let adapter = adapter.clone();
5473 let stderr_capture = stderr_capture.clone();
5474
5475 move |_lsp_store, cx| async move {
5476 let binary = binary.await?;
5477
5478 #[cfg(any(test, feature = "test-support"))]
5479 if let Some(server) = _lsp_store
5480 .update(&mut cx.clone(), |this, cx| {
5481 this.languages.create_fake_language_server(
5482 server_id,
5483 &adapter.name,
5484 binary.clone(),
5485 cx.to_async(),
5486 )
5487 })
5488 .ok()
5489 .flatten()
5490 {
5491 return Ok(server);
5492 }
5493
5494 lsp::LanguageServer::new(
5495 stderr_capture,
5496 server_id,
5497 binary,
5498 &root_path,
5499 adapter.code_action_kinds(),
5500 cx,
5501 )
5502 }
5503 });
5504
5505 let state = LanguageServerState::Starting({
5506 let server_name = adapter.name.0.clone();
5507 let delegate = delegate as Arc<dyn LspAdapterDelegate>;
5508 let language = language.clone();
5509 let key = key.clone();
5510 let adapter = adapter.clone();
5511
5512 cx.spawn(move |this, mut cx| async move {
5513 let result = {
5514 let delegate = delegate.clone();
5515 let adapter = adapter.clone();
5516 let this = this.clone();
5517 let mut cx = cx.clone();
5518 async move {
5519 let language_server = pending_server.await?;
5520
5521 let workspace_config = adapter
5522 .adapter
5523 .clone()
5524 .workspace_configuration(&delegate, &mut cx)
5525 .await?;
5526
5527 let mut initialization_options = adapter
5528 .adapter
5529 .clone()
5530 .initialization_options(&(delegate))
5531 .await?;
5532
5533 Self::setup_lsp_messages(this.clone(), &language_server, delegate, adapter);
5534
5535 match (&mut initialization_options, override_options) {
5536 (Some(initialization_options), Some(override_options)) => {
5537 merge_json_value_into(override_options, initialization_options);
5538 }
5539 (None, override_options) => initialization_options = override_options,
5540 _ => {}
5541 }
5542
5543 let language_server = cx
5544 .update(|cx| language_server.initialize(initialization_options, cx))?
5545 .await
5546 .inspect_err(|_| {
5547 if let Some(this) = this.upgrade() {
5548 this.update(&mut cx, |_, cx| {
5549 cx.emit(LspStoreEvent::LanguageServerRemoved(server_id))
5550 })
5551 .ok();
5552 }
5553 })?;
5554
5555 language_server
5556 .notify::<lsp::notification::DidChangeConfiguration>(
5557 lsp::DidChangeConfigurationParams {
5558 settings: workspace_config,
5559 },
5560 )
5561 .ok();
5562
5563 anyhow::Ok(language_server)
5564 }
5565 }
5566 .await;
5567
5568 match result {
5569 Ok(server) => {
5570 this.update(&mut cx, |this, mut cx| {
5571 this.insert_newly_running_language_server(
5572 language,
5573 adapter,
5574 server.clone(),
5575 server_id,
5576 key,
5577 &mut cx,
5578 );
5579 })
5580 .ok();
5581 stderr_capture.lock().take();
5582 Some(server)
5583 }
5584
5585 Err(err) => {
5586 let log = stderr_capture.lock().take().unwrap_or_default();
5587 delegate.update_status(
5588 adapter.name(),
5589 LanguageServerBinaryStatus::Failed {
5590 error: format!("{err}\n-- stderr--\n{}", log),
5591 },
5592 );
5593 log::error!("Failed to start language server {server_name:?}: {err}");
5594 log::error!("server stderr: {:?}", log);
5595 None
5596 }
5597 }
5598 })
5599 });
5600
5601 self.as_local_mut()
5602 .unwrap()
5603 .language_servers
5604 .insert(server_id, state);
5605 self.language_server_ids.insert(key, server_id);
5606 }
5607
5608 async fn shutdown_language_server(
5609 server_state: Option<LanguageServerState>,
5610 name: LanguageServerName,
5611 cx: AsyncAppContext,
5612 ) {
5613 let server = match server_state {
5614 Some(LanguageServerState::Starting(task)) => {
5615 let mut timer = cx
5616 .background_executor()
5617 .timer(SERVER_LAUNCHING_BEFORE_SHUTDOWN_TIMEOUT)
5618 .fuse();
5619
5620 select! {
5621 server = task.fuse() => server,
5622 _ = timer => {
5623 log::info!(
5624 "timeout waiting for language server {} to finish launching before stopping",
5625 name
5626 );
5627 None
5628 },
5629 }
5630 }
5631
5632 Some(LanguageServerState::Running { server, .. }) => Some(server),
5633
5634 None => None,
5635 };
5636
5637 if let Some(server) = server {
5638 if let Some(shutdown) = server.shutdown() {
5639 shutdown.await;
5640 }
5641 }
5642 }
5643
5644 // Returns a list of all of the worktrees which no longer have a language server and the root path
5645 // for the stopped server
5646 fn stop_local_language_server(
5647 &mut self,
5648 worktree_id: WorktreeId,
5649 adapter_name: LanguageServerName,
5650 cx: &mut ModelContext<Self>,
5651 ) -> Task<Vec<WorktreeId>> {
5652 let key = (worktree_id, adapter_name);
5653 if self.mode.is_local() {
5654 if let Some(server_id) = self.language_server_ids.remove(&key) {
5655 let name = key.1;
5656 log::info!("stopping language server {name}");
5657
5658 // Remove other entries for this language server as well
5659 let mut orphaned_worktrees = vec![worktree_id];
5660 let other_keys = self.language_server_ids.keys().cloned().collect::<Vec<_>>();
5661 for other_key in other_keys {
5662 if self.language_server_ids.get(&other_key) == Some(&server_id) {
5663 self.language_server_ids.remove(&other_key);
5664 orphaned_worktrees.push(other_key.0);
5665 }
5666 }
5667
5668 self.buffer_store.update(cx, |buffer_store, cx| {
5669 for buffer in buffer_store.buffers() {
5670 buffer.update(cx, |buffer, cx| {
5671 buffer.update_diagnostics(
5672 server_id,
5673 DiagnosticSet::new([], buffer),
5674 cx,
5675 );
5676 });
5677 }
5678 });
5679
5680 for (worktree_id, summaries) in self.diagnostic_summaries.iter_mut() {
5681 summaries.retain(|path, summaries_by_server_id| {
5682 if summaries_by_server_id.remove(&server_id).is_some() {
5683 if let Some((client, project_id)) = self.downstream_client.clone() {
5684 client
5685 .send(proto::UpdateDiagnosticSummary {
5686 project_id,
5687 worktree_id: worktree_id.to_proto(),
5688 summary: Some(proto::DiagnosticSummary {
5689 path: path.to_string_lossy().to_string(),
5690 language_server_id: server_id.0 as u64,
5691 error_count: 0,
5692 warning_count: 0,
5693 }),
5694 })
5695 .log_err();
5696 }
5697 !summaries_by_server_id.is_empty()
5698 } else {
5699 true
5700 }
5701 });
5702 }
5703
5704 for diagnostics in self.diagnostics.values_mut() {
5705 diagnostics.retain(|_, diagnostics_by_server_id| {
5706 if let Ok(ix) =
5707 diagnostics_by_server_id.binary_search_by_key(&server_id, |e| e.0)
5708 {
5709 diagnostics_by_server_id.remove(ix);
5710 !diagnostics_by_server_id.is_empty()
5711 } else {
5712 true
5713 }
5714 });
5715 }
5716
5717 self.as_local_mut()
5718 .unwrap()
5719 .language_server_watched_paths
5720 .remove(&server_id);
5721 self.language_server_statuses.remove(&server_id);
5722 cx.notify();
5723
5724 let server_state = self
5725 .as_local_mut()
5726 .unwrap()
5727 .language_servers
5728 .remove(&server_id);
5729 cx.emit(LspStoreEvent::LanguageServerRemoved(server_id));
5730 cx.spawn(move |_, cx| async move {
5731 Self::shutdown_language_server(server_state, name, cx).await;
5732 orphaned_worktrees
5733 })
5734 } else {
5735 Task::ready(Vec::new())
5736 }
5737 } else {
5738 Task::ready(Vec::new())
5739 }
5740 }
5741
5742 pub fn restart_language_servers_for_buffers(
5743 &mut self,
5744 buffers: impl IntoIterator<Item = Model<Buffer>>,
5745 cx: &mut ModelContext<Self>,
5746 ) {
5747 if let Some((client, project_id)) = self.upstream_client() {
5748 let request = client.request(proto::RestartLanguageServers {
5749 project_id,
5750 buffer_ids: buffers
5751 .into_iter()
5752 .map(|b| b.read(cx).remote_id().to_proto())
5753 .collect(),
5754 });
5755 cx.background_executor()
5756 .spawn(request)
5757 .detach_and_log_err(cx);
5758 } else {
5759 let language_server_lookup_info: HashSet<(Model<Worktree>, LanguageName)> = buffers
5760 .into_iter()
5761 .filter_map(|buffer| {
5762 let buffer = buffer.read(cx);
5763 let file = buffer.file()?;
5764 let worktree = File::from_dyn(Some(file))?.worktree.clone();
5765 let language =
5766 self.languages
5767 .language_for_file(file, Some(buffer.as_rope()), cx)?;
5768
5769 Some((worktree, language.name()))
5770 })
5771 .collect();
5772
5773 for (worktree, language) in language_server_lookup_info {
5774 self.restart_local_language_servers(worktree, language, cx);
5775 }
5776 }
5777 }
5778
5779 fn restart_local_language_servers(
5780 &mut self,
5781 worktree: Model<Worktree>,
5782 language: LanguageName,
5783 cx: &mut ModelContext<Self>,
5784 ) {
5785 let worktree_id = worktree.read(cx).id();
5786
5787 let stop_tasks = self
5788 .languages
5789 .clone()
5790 .lsp_adapters(&language)
5791 .iter()
5792 .map(|adapter| {
5793 let stop_task =
5794 self.stop_local_language_server(worktree_id, adapter.name.clone(), cx);
5795 (stop_task, adapter.name.clone())
5796 })
5797 .collect::<Vec<_>>();
5798 if stop_tasks.is_empty() {
5799 return;
5800 }
5801
5802 cx.spawn(move |this, mut cx| async move {
5803 // For each stopped language server, record all of the worktrees with which
5804 // it was associated.
5805 let mut affected_worktrees = Vec::new();
5806 for (stop_task, language_server_name) in stop_tasks {
5807 for affected_worktree_id in stop_task.await {
5808 affected_worktrees.push((affected_worktree_id, language_server_name.clone()));
5809 }
5810 }
5811
5812 this.update(&mut cx, |this, cx| {
5813 // Restart the language server for the given worktree.
5814 this.start_language_servers(&worktree, language.clone(), cx);
5815
5816 // Lookup new server ids and set them for each of the orphaned worktrees
5817 for (affected_worktree_id, language_server_name) in affected_worktrees {
5818 if let Some(new_server_id) = this
5819 .language_server_ids
5820 .get(&(worktree_id, language_server_name.clone()))
5821 .cloned()
5822 {
5823 this.language_server_ids
5824 .insert((affected_worktree_id, language_server_name), new_server_id);
5825 }
5826 }
5827 })
5828 .ok();
5829 })
5830 .detach();
5831 }
5832
5833 fn setup_lsp_messages(
5834 this: WeakModel<Self>,
5835 language_server: &LanguageServer,
5836 delegate: Arc<dyn LspAdapterDelegate>,
5837 adapter: Arc<CachedLspAdapter>,
5838 ) {
5839 let name = language_server.name();
5840 let server_id = language_server.server_id();
5841 language_server
5842 .on_notification::<lsp::notification::PublishDiagnostics, _>({
5843 let adapter = adapter.clone();
5844 let this = this.clone();
5845 move |mut params, mut cx| {
5846 let adapter = adapter.clone();
5847 if let Some(this) = this.upgrade() {
5848 adapter.process_diagnostics(&mut params);
5849 // Everything else has to be on the server, Can we make it on the client?
5850 this.update(&mut cx, |this, cx| {
5851 this.update_diagnostics(
5852 server_id,
5853 params,
5854 &adapter.disk_based_diagnostic_sources,
5855 cx,
5856 )
5857 .log_err();
5858 })
5859 .ok();
5860 }
5861 }
5862 })
5863 .detach();
5864
5865 language_server
5866 .on_request::<lsp::request::WorkspaceConfiguration, _, _>({
5867 let adapter = adapter.adapter.clone();
5868 let delegate = delegate.clone();
5869 move |params, mut cx| {
5870 let adapter = adapter.clone();
5871 let delegate = delegate.clone();
5872 async move {
5873 let workspace_config =
5874 adapter.workspace_configuration(&delegate, &mut cx).await?;
5875 Ok(params
5876 .items
5877 .into_iter()
5878 .map(|item| {
5879 if let Some(section) = &item.section {
5880 workspace_config
5881 .get(section)
5882 .cloned()
5883 .unwrap_or(serde_json::Value::Null)
5884 } else {
5885 workspace_config.clone()
5886 }
5887 })
5888 .collect())
5889 }
5890 }
5891 })
5892 .detach();
5893
5894 language_server
5895 .on_request::<lsp::request::WorkspaceFoldersRequest, _, _>({
5896 let this = this.clone();
5897 move |_, mut cx| {
5898 let this = this.clone();
5899 async move {
5900 let Some(server) =
5901 this.update(&mut cx, |this, _| this.language_server_for_id(server_id))?
5902 else {
5903 return Ok(None);
5904 };
5905 let root = server.root_path();
5906 let Ok(uri) = Url::from_file_path(&root) else {
5907 return Ok(None);
5908 };
5909 Ok(Some(vec![WorkspaceFolder {
5910 uri,
5911 name: Default::default(),
5912 }]))
5913 }
5914 }
5915 })
5916 .detach();
5917 // Even though we don't have handling for these requests, respond to them to
5918 // avoid stalling any language server like `gopls` which waits for a response
5919 // to these requests when initializing.
5920 language_server
5921 .on_request::<lsp::request::WorkDoneProgressCreate, _, _>({
5922 let this = this.clone();
5923 move |params, mut cx| {
5924 let this = this.clone();
5925 async move {
5926 this.update(&mut cx, |this, _| {
5927 if let Some(status) = this.language_server_statuses.get_mut(&server_id)
5928 {
5929 if let lsp::NumberOrString::String(token) = params.token {
5930 status.progress_tokens.insert(token);
5931 }
5932 }
5933 })?;
5934
5935 Ok(())
5936 }
5937 }
5938 })
5939 .detach();
5940
5941 language_server
5942 .on_request::<lsp::request::RegisterCapability, _, _>({
5943 let this = this.clone();
5944 move |params, mut cx| {
5945 let this = this.clone();
5946 async move {
5947 for reg in params.registrations {
5948 match reg.method.as_str() {
5949 "workspace/didChangeWatchedFiles" => {
5950 if let Some(options) = reg.register_options {
5951 let options = serde_json::from_value(options)?;
5952 this.update(&mut cx, |this, cx| {
5953 this.on_lsp_did_change_watched_files(
5954 server_id, ®.id, options, cx,
5955 );
5956 })?;
5957 }
5958 }
5959 "textDocument/rangeFormatting" => {
5960 this.update(&mut cx, |this, _| {
5961 if let Some(server) = this.language_server_for_id(server_id)
5962 {
5963 let options = reg
5964 .register_options
5965 .map(|options| {
5966 serde_json::from_value::<
5967 lsp::DocumentRangeFormattingOptions,
5968 >(
5969 options
5970 )
5971 })
5972 .transpose()?;
5973 let provider = match options {
5974 None => OneOf::Left(true),
5975 Some(options) => OneOf::Right(options),
5976 };
5977 server.update_capabilities(|capabilities| {
5978 capabilities.document_range_formatting_provider =
5979 Some(provider);
5980 })
5981 }
5982 anyhow::Ok(())
5983 })??;
5984 }
5985 "textDocument/onTypeFormatting" => {
5986 this.update(&mut cx, |this, _| {
5987 if let Some(server) = this.language_server_for_id(server_id)
5988 {
5989 let options = reg
5990 .register_options
5991 .map(|options| {
5992 serde_json::from_value::<
5993 lsp::DocumentOnTypeFormattingOptions,
5994 >(
5995 options
5996 )
5997 })
5998 .transpose()?;
5999 if let Some(options) = options {
6000 server.update_capabilities(|capabilities| {
6001 capabilities
6002 .document_on_type_formatting_provider =
6003 Some(options);
6004 })
6005 }
6006 }
6007 anyhow::Ok(())
6008 })??;
6009 }
6010 "textDocument/formatting" => {
6011 this.update(&mut cx, |this, _| {
6012 if let Some(server) = this.language_server_for_id(server_id)
6013 {
6014 let options = reg
6015 .register_options
6016 .map(|options| {
6017 serde_json::from_value::<
6018 lsp::DocumentFormattingOptions,
6019 >(
6020 options
6021 )
6022 })
6023 .transpose()?;
6024 let provider = match options {
6025 None => OneOf::Left(true),
6026 Some(options) => OneOf::Right(options),
6027 };
6028 server.update_capabilities(|capabilities| {
6029 capabilities.document_formatting_provider =
6030 Some(provider);
6031 })
6032 }
6033 anyhow::Ok(())
6034 })??;
6035 }
6036 _ => log::warn!("unhandled capability registration: {reg:?}"),
6037 }
6038 }
6039 Ok(())
6040 }
6041 }
6042 })
6043 .detach();
6044
6045 language_server
6046 .on_request::<lsp::request::UnregisterCapability, _, _>({
6047 let this = this.clone();
6048 move |params, mut cx| {
6049 let this = this.clone();
6050 async move {
6051 for unreg in params.unregisterations.iter() {
6052 match unreg.method.as_str() {
6053 "workspace/didChangeWatchedFiles" => {
6054 this.update(&mut cx, |this, cx| {
6055 this.on_lsp_unregister_did_change_watched_files(
6056 server_id, &unreg.id, cx,
6057 );
6058 })?;
6059 }
6060 "textDocument/rangeFormatting" => {
6061 this.update(&mut cx, |this, _| {
6062 if let Some(server) = this.language_server_for_id(server_id)
6063 {
6064 server.update_capabilities(|capabilities| {
6065 capabilities.document_range_formatting_provider =
6066 None
6067 })
6068 }
6069 })?;
6070 }
6071 "textDocument/onTypeFormatting" => {
6072 this.update(&mut cx, |this, _| {
6073 if let Some(server) = this.language_server_for_id(server_id)
6074 {
6075 server.update_capabilities(|capabilities| {
6076 capabilities.document_on_type_formatting_provider =
6077 None;
6078 })
6079 }
6080 })?;
6081 }
6082 "textDocument/formatting" => {
6083 this.update(&mut cx, |this, _| {
6084 if let Some(server) = this.language_server_for_id(server_id)
6085 {
6086 server.update_capabilities(|capabilities| {
6087 capabilities.document_formatting_provider = None;
6088 })
6089 }
6090 })?;
6091 }
6092 _ => log::warn!("unhandled capability unregistration: {unreg:?}"),
6093 }
6094 }
6095 Ok(())
6096 }
6097 }
6098 })
6099 .detach();
6100
6101 language_server
6102 .on_request::<lsp::request::ApplyWorkspaceEdit, _, _>({
6103 let adapter = adapter.clone();
6104 let this = this.clone();
6105 move |params, cx| {
6106 Self::on_lsp_workspace_edit(
6107 this.clone(),
6108 params,
6109 server_id,
6110 adapter.clone(),
6111 cx,
6112 )
6113 }
6114 })
6115 .detach();
6116
6117 language_server
6118 .on_request::<lsp::request::InlayHintRefreshRequest, _, _>({
6119 let this = this.clone();
6120 move |(), mut cx| {
6121 let this = this.clone();
6122 async move {
6123 this.update(&mut cx, |this, cx| {
6124 cx.emit(LspStoreEvent::RefreshInlayHints);
6125 this.downstream_client.as_ref().map(|(client, project_id)| {
6126 client.send(proto::RefreshInlayHints {
6127 project_id: *project_id,
6128 })
6129 })
6130 })?
6131 .transpose()?;
6132 Ok(())
6133 }
6134 }
6135 })
6136 .detach();
6137
6138 language_server
6139 .on_request::<lsp::request::ShowMessageRequest, _, _>({
6140 let this = this.clone();
6141 let name = name.to_string();
6142 move |params, mut cx| {
6143 let this = this.clone();
6144 let name = name.to_string();
6145 async move {
6146 let actions = params.actions.unwrap_or_default();
6147 let (tx, mut rx) = smol::channel::bounded(1);
6148 let request = LanguageServerPromptRequest {
6149 level: match params.typ {
6150 lsp::MessageType::ERROR => PromptLevel::Critical,
6151 lsp::MessageType::WARNING => PromptLevel::Warning,
6152 _ => PromptLevel::Info,
6153 },
6154 message: params.message,
6155 actions,
6156 response_channel: tx,
6157 lsp_name: name.clone(),
6158 };
6159
6160 let did_update = this
6161 .update(&mut cx, |_, cx| {
6162 cx.emit(LspStoreEvent::LanguageServerPrompt(request));
6163 })
6164 .is_ok();
6165 if did_update {
6166 let response = rx.next().await;
6167
6168 Ok(response)
6169 } else {
6170 Ok(None)
6171 }
6172 }
6173 }
6174 })
6175 .detach();
6176
6177 language_server
6178 .on_notification::<ServerStatus, _>({
6179 let this = this.clone();
6180 let name = name.to_string();
6181 move |params, mut cx| {
6182 let this = this.clone();
6183 let name = name.to_string();
6184 if let Some(ref message) = params.message {
6185 let message = message.trim();
6186 if !message.is_empty() {
6187 let formatted_message = format!(
6188 "Language server {name} (id {server_id}) status update: {message}"
6189 );
6190 match params.health {
6191 ServerHealthStatus::Ok => log::info!("{}", formatted_message),
6192 ServerHealthStatus::Warning => log::warn!("{}", formatted_message),
6193 ServerHealthStatus::Error => {
6194 log::error!("{}", formatted_message);
6195 let (tx, _rx) = smol::channel::bounded(1);
6196 let request = LanguageServerPromptRequest {
6197 level: PromptLevel::Critical,
6198 message: params.message.unwrap_or_default(),
6199 actions: Vec::new(),
6200 response_channel: tx,
6201 lsp_name: name.clone(),
6202 };
6203 let _ = this
6204 .update(&mut cx, |_, cx| {
6205 cx.emit(LspStoreEvent::LanguageServerPrompt(request));
6206 })
6207 .ok();
6208 }
6209 ServerHealthStatus::Other(status) => {
6210 log::info!(
6211 "Unknown server health: {status}\n{formatted_message}"
6212 )
6213 }
6214 }
6215 }
6216 }
6217 }
6218 })
6219 .detach();
6220 language_server
6221 .on_notification::<lsp::notification::ShowMessage, _>({
6222 let this = this.clone();
6223 let name = name.to_string();
6224 move |params, mut cx| {
6225 let this = this.clone();
6226 let name = name.to_string();
6227
6228 let (tx, _) = smol::channel::bounded(1);
6229 let request = LanguageServerPromptRequest {
6230 level: match params.typ {
6231 lsp::MessageType::ERROR => PromptLevel::Critical,
6232 lsp::MessageType::WARNING => PromptLevel::Warning,
6233 _ => PromptLevel::Info,
6234 },
6235 message: params.message,
6236 actions: vec![],
6237 response_channel: tx,
6238 lsp_name: name.clone(),
6239 };
6240
6241 let _ = this.update(&mut cx, |_, cx| {
6242 cx.emit(LspStoreEvent::LanguageServerPrompt(request));
6243 });
6244 }
6245 })
6246 .detach();
6247
6248 let disk_based_diagnostics_progress_token =
6249 adapter.disk_based_diagnostics_progress_token.clone();
6250
6251 language_server
6252 .on_notification::<lsp::notification::Progress, _>({
6253 let this = this.clone();
6254 move |params, mut cx| {
6255 if let Some(this) = this.upgrade() {
6256 this.update(&mut cx, |this, cx| {
6257 this.on_lsp_progress(
6258 params,
6259 server_id,
6260 disk_based_diagnostics_progress_token.clone(),
6261 cx,
6262 );
6263 })
6264 .ok();
6265 }
6266 }
6267 })
6268 .detach();
6269
6270 language_server
6271 .on_notification::<lsp::notification::LogMessage, _>({
6272 let this = this.clone();
6273 move |params, mut cx| {
6274 if let Some(this) = this.upgrade() {
6275 this.update(&mut cx, |_, cx| {
6276 cx.emit(LspStoreEvent::LanguageServerLog(
6277 server_id,
6278 LanguageServerLogType::Log(params.typ),
6279 params.message,
6280 ));
6281 })
6282 .ok();
6283 }
6284 }
6285 })
6286 .detach();
6287
6288 language_server
6289 .on_notification::<lsp::notification::LogTrace, _>({
6290 let this = this.clone();
6291 move |params, mut cx| {
6292 if let Some(this) = this.upgrade() {
6293 this.update(&mut cx, |_, cx| {
6294 cx.emit(LspStoreEvent::LanguageServerLog(
6295 server_id,
6296 LanguageServerLogType::Trace(params.verbose),
6297 params.message,
6298 ));
6299 })
6300 .ok();
6301 }
6302 }
6303 })
6304 .detach();
6305 }
6306
6307 pub fn update_diagnostics(
6308 &mut self,
6309 language_server_id: LanguageServerId,
6310 mut params: lsp::PublishDiagnosticsParams,
6311 disk_based_sources: &[String],
6312 cx: &mut ModelContext<Self>,
6313 ) -> Result<()> {
6314 let abs_path = params
6315 .uri
6316 .to_file_path()
6317 .map_err(|_| anyhow!("URI is not a file"))?;
6318 let mut diagnostics = Vec::default();
6319 let mut primary_diagnostic_group_ids = HashMap::default();
6320 let mut sources_by_group_id = HashMap::default();
6321 let mut supporting_diagnostics = HashMap::default();
6322
6323 // Ensure that primary diagnostics are always the most severe
6324 params.diagnostics.sort_by_key(|item| item.severity);
6325
6326 for diagnostic in ¶ms.diagnostics {
6327 let source = diagnostic.source.as_ref();
6328 let code = diagnostic.code.as_ref().map(|code| match code {
6329 lsp::NumberOrString::Number(code) => code.to_string(),
6330 lsp::NumberOrString::String(code) => code.clone(),
6331 });
6332 let range = range_from_lsp(diagnostic.range);
6333 let is_supporting = diagnostic
6334 .related_information
6335 .as_ref()
6336 .map_or(false, |infos| {
6337 infos.iter().any(|info| {
6338 primary_diagnostic_group_ids.contains_key(&(
6339 source,
6340 code.clone(),
6341 range_from_lsp(info.location.range),
6342 ))
6343 })
6344 });
6345
6346 let is_unnecessary = diagnostic.tags.as_ref().map_or(false, |tags| {
6347 tags.iter().any(|tag| *tag == DiagnosticTag::UNNECESSARY)
6348 });
6349
6350 if is_supporting {
6351 supporting_diagnostics.insert(
6352 (source, code.clone(), range),
6353 (diagnostic.severity, is_unnecessary),
6354 );
6355 } else {
6356 let group_id = post_inc(&mut self.next_diagnostic_group_id);
6357 let is_disk_based =
6358 source.map_or(false, |source| disk_based_sources.contains(source));
6359
6360 sources_by_group_id.insert(group_id, source);
6361 primary_diagnostic_group_ids
6362 .insert((source, code.clone(), range.clone()), group_id);
6363
6364 diagnostics.push(DiagnosticEntry {
6365 range,
6366 diagnostic: Diagnostic {
6367 source: diagnostic.source.clone(),
6368 code: code.clone(),
6369 severity: diagnostic.severity.unwrap_or(DiagnosticSeverity::ERROR),
6370 message: diagnostic.message.trim().to_string(),
6371 group_id,
6372 is_primary: true,
6373 is_disk_based,
6374 is_unnecessary,
6375 data: diagnostic.data.clone(),
6376 },
6377 });
6378 if let Some(infos) = &diagnostic.related_information {
6379 for info in infos {
6380 if info.location.uri == params.uri && !info.message.is_empty() {
6381 let range = range_from_lsp(info.location.range);
6382 diagnostics.push(DiagnosticEntry {
6383 range,
6384 diagnostic: Diagnostic {
6385 source: diagnostic.source.clone(),
6386 code: code.clone(),
6387 severity: DiagnosticSeverity::INFORMATION,
6388 message: info.message.trim().to_string(),
6389 group_id,
6390 is_primary: false,
6391 is_disk_based,
6392 is_unnecessary: false,
6393 data: diagnostic.data.clone(),
6394 },
6395 });
6396 }
6397 }
6398 }
6399 }
6400 }
6401
6402 for entry in &mut diagnostics {
6403 let diagnostic = &mut entry.diagnostic;
6404 if !diagnostic.is_primary {
6405 let source = *sources_by_group_id.get(&diagnostic.group_id).unwrap();
6406 if let Some(&(severity, is_unnecessary)) = supporting_diagnostics.get(&(
6407 source,
6408 diagnostic.code.clone(),
6409 entry.range.clone(),
6410 )) {
6411 if let Some(severity) = severity {
6412 diagnostic.severity = severity;
6413 }
6414 diagnostic.is_unnecessary = is_unnecessary;
6415 }
6416 }
6417 }
6418
6419 self.update_diagnostic_entries(
6420 language_server_id,
6421 abs_path,
6422 params.version,
6423 diagnostics,
6424 cx,
6425 )?;
6426 Ok(())
6427 }
6428
6429 fn insert_newly_running_language_server(
6430 &mut self,
6431 language: LanguageName,
6432 adapter: Arc<CachedLspAdapter>,
6433 language_server: Arc<LanguageServer>,
6434 server_id: LanguageServerId,
6435 key: (WorktreeId, LanguageServerName),
6436 cx: &mut ModelContext<Self>,
6437 ) {
6438 // If the language server for this key doesn't match the server id, don't store the
6439 // server. Which will cause it to be dropped, killing the process
6440 if self
6441 .language_server_ids
6442 .get(&key)
6443 .map(|id| id != &server_id)
6444 .unwrap_or(false)
6445 {
6446 return;
6447 }
6448
6449 // Update language_servers collection with Running variant of LanguageServerState
6450 // indicating that the server is up and running and ready
6451 if let Some(local) = self.as_local_mut() {
6452 local.language_servers.insert(
6453 server_id,
6454 LanguageServerState::Running {
6455 adapter: adapter.clone(),
6456 language: language.clone(),
6457 server: language_server.clone(),
6458 simulate_disk_based_diagnostics_completion: None,
6459 },
6460 );
6461 }
6462
6463 self.language_server_statuses.insert(
6464 server_id,
6465 LanguageServerStatus {
6466 name: language_server.name().to_string(),
6467 pending_work: Default::default(),
6468 has_pending_diagnostic_updates: false,
6469 progress_tokens: Default::default(),
6470 },
6471 );
6472
6473 cx.emit(LspStoreEvent::LanguageServerAdded(
6474 server_id,
6475 language_server.name().into(),
6476 Some(key.0),
6477 ));
6478
6479 if let Some((downstream_client, project_id)) = self.downstream_client.as_ref() {
6480 downstream_client
6481 .send(proto::StartLanguageServer {
6482 project_id: *project_id,
6483 server: Some(proto::LanguageServer {
6484 id: server_id.0 as u64,
6485 name: language_server.name().to_string(),
6486 worktree_id: Some(key.0.to_proto()),
6487 }),
6488 })
6489 .log_err();
6490 }
6491
6492 // Tell the language server about every open buffer in the worktree that matches the language.
6493 self.buffer_store.update(cx, |buffer_store, cx| {
6494 for buffer_handle in buffer_store.buffers() {
6495 let buffer = buffer_handle.read(cx);
6496 let file = match File::from_dyn(buffer.file()) {
6497 Some(file) => file,
6498 None => continue,
6499 };
6500 let language = match buffer.language() {
6501 Some(language) => language,
6502 None => continue,
6503 };
6504
6505 if file.worktree.read(cx).id() != key.0
6506 || !self
6507 .languages
6508 .lsp_adapters(&language.name())
6509 .iter()
6510 .any(|a| a.name == key.1)
6511 {
6512 continue;
6513 }
6514
6515 let file = match file.as_local() {
6516 Some(file) => file,
6517 None => continue,
6518 };
6519
6520 let versions = self
6521 .buffer_snapshots
6522 .entry(buffer.remote_id())
6523 .or_default()
6524 .entry(server_id)
6525 .or_insert_with(|| {
6526 vec![LspBufferSnapshot {
6527 version: 0,
6528 snapshot: buffer.text_snapshot(),
6529 }]
6530 });
6531
6532 let snapshot = versions.last().unwrap();
6533 let version = snapshot.version;
6534 let initial_snapshot = &snapshot.snapshot;
6535 let uri = lsp::Url::from_file_path(file.abs_path(cx)).unwrap();
6536 language_server
6537 .notify::<lsp::notification::DidOpenTextDocument>(
6538 lsp::DidOpenTextDocumentParams {
6539 text_document: lsp::TextDocumentItem::new(
6540 uri,
6541 adapter.language_id(&language.name()),
6542 version,
6543 initial_snapshot.text(),
6544 ),
6545 },
6546 )
6547 .log_err();
6548
6549 buffer_handle.update(cx, |buffer, cx| {
6550 buffer.set_completion_triggers(
6551 language_server
6552 .capabilities()
6553 .completion_provider
6554 .as_ref()
6555 .and_then(|provider| provider.trigger_characters.clone())
6556 .unwrap_or_default(),
6557 cx,
6558 )
6559 });
6560 }
6561 });
6562
6563 cx.notify();
6564 }
6565
6566 fn buffer_snapshot_for_lsp_version(
6567 &mut self,
6568 buffer: &Model<Buffer>,
6569 server_id: LanguageServerId,
6570 version: Option<i32>,
6571 cx: &AppContext,
6572 ) -> Result<TextBufferSnapshot> {
6573 const OLD_VERSIONS_TO_RETAIN: i32 = 10;
6574
6575 if let Some(version) = version {
6576 let buffer_id = buffer.read(cx).remote_id();
6577 let snapshots = self
6578 .buffer_snapshots
6579 .get_mut(&buffer_id)
6580 .and_then(|m| m.get_mut(&server_id))
6581 .ok_or_else(|| {
6582 anyhow!("no snapshots found for buffer {buffer_id} and server {server_id}")
6583 })?;
6584
6585 let found_snapshot = snapshots
6586 .binary_search_by_key(&version, |e| e.version)
6587 .map(|ix| snapshots[ix].snapshot.clone())
6588 .map_err(|_| {
6589 anyhow!("snapshot not found for buffer {buffer_id} server {server_id} at version {version}")
6590 })?;
6591
6592 snapshots.retain(|snapshot| snapshot.version + OLD_VERSIONS_TO_RETAIN >= version);
6593 Ok(found_snapshot)
6594 } else {
6595 Ok((buffer.read(cx)).text_snapshot())
6596 }
6597 }
6598
6599 pub fn language_servers_running_disk_based_diagnostics(
6600 &self,
6601 ) -> impl Iterator<Item = LanguageServerId> + '_ {
6602 self.language_server_statuses
6603 .iter()
6604 .filter_map(|(id, status)| {
6605 if status.has_pending_diagnostic_updates {
6606 Some(*id)
6607 } else {
6608 None
6609 }
6610 })
6611 }
6612
6613 pub(crate) fn language_servers_for_buffer<'a>(
6614 &'a self,
6615 buffer: &'a Buffer,
6616 cx: &'a AppContext,
6617 ) -> impl Iterator<Item = (&'a Arc<CachedLspAdapter>, &'a Arc<LanguageServer>)> {
6618 self.language_server_ids_for_buffer(buffer, cx)
6619 .into_iter()
6620 .filter_map(
6621 |server_id| match self.as_local()?.language_servers.get(&server_id)? {
6622 LanguageServerState::Running {
6623 adapter, server, ..
6624 } => Some((adapter, server)),
6625 _ => None,
6626 },
6627 )
6628 }
6629
6630 pub(crate) fn cancel_language_server_work_for_buffers(
6631 &mut self,
6632 buffers: impl IntoIterator<Item = Model<Buffer>>,
6633 cx: &mut ModelContext<Self>,
6634 ) {
6635 let servers = buffers
6636 .into_iter()
6637 .flat_map(|buffer| {
6638 self.language_server_ids_for_buffer(buffer.read(cx), cx)
6639 .into_iter()
6640 })
6641 .collect::<HashSet<_>>();
6642
6643 for server_id in servers {
6644 self.cancel_language_server_work(server_id, None, cx);
6645 }
6646 }
6647
6648 pub fn language_servers(
6649 &self,
6650 ) -> impl '_ + Iterator<Item = (LanguageServerId, LanguageServerName, WorktreeId)> {
6651 self.language_server_ids
6652 .iter()
6653 .map(|((worktree_id, server_name), server_id)| {
6654 (*server_id, server_name.clone(), *worktree_id)
6655 })
6656 }
6657
6658 fn register_supplementary_language_server(
6659 &mut self,
6660 id: LanguageServerId,
6661 name: LanguageServerName,
6662 server: Arc<LanguageServer>,
6663 cx: &mut ModelContext<Self>,
6664 ) {
6665 if let Some(local) = self.as_local_mut() {
6666 local
6667 .supplementary_language_servers
6668 .insert(id, (name.clone(), server));
6669 cx.emit(LspStoreEvent::LanguageServerAdded(id, name, None));
6670 }
6671 }
6672
6673 fn unregister_supplementary_language_server(
6674 &mut self,
6675 id: LanguageServerId,
6676 cx: &mut ModelContext<Self>,
6677 ) {
6678 if let Some(local) = self.as_local_mut() {
6679 local.supplementary_language_servers.remove(&id);
6680 cx.emit(LspStoreEvent::LanguageServerRemoved(id));
6681 }
6682 }
6683
6684 pub fn supplementary_language_servers(
6685 &self,
6686 ) -> impl '_ + Iterator<Item = (LanguageServerId, LanguageServerName)> {
6687 self.as_local().into_iter().flat_map(|local| {
6688 local
6689 .supplementary_language_servers
6690 .iter()
6691 .map(|(id, (name, _))| (*id, name.clone()))
6692 })
6693 }
6694
6695 pub fn language_server_adapter_for_id(
6696 &self,
6697 id: LanguageServerId,
6698 ) -> Option<Arc<CachedLspAdapter>> {
6699 self.as_local()
6700 .and_then(|local| local.language_servers.get(&id))
6701 .and_then(|language_server_state| match language_server_state {
6702 LanguageServerState::Running { adapter, .. } => Some(adapter.clone()),
6703 _ => None,
6704 })
6705 }
6706
6707 pub(super) fn update_local_worktree_language_servers(
6708 &mut self,
6709 worktree_handle: &Model<Worktree>,
6710 changes: &[(Arc<Path>, ProjectEntryId, PathChange)],
6711 cx: &mut ModelContext<Self>,
6712 ) {
6713 if changes.is_empty() {
6714 return;
6715 }
6716
6717 let Some(local) = self.as_local() else { return };
6718
6719 local.prettier_store.update(cx, |prettier_store, cx| {
6720 prettier_store.update_prettier_settings(&worktree_handle, changes, cx)
6721 });
6722
6723 let worktree_id = worktree_handle.read(cx).id();
6724 let mut language_server_ids = self
6725 .language_server_ids
6726 .iter()
6727 .filter_map(|((server_worktree_id, _), server_id)| {
6728 (*server_worktree_id == worktree_id).then_some(*server_id)
6729 })
6730 .collect::<Vec<_>>();
6731 language_server_ids.sort();
6732 language_server_ids.dedup();
6733
6734 let abs_path = worktree_handle.read(cx).abs_path();
6735 for server_id in &language_server_ids {
6736 if let Some(LanguageServerState::Running { server, .. }) =
6737 local.language_servers.get(server_id)
6738 {
6739 if let Some(watched_paths) = local
6740 .language_server_watched_paths
6741 .get(server_id)
6742 .and_then(|paths| paths.read(cx).worktree_paths.get(&worktree_id))
6743 {
6744 let params = lsp::DidChangeWatchedFilesParams {
6745 changes: changes
6746 .iter()
6747 .filter_map(|(path, _, change)| {
6748 if !watched_paths.is_match(path) {
6749 return None;
6750 }
6751 let typ = match change {
6752 PathChange::Loaded => return None,
6753 PathChange::Added => lsp::FileChangeType::CREATED,
6754 PathChange::Removed => lsp::FileChangeType::DELETED,
6755 PathChange::Updated => lsp::FileChangeType::CHANGED,
6756 PathChange::AddedOrUpdated => lsp::FileChangeType::CHANGED,
6757 };
6758 Some(lsp::FileEvent {
6759 uri: lsp::Url::from_file_path(abs_path.join(path)).unwrap(),
6760 typ,
6761 })
6762 })
6763 .collect(),
6764 };
6765 if !params.changes.is_empty() {
6766 server
6767 .notify::<lsp::notification::DidChangeWatchedFiles>(params)
6768 .log_err();
6769 }
6770 }
6771 }
6772 }
6773 }
6774
6775 pub(crate) fn cancel_language_server_work(
6776 &mut self,
6777 server_id: LanguageServerId,
6778 token_to_cancel: Option<String>,
6779 _cx: &mut ModelContext<Self>,
6780 ) {
6781 let Some(local) = self.as_local() else {
6782 return;
6783 };
6784 let status = self.language_server_statuses.get(&server_id);
6785 let server = local.language_servers.get(&server_id);
6786 if let Some((LanguageServerState::Running { server, .. }, status)) = server.zip(status) {
6787 for (token, progress) in &status.pending_work {
6788 if let Some(token_to_cancel) = token_to_cancel.as_ref() {
6789 if token != token_to_cancel {
6790 continue;
6791 }
6792 }
6793 if progress.is_cancellable {
6794 server
6795 .notify::<lsp::notification::WorkDoneProgressCancel>(
6796 WorkDoneProgressCancelParams {
6797 token: lsp::NumberOrString::String(token.clone()),
6798 },
6799 )
6800 .ok();
6801 }
6802
6803 if progress.is_cancellable {
6804 server
6805 .notify::<lsp::notification::WorkDoneProgressCancel>(
6806 WorkDoneProgressCancelParams {
6807 token: lsp::NumberOrString::String(token.clone()),
6808 },
6809 )
6810 .ok();
6811 }
6812 }
6813 }
6814 }
6815
6816 pub fn wait_for_remote_buffer(
6817 &mut self,
6818 id: BufferId,
6819 cx: &mut ModelContext<Self>,
6820 ) -> Task<Result<Model<Buffer>>> {
6821 self.buffer_store.update(cx, |buffer_store, cx| {
6822 buffer_store.wait_for_remote_buffer(id, cx)
6823 })
6824 }
6825
6826 pub(crate) fn language_server_ids_for_buffer(
6827 &self,
6828 buffer: &Buffer,
6829 cx: &AppContext,
6830 ) -> Vec<LanguageServerId> {
6831 if let Some((file, language)) = File::from_dyn(buffer.file()).zip(buffer.language()) {
6832 let worktree_id = file.worktree_id(cx);
6833 self.languages
6834 .lsp_adapters(&language.name())
6835 .iter()
6836 .flat_map(|adapter| {
6837 let key = (worktree_id, adapter.name.clone());
6838 self.language_server_ids.get(&key).copied()
6839 })
6840 .collect()
6841 } else {
6842 Vec::new()
6843 }
6844 }
6845
6846 pub async fn deserialize_text_edits(
6847 this: Model<Self>,
6848 buffer_to_edit: Model<Buffer>,
6849 edits: Vec<lsp::TextEdit>,
6850 push_to_history: bool,
6851 _: Arc<CachedLspAdapter>,
6852 language_server: Arc<LanguageServer>,
6853 cx: &mut AsyncAppContext,
6854 ) -> Result<Option<Transaction>> {
6855 let edits = this
6856 .update(cx, |this, cx| {
6857 this.edits_from_lsp(
6858 &buffer_to_edit,
6859 edits,
6860 language_server.server_id(),
6861 None,
6862 cx,
6863 )
6864 })?
6865 .await?;
6866
6867 let transaction = buffer_to_edit.update(cx, |buffer, cx| {
6868 buffer.finalize_last_transaction();
6869 buffer.start_transaction();
6870 for (range, text) in edits {
6871 buffer.edit([(range, text)], None, cx);
6872 }
6873
6874 if buffer.end_transaction(cx).is_some() {
6875 let transaction = buffer.finalize_last_transaction().unwrap().clone();
6876 if !push_to_history {
6877 buffer.forget_transaction(transaction.id);
6878 }
6879 Some(transaction)
6880 } else {
6881 None
6882 }
6883 })?;
6884
6885 Ok(transaction)
6886 }
6887
6888 pub async fn deserialize_workspace_edit(
6889 this: Model<Self>,
6890 edit: lsp::WorkspaceEdit,
6891 push_to_history: bool,
6892 lsp_adapter: Arc<CachedLspAdapter>,
6893 language_server: Arc<LanguageServer>,
6894 cx: &mut AsyncAppContext,
6895 ) -> Result<ProjectTransaction> {
6896 let fs = this.read_with(cx, |this, _| this.as_local().unwrap().fs.clone())?;
6897
6898 let mut operations = Vec::new();
6899 if let Some(document_changes) = edit.document_changes {
6900 match document_changes {
6901 lsp::DocumentChanges::Edits(edits) => {
6902 operations.extend(edits.into_iter().map(lsp::DocumentChangeOperation::Edit))
6903 }
6904 lsp::DocumentChanges::Operations(ops) => operations = ops,
6905 }
6906 } else if let Some(changes) = edit.changes {
6907 operations.extend(changes.into_iter().map(|(uri, edits)| {
6908 lsp::DocumentChangeOperation::Edit(lsp::TextDocumentEdit {
6909 text_document: lsp::OptionalVersionedTextDocumentIdentifier {
6910 uri,
6911 version: None,
6912 },
6913 edits: edits.into_iter().map(Edit::Plain).collect(),
6914 })
6915 }));
6916 }
6917
6918 let mut project_transaction = ProjectTransaction::default();
6919 for operation in operations {
6920 match operation {
6921 lsp::DocumentChangeOperation::Op(lsp::ResourceOp::Create(op)) => {
6922 let abs_path = op
6923 .uri
6924 .to_file_path()
6925 .map_err(|_| anyhow!("can't convert URI to path"))?;
6926
6927 if let Some(parent_path) = abs_path.parent() {
6928 fs.create_dir(parent_path).await?;
6929 }
6930 if abs_path.ends_with("/") {
6931 fs.create_dir(&abs_path).await?;
6932 } else {
6933 fs.create_file(
6934 &abs_path,
6935 op.options
6936 .map(|options| fs::CreateOptions {
6937 overwrite: options.overwrite.unwrap_or(false),
6938 ignore_if_exists: options.ignore_if_exists.unwrap_or(false),
6939 })
6940 .unwrap_or_default(),
6941 )
6942 .await?;
6943 }
6944 }
6945
6946 lsp::DocumentChangeOperation::Op(lsp::ResourceOp::Rename(op)) => {
6947 let source_abs_path = op
6948 .old_uri
6949 .to_file_path()
6950 .map_err(|_| anyhow!("can't convert URI to path"))?;
6951 let target_abs_path = op
6952 .new_uri
6953 .to_file_path()
6954 .map_err(|_| anyhow!("can't convert URI to path"))?;
6955 fs.rename(
6956 &source_abs_path,
6957 &target_abs_path,
6958 op.options
6959 .map(|options| fs::RenameOptions {
6960 overwrite: options.overwrite.unwrap_or(false),
6961 ignore_if_exists: options.ignore_if_exists.unwrap_or(false),
6962 })
6963 .unwrap_or_default(),
6964 )
6965 .await?;
6966 }
6967
6968 lsp::DocumentChangeOperation::Op(lsp::ResourceOp::Delete(op)) => {
6969 let abs_path = op
6970 .uri
6971 .to_file_path()
6972 .map_err(|_| anyhow!("can't convert URI to path"))?;
6973 let options = op
6974 .options
6975 .map(|options| fs::RemoveOptions {
6976 recursive: options.recursive.unwrap_or(false),
6977 ignore_if_not_exists: options.ignore_if_not_exists.unwrap_or(false),
6978 })
6979 .unwrap_or_default();
6980 if abs_path.ends_with("/") {
6981 fs.remove_dir(&abs_path, options).await?;
6982 } else {
6983 fs.remove_file(&abs_path, options).await?;
6984 }
6985 }
6986
6987 lsp::DocumentChangeOperation::Edit(op) => {
6988 let buffer_to_edit = this
6989 .update(cx, |this, cx| {
6990 this.open_local_buffer_via_lsp(
6991 op.text_document.uri.clone(),
6992 language_server.server_id(),
6993 lsp_adapter.name.clone(),
6994 cx,
6995 )
6996 })?
6997 .await?;
6998
6999 let edits = this
7000 .update(cx, |this, cx| {
7001 let path = buffer_to_edit.read(cx).project_path(cx);
7002 let active_entry = this.active_entry;
7003 let is_active_entry = path.clone().map_or(false, |project_path| {
7004 this.worktree_store
7005 .read(cx)
7006 .entry_for_path(&project_path, cx)
7007 .map_or(false, |entry| Some(entry.id) == active_entry)
7008 });
7009
7010 let (mut edits, mut snippet_edits) = (vec![], vec![]);
7011 for edit in op.edits {
7012 match edit {
7013 Edit::Plain(edit) => edits.push(edit),
7014 Edit::Annotated(edit) => edits.push(edit.text_edit),
7015 Edit::Snippet(edit) => {
7016 let Ok(snippet) = Snippet::parse(&edit.snippet.value)
7017 else {
7018 continue;
7019 };
7020
7021 if is_active_entry {
7022 snippet_edits.push((edit.range, snippet));
7023 } else {
7024 // Since this buffer is not focused, apply a normal edit.
7025 edits.push(TextEdit {
7026 range: edit.range,
7027 new_text: snippet.text,
7028 });
7029 }
7030 }
7031 }
7032 }
7033 if !snippet_edits.is_empty() {
7034 let buffer_id = buffer_to_edit.read(cx).remote_id();
7035 let version = if let Some(buffer_version) = op.text_document.version
7036 {
7037 this.buffer_snapshot_for_lsp_version(
7038 &buffer_to_edit,
7039 language_server.server_id(),
7040 Some(buffer_version),
7041 cx,
7042 )
7043 .ok()
7044 .map(|snapshot| snapshot.version)
7045 } else {
7046 Some(buffer_to_edit.read(cx).saved_version().clone())
7047 };
7048
7049 let most_recent_edit = version.and_then(|version| {
7050 version.iter().max_by_key(|timestamp| timestamp.value)
7051 });
7052 // Check if the edit that triggered that edit has been made by this participant.
7053
7054 if let Some(most_recent_edit) = most_recent_edit {
7055 cx.emit(LspStoreEvent::SnippetEdit {
7056 buffer_id,
7057 edits: snippet_edits,
7058 most_recent_edit,
7059 });
7060 }
7061 }
7062
7063 this.edits_from_lsp(
7064 &buffer_to_edit,
7065 edits,
7066 language_server.server_id(),
7067 op.text_document.version,
7068 cx,
7069 )
7070 })?
7071 .await?;
7072
7073 let transaction = buffer_to_edit.update(cx, |buffer, cx| {
7074 buffer.finalize_last_transaction();
7075 buffer.start_transaction();
7076 for (range, text) in edits {
7077 buffer.edit([(range, text)], None, cx);
7078 }
7079 let transaction = if buffer.end_transaction(cx).is_some() {
7080 let transaction = buffer.finalize_last_transaction().unwrap().clone();
7081 if !push_to_history {
7082 buffer.forget_transaction(transaction.id);
7083 }
7084 Some(transaction)
7085 } else {
7086 None
7087 };
7088
7089 transaction
7090 })?;
7091 if let Some(transaction) = transaction {
7092 project_transaction.0.insert(buffer_to_edit, transaction);
7093 }
7094 }
7095 }
7096 }
7097
7098 Ok(project_transaction)
7099 }
7100
7101 fn serialize_symbol(symbol: &Symbol) -> proto::Symbol {
7102 proto::Symbol {
7103 language_server_name: symbol.language_server_name.0.to_string(),
7104 source_worktree_id: symbol.source_worktree_id.to_proto(),
7105 worktree_id: symbol.path.worktree_id.to_proto(),
7106 path: symbol.path.path.to_string_lossy().to_string(),
7107 name: symbol.name.clone(),
7108 kind: unsafe { mem::transmute::<lsp::SymbolKind, i32>(symbol.kind) },
7109 start: Some(proto::PointUtf16 {
7110 row: symbol.range.start.0.row,
7111 column: symbol.range.start.0.column,
7112 }),
7113 end: Some(proto::PointUtf16 {
7114 row: symbol.range.end.0.row,
7115 column: symbol.range.end.0.column,
7116 }),
7117 signature: symbol.signature.to_vec(),
7118 }
7119 }
7120
7121 fn deserialize_symbol(serialized_symbol: proto::Symbol) -> Result<CoreSymbol> {
7122 let source_worktree_id = WorktreeId::from_proto(serialized_symbol.source_worktree_id);
7123 let worktree_id = WorktreeId::from_proto(serialized_symbol.worktree_id);
7124 let kind = unsafe { mem::transmute::<i32, lsp::SymbolKind>(serialized_symbol.kind) };
7125 let path = ProjectPath {
7126 worktree_id,
7127 path: PathBuf::from(serialized_symbol.path).into(),
7128 };
7129
7130 let start = serialized_symbol
7131 .start
7132 .ok_or_else(|| anyhow!("invalid start"))?;
7133 let end = serialized_symbol
7134 .end
7135 .ok_or_else(|| anyhow!("invalid end"))?;
7136 Ok(CoreSymbol {
7137 language_server_name: LanguageServerName(serialized_symbol.language_server_name.into()),
7138 source_worktree_id,
7139 path,
7140 name: serialized_symbol.name,
7141 range: Unclipped(PointUtf16::new(start.row, start.column))
7142 ..Unclipped(PointUtf16::new(end.row, end.column)),
7143 kind,
7144 signature: serialized_symbol
7145 .signature
7146 .try_into()
7147 .map_err(|_| anyhow!("invalid signature"))?,
7148 })
7149 }
7150
7151 pub(crate) fn serialize_completion(completion: &CoreCompletion) -> proto::Completion {
7152 proto::Completion {
7153 old_start: Some(serialize_anchor(&completion.old_range.start)),
7154 old_end: Some(serialize_anchor(&completion.old_range.end)),
7155 new_text: completion.new_text.clone(),
7156 server_id: completion.server_id.0 as u64,
7157 lsp_completion: serde_json::to_vec(&completion.lsp_completion).unwrap(),
7158 }
7159 }
7160
7161 pub(crate) fn deserialize_completion(completion: proto::Completion) -> Result<CoreCompletion> {
7162 let old_start = completion
7163 .old_start
7164 .and_then(deserialize_anchor)
7165 .ok_or_else(|| anyhow!("invalid old start"))?;
7166 let old_end = completion
7167 .old_end
7168 .and_then(deserialize_anchor)
7169 .ok_or_else(|| anyhow!("invalid old end"))?;
7170 let lsp_completion = serde_json::from_slice(&completion.lsp_completion)?;
7171
7172 Ok(CoreCompletion {
7173 old_range: old_start..old_end,
7174 new_text: completion.new_text,
7175 server_id: LanguageServerId(completion.server_id as usize),
7176 lsp_completion,
7177 })
7178 }
7179
7180 pub(crate) fn serialize_code_action(action: &CodeAction) -> proto::CodeAction {
7181 proto::CodeAction {
7182 server_id: action.server_id.0 as u64,
7183 start: Some(serialize_anchor(&action.range.start)),
7184 end: Some(serialize_anchor(&action.range.end)),
7185 lsp_action: serde_json::to_vec(&action.lsp_action).unwrap(),
7186 }
7187 }
7188
7189 pub(crate) fn deserialize_code_action(action: proto::CodeAction) -> Result<CodeAction> {
7190 let start = action
7191 .start
7192 .and_then(deserialize_anchor)
7193 .ok_or_else(|| anyhow!("invalid start"))?;
7194 let end = action
7195 .end
7196 .and_then(deserialize_anchor)
7197 .ok_or_else(|| anyhow!("invalid end"))?;
7198 let lsp_action = serde_json::from_slice(&action.lsp_action)?;
7199 Ok(CodeAction {
7200 server_id: LanguageServerId(action.server_id as usize),
7201 range: start..end,
7202 lsp_action,
7203 })
7204 }
7205}
7206
7207impl EventEmitter<LspStoreEvent> for LspStore {}
7208
7209fn remove_empty_hover_blocks(mut hover: Hover) -> Option<Hover> {
7210 hover
7211 .contents
7212 .retain(|hover_block| !hover_block.text.trim().is_empty());
7213 if hover.contents.is_empty() {
7214 None
7215 } else {
7216 Some(hover)
7217 }
7218}
7219
7220async fn populate_labels_for_completions(
7221 mut new_completions: Vec<CoreCompletion>,
7222 language_registry: &Arc<LanguageRegistry>,
7223 language: Option<Arc<Language>>,
7224 lsp_adapter: Option<Arc<CachedLspAdapter>>,
7225 completions: &mut Vec<Completion>,
7226) {
7227 let lsp_completions = new_completions
7228 .iter_mut()
7229 .map(|completion| mem::take(&mut completion.lsp_completion))
7230 .collect::<Vec<_>>();
7231
7232 let labels = if let Some((language, lsp_adapter)) = language.as_ref().zip(lsp_adapter) {
7233 lsp_adapter
7234 .labels_for_completions(&lsp_completions, language)
7235 .await
7236 .log_err()
7237 .unwrap_or_default()
7238 } else {
7239 Vec::new()
7240 };
7241
7242 for ((completion, lsp_completion), label) in new_completions
7243 .into_iter()
7244 .zip(lsp_completions)
7245 .zip(labels.into_iter().chain(iter::repeat(None)))
7246 {
7247 let documentation = if let Some(docs) = &lsp_completion.documentation {
7248 Some(prepare_completion_documentation(docs, language_registry, language.clone()).await)
7249 } else {
7250 None
7251 };
7252
7253 completions.push(Completion {
7254 old_range: completion.old_range,
7255 new_text: completion.new_text,
7256 label: label.unwrap_or_else(|| {
7257 CodeLabel::plain(
7258 lsp_completion.label.clone(),
7259 lsp_completion.filter_text.as_deref(),
7260 )
7261 }),
7262 server_id: completion.server_id,
7263 documentation,
7264 lsp_completion,
7265 confirm: None,
7266 })
7267 }
7268}
7269
7270#[derive(Debug)]
7271pub enum LanguageServerToQuery {
7272 Primary,
7273 Other(LanguageServerId),
7274}
7275
7276#[derive(Default)]
7277struct LanguageServerWatchedPaths {
7278 worktree_paths: HashMap<WorktreeId, GlobSet>,
7279 abs_paths: HashMap<Arc<Path>, (GlobSet, Task<()>)>,
7280}
7281
7282#[derive(Default)]
7283struct LanguageServerWatchedPathsBuilder {
7284 worktree_paths: HashMap<WorktreeId, GlobSet>,
7285 abs_paths: HashMap<Arc<Path>, GlobSet>,
7286}
7287
7288impl LanguageServerWatchedPathsBuilder {
7289 fn watch_worktree(&mut self, worktree_id: WorktreeId, glob_set: GlobSet) {
7290 self.worktree_paths.insert(worktree_id, glob_set);
7291 }
7292 fn watch_abs_path(&mut self, path: Arc<Path>, glob_set: GlobSet) {
7293 self.abs_paths.insert(path, glob_set);
7294 }
7295 fn build(
7296 self,
7297 fs: Arc<dyn Fs>,
7298 language_server_id: LanguageServerId,
7299 cx: &mut ModelContext<LspStore>,
7300 ) -> Model<LanguageServerWatchedPaths> {
7301 let project = cx.weak_model();
7302
7303 cx.new_model(|cx| {
7304 let this_id = cx.entity_id();
7305 const LSP_ABS_PATH_OBSERVE: Duration = Duration::from_millis(100);
7306 let abs_paths = self
7307 .abs_paths
7308 .into_iter()
7309 .map(|(abs_path, globset)| {
7310 let task = cx.spawn({
7311 let abs_path = abs_path.clone();
7312 let fs = fs.clone();
7313
7314 let lsp_store = project.clone();
7315 |_, mut cx| async move {
7316 maybe!(async move {
7317 let mut push_updates =
7318 fs.watch(&abs_path, LSP_ABS_PATH_OBSERVE).await;
7319 while let Some(update) = push_updates.0.next().await {
7320 let action = lsp_store
7321 .update(&mut cx, |this, cx| {
7322 let Some(local) = this.as_local() else {
7323 return ControlFlow::Break(());
7324 };
7325 let Some(watcher) = local
7326 .language_server_watched_paths
7327 .get(&language_server_id)
7328 else {
7329 return ControlFlow::Break(());
7330 };
7331 if watcher.entity_id() != this_id {
7332 // This watcher is no longer registered on the project, which means that we should
7333 // cease operations.
7334 return ControlFlow::Break(());
7335 }
7336 let (globs, _) = watcher
7337 .read(cx)
7338 .abs_paths
7339 .get(&abs_path)
7340 .expect(
7341 "Watched abs path is not registered with a watcher",
7342 );
7343 let matching_entries = update
7344 .into_iter()
7345 .filter(|event| globs.is_match(&event.path))
7346 .collect::<Vec<_>>();
7347 this.lsp_notify_abs_paths_changed(
7348 language_server_id,
7349 matching_entries,
7350 );
7351 ControlFlow::Continue(())
7352 })
7353 .ok()?;
7354
7355 if action.is_break() {
7356 break;
7357 }
7358 }
7359 Some(())
7360 })
7361 .await;
7362 }
7363 });
7364 (abs_path, (globset, task))
7365 })
7366 .collect();
7367 LanguageServerWatchedPaths {
7368 worktree_paths: self.worktree_paths,
7369 abs_paths,
7370 }
7371 })
7372 }
7373}
7374
7375struct LspBufferSnapshot {
7376 version: i32,
7377 snapshot: TextBufferSnapshot,
7378}
7379
7380/// A prompt requested by LSP server.
7381#[derive(Clone, Debug)]
7382pub struct LanguageServerPromptRequest {
7383 pub level: PromptLevel,
7384 pub message: String,
7385 pub actions: Vec<MessageActionItem>,
7386 pub lsp_name: String,
7387 pub(crate) response_channel: Sender<MessageActionItem>,
7388}
7389
7390impl LanguageServerPromptRequest {
7391 pub async fn respond(self, index: usize) -> Option<()> {
7392 if let Some(response) = self.actions.into_iter().nth(index) {
7393 self.response_channel.send(response).await.ok()
7394 } else {
7395 None
7396 }
7397 }
7398}
7399impl PartialEq for LanguageServerPromptRequest {
7400 fn eq(&self, other: &Self) -> bool {
7401 self.message == other.message && self.actions == other.actions
7402 }
7403}
7404
7405#[derive(Clone, Debug, PartialEq)]
7406pub enum LanguageServerLogType {
7407 Log(MessageType),
7408 Trace(Option<String>),
7409}
7410
7411impl LanguageServerLogType {
7412 pub fn to_proto(&self) -> proto::language_server_log::LogType {
7413 match self {
7414 Self::Log(log_type) => {
7415 let message_type = match *log_type {
7416 MessageType::ERROR => 1,
7417 MessageType::WARNING => 2,
7418 MessageType::INFO => 3,
7419 MessageType::LOG => 4,
7420 other => {
7421 log::warn!("Unknown lsp log message type: {:?}", other);
7422 4
7423 }
7424 };
7425 proto::language_server_log::LogType::LogMessageType(message_type)
7426 }
7427 Self::Trace(message) => {
7428 proto::language_server_log::LogType::LogTrace(proto::LspLogTrace {
7429 message: message.clone(),
7430 })
7431 }
7432 }
7433 }
7434
7435 pub fn from_proto(log_type: proto::language_server_log::LogType) -> Self {
7436 match log_type {
7437 proto::language_server_log::LogType::LogMessageType(message_type) => {
7438 Self::Log(match message_type {
7439 1 => MessageType::ERROR,
7440 2 => MessageType::WARNING,
7441 3 => MessageType::INFO,
7442 4 => MessageType::LOG,
7443 _ => MessageType::LOG,
7444 })
7445 }
7446 proto::language_server_log::LogType::LogTrace(trace) => Self::Trace(trace.message),
7447 }
7448 }
7449}
7450
7451pub enum LanguageServerState {
7452 Starting(Task<Option<Arc<LanguageServer>>>),
7453
7454 Running {
7455 language: LanguageName,
7456 adapter: Arc<CachedLspAdapter>,
7457 server: Arc<LanguageServer>,
7458 simulate_disk_based_diagnostics_completion: Option<Task<()>>,
7459 },
7460}
7461
7462impl std::fmt::Debug for LanguageServerState {
7463 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7464 match self {
7465 LanguageServerState::Starting(_) => {
7466 f.debug_struct("LanguageServerState::Starting").finish()
7467 }
7468 LanguageServerState::Running { language, .. } => f
7469 .debug_struct("LanguageServerState::Running")
7470 .field("language", &language)
7471 .finish(),
7472 }
7473 }
7474}
7475
7476#[derive(Clone, Debug, Serialize)]
7477pub struct LanguageServerProgress {
7478 pub is_disk_based_diagnostics_progress: bool,
7479 pub is_cancellable: bool,
7480 pub title: Option<String>,
7481 pub message: Option<String>,
7482 pub percentage: Option<usize>,
7483 #[serde(skip_serializing)]
7484 pub last_update_at: Instant,
7485}
7486
7487#[derive(Copy, Clone, Debug, Default, PartialEq, Serialize)]
7488pub struct DiagnosticSummary {
7489 pub error_count: usize,
7490 pub warning_count: usize,
7491}
7492
7493impl DiagnosticSummary {
7494 pub fn new<'a, T: 'a>(diagnostics: impl IntoIterator<Item = &'a DiagnosticEntry<T>>) -> Self {
7495 let mut this = Self {
7496 error_count: 0,
7497 warning_count: 0,
7498 };
7499
7500 for entry in diagnostics {
7501 if entry.diagnostic.is_primary {
7502 match entry.diagnostic.severity {
7503 DiagnosticSeverity::ERROR => this.error_count += 1,
7504 DiagnosticSeverity::WARNING => this.warning_count += 1,
7505 _ => {}
7506 }
7507 }
7508 }
7509
7510 this
7511 }
7512
7513 pub fn is_empty(&self) -> bool {
7514 self.error_count == 0 && self.warning_count == 0
7515 }
7516
7517 pub fn to_proto(
7518 &self,
7519 language_server_id: LanguageServerId,
7520 path: &Path,
7521 ) -> proto::DiagnosticSummary {
7522 proto::DiagnosticSummary {
7523 path: path.to_string_lossy().to_string(),
7524 language_server_id: language_server_id.0 as u64,
7525 error_count: self.error_count as u32,
7526 warning_count: self.warning_count as u32,
7527 }
7528 }
7529}
7530
7531fn glob_literal_prefix(glob: &str) -> &str {
7532 let is_absolute = glob.starts_with(path::MAIN_SEPARATOR);
7533
7534 let mut literal_end = is_absolute as usize;
7535 for (i, part) in glob.split(path::MAIN_SEPARATOR).enumerate() {
7536 if part.contains(['*', '?', '{', '}']) {
7537 break;
7538 } else {
7539 if i > 0 {
7540 // Account for separator prior to this part
7541 literal_end += path::MAIN_SEPARATOR.len_utf8();
7542 }
7543 literal_end += part.len();
7544 }
7545 }
7546 let literal_end = literal_end.min(glob.len());
7547 &glob[..literal_end]
7548}
7549
7550pub struct SshLspAdapter {
7551 name: LanguageServerName,
7552 binary: LanguageServerBinary,
7553 initialization_options: Option<String>,
7554 code_action_kinds: Option<Vec<CodeActionKind>>,
7555}
7556
7557impl SshLspAdapter {
7558 pub fn new(
7559 name: LanguageServerName,
7560 binary: LanguageServerBinary,
7561 initialization_options: Option<String>,
7562 code_action_kinds: Option<String>,
7563 ) -> Self {
7564 Self {
7565 name,
7566 binary,
7567 initialization_options,
7568 code_action_kinds: code_action_kinds
7569 .as_ref()
7570 .and_then(|c| serde_json::from_str(c).ok()),
7571 }
7572 }
7573}
7574
7575#[async_trait(?Send)]
7576impl LspAdapter for SshLspAdapter {
7577 fn name(&self) -> LanguageServerName {
7578 self.name.clone()
7579 }
7580
7581 async fn initialization_options(
7582 self: Arc<Self>,
7583 _: &Arc<dyn LspAdapterDelegate>,
7584 ) -> Result<Option<serde_json::Value>> {
7585 let Some(options) = &self.initialization_options else {
7586 return Ok(None);
7587 };
7588 let result = serde_json::from_str(options)?;
7589 Ok(result)
7590 }
7591
7592 fn code_action_kinds(&self) -> Option<Vec<CodeActionKind>> {
7593 self.code_action_kinds.clone()
7594 }
7595
7596 async fn check_if_user_installed(
7597 &self,
7598 _: &dyn LspAdapterDelegate,
7599 _: &AsyncAppContext,
7600 ) -> Option<LanguageServerBinary> {
7601 Some(self.binary.clone())
7602 }
7603
7604 async fn cached_server_binary(
7605 &self,
7606 _: PathBuf,
7607 _: &dyn LspAdapterDelegate,
7608 ) -> Option<LanguageServerBinary> {
7609 None
7610 }
7611
7612 async fn fetch_latest_server_version(
7613 &self,
7614 _: &dyn LspAdapterDelegate,
7615 ) -> Result<Box<dyn 'static + Send + Any>> {
7616 anyhow::bail!("SshLspAdapter does not support fetch_latest_server_version")
7617 }
7618
7619 async fn fetch_server_binary(
7620 &self,
7621 _: Box<dyn 'static + Send + Any>,
7622 _: PathBuf,
7623 _: &dyn LspAdapterDelegate,
7624 ) -> Result<LanguageServerBinary> {
7625 anyhow::bail!("SshLspAdapter does not support fetch_server_binary")
7626 }
7627}
7628
7629pub fn language_server_settings<'a, 'b: 'a>(
7630 delegate: &'a dyn LspAdapterDelegate,
7631 language: &LanguageServerName,
7632 cx: &'b AppContext,
7633) -> Option<&'a LspSettings> {
7634 ProjectSettings::get(
7635 Some(SettingsLocation {
7636 worktree_id: delegate.worktree_id(),
7637 path: delegate.worktree_root_path(),
7638 }),
7639 cx,
7640 )
7641 .lsp
7642 .get(language)
7643}
7644
7645pub struct LocalLspAdapterDelegate {
7646 lsp_store: WeakModel<LspStore>,
7647 worktree: worktree::Snapshot,
7648 fs: Arc<dyn Fs>,
7649 http_client: Arc<dyn HttpClient>,
7650 language_registry: Arc<LanguageRegistry>,
7651 load_shell_env_task: Shared<Task<Option<HashMap<String, String>>>>,
7652}
7653
7654impl LocalLspAdapterDelegate {
7655 fn for_local(
7656 lsp_store: &LspStore,
7657 worktree: &Model<Worktree>,
7658 cx: &mut ModelContext<LspStore>,
7659 ) -> Arc<Self> {
7660 let local = lsp_store
7661 .as_local()
7662 .expect("LocalLspAdapterDelegate cannot be constructed on a remote");
7663
7664 let http_client = local.http_client.clone();
7665
7666 Self::new(lsp_store, worktree, http_client, local.fs.clone(), cx)
7667 }
7668
7669 pub fn new(
7670 lsp_store: &LspStore,
7671 worktree: &Model<Worktree>,
7672 http_client: Arc<dyn HttpClient>,
7673 fs: Arc<dyn Fs>,
7674 cx: &mut ModelContext<LspStore>,
7675 ) -> Arc<Self> {
7676 let worktree_id = worktree.read(cx).id();
7677 let worktree_abs_path = worktree.read(cx).abs_path();
7678 let load_shell_env_task = if let Some(environment) =
7679 &lsp_store.as_local().map(|local| local.environment.clone())
7680 {
7681 environment.update(cx, |env, cx| {
7682 env.get_environment(Some(worktree_id), Some(worktree_abs_path), cx)
7683 })
7684 } else {
7685 Task::ready(None).shared()
7686 };
7687
7688 Arc::new(Self {
7689 lsp_store: cx.weak_model(),
7690 worktree: worktree.read(cx).snapshot(),
7691 fs,
7692 http_client,
7693 language_registry: lsp_store.languages.clone(),
7694 load_shell_env_task,
7695 })
7696 }
7697}
7698
7699#[async_trait]
7700impl LspAdapterDelegate for LocalLspAdapterDelegate {
7701 fn show_notification(&self, message: &str, cx: &mut AppContext) {
7702 self.lsp_store
7703 .update(cx, |_, cx| {
7704 cx.emit(LspStoreEvent::Notification(message.to_owned()))
7705 })
7706 .ok();
7707 }
7708
7709 fn http_client(&self) -> Arc<dyn HttpClient> {
7710 self.http_client.clone()
7711 }
7712
7713 fn worktree_id(&self) -> WorktreeId {
7714 self.worktree.id()
7715 }
7716
7717 fn worktree_root_path(&self) -> &Path {
7718 self.worktree.abs_path().as_ref()
7719 }
7720
7721 async fn shell_env(&self) -> HashMap<String, String> {
7722 let task = self.load_shell_env_task.clone();
7723 task.await.unwrap_or_default()
7724 }
7725
7726 async fn npm_package_installed_version(
7727 &self,
7728 package_name: &str,
7729 ) -> Result<Option<(PathBuf, String)>> {
7730 let local_package_directory = self.worktree_root_path();
7731 let node_modules_directory = local_package_directory.join("node_modules");
7732
7733 if let Some(version) =
7734 read_package_installed_version(node_modules_directory.clone(), package_name).await?
7735 {
7736 return Ok(Some((node_modules_directory, version)));
7737 }
7738 let Some(npm) = self.which("npm".as_ref()).await else {
7739 log::warn!(
7740 "Failed to find npm executable for {:?}",
7741 local_package_directory
7742 );
7743 return Ok(None);
7744 };
7745
7746 let env = self.shell_env().await;
7747 let output = smol::process::Command::new(&npm)
7748 .args(["root", "-g"])
7749 .envs(env)
7750 .current_dir(local_package_directory)
7751 .output()
7752 .await?;
7753 let global_node_modules =
7754 PathBuf::from(String::from_utf8_lossy(&output.stdout).to_string());
7755
7756 if let Some(version) =
7757 read_package_installed_version(global_node_modules.clone(), package_name).await?
7758 {
7759 return Ok(Some((global_node_modules, version)));
7760 }
7761 return Ok(None);
7762 }
7763
7764 #[cfg(not(target_os = "windows"))]
7765 async fn which(&self, command: &OsStr) -> Option<PathBuf> {
7766 let worktree_abs_path = self.worktree.abs_path();
7767 let shell_path = self.shell_env().await.get("PATH").cloned();
7768 which::which_in(command, shell_path.as_ref(), worktree_abs_path).ok()
7769 }
7770
7771 #[cfg(target_os = "windows")]
7772 async fn which(&self, command: &OsStr) -> Option<PathBuf> {
7773 // todo(windows) Getting the shell env variables in a current directory on Windows is more complicated than other platforms
7774 // there isn't a 'default shell' necessarily. The closest would be the default profile on the windows terminal
7775 // SEE: https://learn.microsoft.com/en-us/windows/terminal/customize-settings/startup
7776 which::which(command).ok()
7777 }
7778
7779 async fn try_exec(&self, command: LanguageServerBinary) -> Result<()> {
7780 let working_dir = self.worktree_root_path();
7781 let output = smol::process::Command::new(&command.path)
7782 .args(command.arguments)
7783 .envs(command.env.clone().unwrap_or_default())
7784 .current_dir(working_dir)
7785 .output()
7786 .await?;
7787
7788 if output.status.success() {
7789 return Ok(());
7790 }
7791 Err(anyhow!(
7792 "{}, stdout: {:?}, stderr: {:?}",
7793 output.status,
7794 String::from_utf8_lossy(&output.stdout),
7795 String::from_utf8_lossy(&output.stderr)
7796 ))
7797 }
7798
7799 fn update_status(
7800 &self,
7801 server_name: LanguageServerName,
7802 status: language::LanguageServerBinaryStatus,
7803 ) {
7804 self.language_registry
7805 .update_lsp_status(server_name, status);
7806 }
7807
7808 async fn language_server_download_dir(&self, name: &LanguageServerName) -> Option<Arc<Path>> {
7809 let dir = self.language_registry.language_server_download_dir(name)?;
7810
7811 if !dir.exists() {
7812 smol::fs::create_dir_all(&dir)
7813 .await
7814 .context("failed to create container directory")
7815 .log_err()?;
7816 }
7817
7818 Some(dir)
7819 }
7820
7821 async fn read_text_file(&self, path: PathBuf) -> Result<String> {
7822 let entry = self
7823 .worktree
7824 .entry_for_path(&path)
7825 .with_context(|| format!("no worktree entry for path {path:?}"))?;
7826 let abs_path = self
7827 .worktree
7828 .absolutize(&entry.path)
7829 .with_context(|| format!("cannot absolutize path {path:?}"))?;
7830
7831 self.fs.load(&abs_path).await
7832 }
7833}
7834
7835async fn populate_labels_for_symbols(
7836 symbols: Vec<CoreSymbol>,
7837 language_registry: &Arc<LanguageRegistry>,
7838 default_language: Option<LanguageName>,
7839 lsp_adapter: Option<Arc<CachedLspAdapter>>,
7840 output: &mut Vec<Symbol>,
7841) {
7842 #[allow(clippy::mutable_key_type)]
7843 let mut symbols_by_language = HashMap::<Option<Arc<Language>>, Vec<CoreSymbol>>::default();
7844
7845 let mut unknown_path = None;
7846 for symbol in symbols {
7847 let language = language_registry
7848 .language_for_file_path(&symbol.path.path)
7849 .await
7850 .ok()
7851 .or_else(|| {
7852 unknown_path.get_or_insert(symbol.path.path.clone());
7853 default_language.as_ref().and_then(|name| {
7854 language_registry
7855 .language_for_name(&name.0)
7856 .now_or_never()?
7857 .ok()
7858 })
7859 });
7860 symbols_by_language
7861 .entry(language)
7862 .or_default()
7863 .push(symbol);
7864 }
7865
7866 if let Some(unknown_path) = unknown_path {
7867 log::info!(
7868 "no language found for symbol path {}",
7869 unknown_path.display()
7870 );
7871 }
7872
7873 let mut label_params = Vec::new();
7874 for (language, mut symbols) in symbols_by_language {
7875 label_params.clear();
7876 label_params.extend(
7877 symbols
7878 .iter_mut()
7879 .map(|symbol| (mem::take(&mut symbol.name), symbol.kind)),
7880 );
7881
7882 let mut labels = Vec::new();
7883 if let Some(language) = language {
7884 let lsp_adapter = lsp_adapter.clone().or_else(|| {
7885 language_registry
7886 .lsp_adapters(&language.name())
7887 .first()
7888 .cloned()
7889 });
7890 if let Some(lsp_adapter) = lsp_adapter {
7891 labels = lsp_adapter
7892 .labels_for_symbols(&label_params, &language)
7893 .await
7894 .log_err()
7895 .unwrap_or_default();
7896 }
7897 }
7898
7899 for ((symbol, (name, _)), label) in symbols
7900 .into_iter()
7901 .zip(label_params.drain(..))
7902 .zip(labels.into_iter().chain(iter::repeat(None)))
7903 {
7904 output.push(Symbol {
7905 language_server_name: symbol.language_server_name,
7906 source_worktree_id: symbol.source_worktree_id,
7907 path: symbol.path,
7908 label: label.unwrap_or_else(|| CodeLabel::plain(name.clone(), None)),
7909 name,
7910 kind: symbol.kind,
7911 range: symbol.range,
7912 signature: symbol.signature,
7913 });
7914 }
7915 }
7916}
7917
7918fn include_text(server: &lsp::LanguageServer) -> Option<bool> {
7919 match server.capabilities().text_document_sync.as_ref()? {
7920 lsp::TextDocumentSyncCapability::Kind(kind) => match *kind {
7921 lsp::TextDocumentSyncKind::NONE => None,
7922 lsp::TextDocumentSyncKind::FULL => Some(true),
7923 lsp::TextDocumentSyncKind::INCREMENTAL => Some(false),
7924 _ => None,
7925 },
7926 lsp::TextDocumentSyncCapability::Options(options) => match options.save.as_ref()? {
7927 lsp::TextDocumentSyncSaveOptions::Supported(supported) => {
7928 if *supported {
7929 Some(true)
7930 } else {
7931 None
7932 }
7933 }
7934 lsp::TextDocumentSyncSaveOptions::SaveOptions(save_options) => {
7935 Some(save_options.include_text.unwrap_or(false))
7936 }
7937 },
7938 }
7939}
7940
7941#[cfg(test)]
7942#[test]
7943fn test_glob_literal_prefix() {
7944 assert_eq!(glob_literal_prefix("**/*.js"), "");
7945 assert_eq!(glob_literal_prefix("node_modules/**/*.js"), "node_modules");
7946 assert_eq!(glob_literal_prefix("foo/{bar,baz}.js"), "foo");
7947 assert_eq!(glob_literal_prefix("foo/bar/baz.js"), "foo/bar/baz.js");
7948}