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