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