1pub mod agent_registry_store;
2pub mod agent_server_store;
3pub mod bookmark_store;
4pub mod buffer_store;
5pub mod color_extractor;
6pub mod connection_manager;
7pub mod context_server_store;
8pub mod debounced_delay;
9pub mod debugger;
10pub mod git_store;
11pub mod image_store;
12pub mod lsp_command;
13pub mod lsp_store;
14pub mod manifest_tree;
15pub mod prettier_store;
16pub mod project_search;
17pub mod project_settings;
18pub mod search;
19pub mod task_inventory;
20pub mod task_store;
21pub mod telemetry_snapshot;
22pub mod terminals;
23pub mod toolchain_store;
24pub mod trusted_worktrees;
25pub mod worktree_store;
26
27mod environment;
28use buffer_diff::BufferDiff;
29use context_server_store::ContextServerStore;
30pub use environment::ProjectEnvironmentEvent;
31use git::repository::get_git_committer;
32use git_store::{Repository, RepositoryId};
33pub mod search_history;
34pub mod yarn;
35
36use dap::inline_value::{InlineValueLocation, VariableLookupKind, VariableScope};
37use itertools::{Either, Itertools};
38
39use crate::{
40 bookmark_store::BookmarkStore,
41 git_store::GitStore,
42 lsp_store::{SymbolLocation, log_store::LogKind},
43 project_search::SearchResultsHandle,
44 trusted_worktrees::{PathTrust, RemoteHostLocation, TrustedWorktrees},
45 worktree_store::WorktreeIdCounter,
46};
47pub use agent_registry_store::{AgentRegistryStore, RegistryAgent};
48pub use agent_server_store::{AgentId, AgentServerStore, AgentServersUpdated, ExternalAgentSource};
49pub use git_store::{
50 ConflictRegion, ConflictSet, ConflictSetSnapshot, ConflictSetUpdate,
51 git_traversal::{ChildEntriesGitIter, GitEntry, GitEntryRef, GitTraversal},
52 linked_worktree_short_name, worktrees_directory_for_repo,
53};
54pub use manifest_tree::ManifestTree;
55pub use project_search::{Search, SearchResults};
56pub use worktree_store::WorktreePaths;
57
58use anyhow::{Context as _, Result, anyhow};
59use buffer_store::{BufferStore, BufferStoreEvent};
60use client::{
61 Client, Collaborator, PendingEntitySubscription, ProjectId, TypedEnvelope, UserStore, proto,
62};
63use clock::ReplicaId;
64
65use dap::client::DebugAdapterClient;
66
67use collections::{BTreeSet, HashMap, HashSet, IndexSet};
68use debounced_delay::DebouncedDelay;
69pub use debugger::breakpoint_store::BreakpointWithPosition;
70use debugger::{
71 breakpoint_store::{ActiveStackFrame, BreakpointStore},
72 dap_store::{DapStore, DapStoreEvent},
73 session::Session,
74};
75
76pub use environment::ProjectEnvironment;
77
78use futures::{
79 StreamExt,
80 channel::mpsc::{self, UnboundedReceiver},
81 future::try_join_all,
82};
83pub use image_store::{ImageItem, ImageStore};
84use image_store::{ImageItemEvent, ImageStoreEvent};
85
86use ::git::{blame::Blame, status::FileStatus};
87use gpui::{
88 App, AppContext, AsyncApp, BorrowAppContext, Context, Entity, EventEmitter, Hsla, SharedString,
89 Task, WeakEntity, Window,
90};
91use language::{
92 Buffer, BufferEvent, Capability, CodeLabel, CursorShape, DiskState, Language, LanguageName,
93 LanguageRegistry, PointUtf16, ToOffset, ToPointUtf16, Toolchain, ToolchainMetadata,
94 ToolchainScope, Transaction, Unclipped, language_settings::InlayHintKind,
95 proto::split_operations,
96};
97use lsp::{
98 CodeActionKind, CompletionContext, CompletionItemKind, DocumentHighlightKind, InsertTextMode,
99 LanguageServerBinary, LanguageServerId, LanguageServerName, LanguageServerSelector,
100 MessageActionItem,
101};
102use lsp_command::*;
103use lsp_store::{CompletionDocumentation, LspFormatTarget, OpenLspBufferHandle};
104pub use manifest_tree::ManifestProvidersStore;
105use node_runtime::NodeRuntime;
106use parking_lot::Mutex;
107pub use prettier_store::PrettierStore;
108use project_settings::{ProjectSettings, SettingsObserver, SettingsObserverEvent};
109#[cfg(target_os = "windows")]
110use remote::wsl_path_to_windows_path;
111use remote::{RemoteClient, RemoteConnectionOptions};
112use rpc::{
113 AnyProtoClient, ErrorCode,
114 proto::{LanguageServerPromptResponse, REMOTE_SERVER_PROJECT_ID},
115};
116use search::{SearchInputKind, SearchQuery, SearchResult};
117use search_history::SearchHistory;
118use settings::{InvalidSettingsError, RegisterSetting, Settings, SettingsLocation, SettingsStore};
119use snippet::Snippet;
120pub use snippet_provider;
121use snippet_provider::SnippetProvider;
122use std::{
123 borrow::Cow,
124 collections::BTreeMap,
125 ffi::OsString,
126 future::Future,
127 ops::{Not as _, Range},
128 path::{Path, PathBuf},
129 pin::pin,
130 str::{self, FromStr},
131 sync::Arc,
132 time::Duration,
133};
134
135use task_store::TaskStore;
136use terminals::Terminals;
137use text::{Anchor, BufferId, Point, Rope};
138use toolchain_store::EmptyToolchainStore;
139use util::{
140 ResultExt as _, maybe,
141 path_list::PathList,
142 paths::{PathStyle, SanitizedPath, is_absolute},
143 rel_path::RelPath,
144};
145use worktree::{CreatedEntry, Snapshot, Traversal};
146pub use worktree::{
147 Entry, EntryKind, FS_WATCH_LATENCY, File, LocalWorktree, PathChange, ProjectEntryId,
148 UpdatedEntriesSet, UpdatedGitRepositoriesSet, Worktree, WorktreeId, WorktreeSettings,
149 discover_root_repo_common_dir,
150};
151use worktree_store::{WorktreeStore, WorktreeStoreEvent};
152
153pub use fs::*;
154pub use language::Location;
155#[cfg(any(test, feature = "test-support"))]
156pub use prettier::FORMAT_SUFFIX as TEST_PRETTIER_FORMAT_SUFFIX;
157#[cfg(any(test, feature = "test-support"))]
158pub use prettier::RANGE_FORMAT_SUFFIX as TEST_PRETTIER_RANGE_FORMAT_SUFFIX;
159pub use task_inventory::{
160 BasicContextProvider, ContextProviderWithTasks, DebugScenarioContext, Inventory, TaskContexts,
161 TaskSourceKind,
162};
163
164pub use buffer_store::ProjectTransaction;
165pub use lsp_store::{
166 DiagnosticSummary, InvalidationStrategy, LanguageServerLogType, LanguageServerProgress,
167 LanguageServerPromptRequest, LanguageServerStatus, LanguageServerToQuery, LspStore,
168 LspStoreEvent, ProgressToken, SERVER_PROGRESS_THROTTLE_TIMEOUT,
169};
170pub use toolchain_store::{ToolchainStore, Toolchains};
171const MAX_PROJECT_SEARCH_HISTORY_SIZE: usize = 500;
172
173#[derive(Clone, Copy, Debug)]
174pub struct LocalProjectFlags {
175 pub init_worktree_trust: bool,
176 pub watch_global_configs: bool,
177}
178
179impl Default for LocalProjectFlags {
180 fn default() -> Self {
181 Self {
182 init_worktree_trust: true,
183 watch_global_configs: true,
184 }
185 }
186}
187
188pub trait ProjectItem: 'static {
189 fn try_open(
190 project: &Entity<Project>,
191 path: &ProjectPath,
192 cx: &mut App,
193 ) -> Option<Task<Result<Entity<Self>>>>
194 where
195 Self: Sized;
196 fn entry_id(&self, cx: &App) -> Option<ProjectEntryId>;
197 fn project_path(&self, cx: &App) -> Option<ProjectPath>;
198 fn is_dirty(&self) -> bool;
199}
200
201#[derive(Clone)]
202pub enum OpenedBufferEvent {
203 Disconnected,
204 Ok(BufferId),
205 Err(BufferId, Arc<anyhow::Error>),
206}
207
208/// Semantics-aware entity that is relevant to one or more [`Worktree`] with the files.
209/// `Project` is responsible for tasks, LSP and collab queries, synchronizing worktree states accordingly.
210/// Maps [`Worktree`] entries with its own logic using [`ProjectEntryId`] and [`ProjectPath`] structs.
211///
212/// Can be either local (for the project opened on the same host) or remote.(for collab projects, browsed by multiple remote users).
213pub struct Project {
214 active_entry: Option<ProjectEntryId>,
215 buffer_ordered_messages_tx: mpsc::UnboundedSender<BufferOrderedMessage>,
216 languages: Arc<LanguageRegistry>,
217 dap_store: Entity<DapStore>,
218 agent_server_store: Entity<AgentServerStore>,
219
220 bookmark_store: Entity<BookmarkStore>,
221 breakpoint_store: Entity<BreakpointStore>,
222 collab_client: Arc<client::Client>,
223 join_project_response_message_id: u32,
224 task_store: Entity<TaskStore>,
225 user_store: Entity<UserStore>,
226 fs: Arc<dyn Fs>,
227 remote_client: Option<Entity<RemoteClient>>,
228 // todo lw explain the client_state x remote_client matrix, its super confusing
229 client_state: ProjectClientState,
230 git_store: Entity<GitStore>,
231 collaborators: HashMap<proto::PeerId, Collaborator>,
232 client_subscriptions: Vec<client::Subscription>,
233 worktree_store: Entity<WorktreeStore>,
234 buffer_store: Entity<BufferStore>,
235 context_server_store: Entity<ContextServerStore>,
236 image_store: Entity<ImageStore>,
237 lsp_store: Entity<LspStore>,
238 _subscriptions: Vec<gpui::Subscription>,
239 buffers_needing_diff: HashSet<WeakEntity<Buffer>>,
240 git_diff_debouncer: DebouncedDelay<Self>,
241 remotely_created_models: Arc<Mutex<RemotelyCreatedModels>>,
242 terminals: Terminals,
243 node: Option<NodeRuntime>,
244 search_history: SearchHistory,
245 search_included_history: SearchHistory,
246 search_excluded_history: SearchHistory,
247 snippets: Entity<SnippetProvider>,
248 environment: Entity<ProjectEnvironment>,
249 settings_observer: Entity<SettingsObserver>,
250 toolchain_store: Option<Entity<ToolchainStore>>,
251 agent_location: Option<AgentLocation>,
252 downloading_files: Arc<Mutex<HashMap<(WorktreeId, String), DownloadingFile>>>,
253 last_worktree_paths: WorktreePaths,
254}
255
256struct DownloadingFile {
257 destination_path: PathBuf,
258 chunks: Vec<u8>,
259 total_size: u64,
260 file_id: Option<u64>, // Set when we receive the State message
261}
262
263#[derive(Clone, Debug, PartialEq, Eq)]
264pub struct AgentLocation {
265 pub buffer: WeakEntity<Buffer>,
266 pub position: Anchor,
267}
268
269#[derive(Default)]
270struct RemotelyCreatedModels {
271 worktrees: Vec<Entity<Worktree>>,
272 buffers: Vec<Entity<Buffer>>,
273 retain_count: usize,
274}
275
276struct RemotelyCreatedModelGuard {
277 remote_models: std::sync::Weak<Mutex<RemotelyCreatedModels>>,
278}
279
280impl Drop for RemotelyCreatedModelGuard {
281 fn drop(&mut self) {
282 if let Some(remote_models) = self.remote_models.upgrade() {
283 let mut remote_models = remote_models.lock();
284 assert!(
285 remote_models.retain_count > 0,
286 "RemotelyCreatedModelGuard dropped too many times"
287 );
288 remote_models.retain_count -= 1;
289 if remote_models.retain_count == 0 {
290 remote_models.buffers.clear();
291 remote_models.worktrees.clear();
292 }
293 }
294 }
295}
296/// Message ordered with respect to buffer operations
297#[derive(Debug)]
298enum BufferOrderedMessage {
299 Operation {
300 buffer_id: BufferId,
301 operation: proto::Operation,
302 },
303 LanguageServerUpdate {
304 language_server_id: LanguageServerId,
305 message: proto::update_language_server::Variant,
306 name: Option<LanguageServerName>,
307 },
308 Resync,
309}
310
311#[derive(Debug)]
312enum ProjectClientState {
313 /// Single-player mode.
314 Local,
315 /// Multi-player mode but still a local project.
316 Shared { remote_id: u64 },
317 /// Multi-player mode but working on a remote project.
318 Collab {
319 sharing_has_stopped: bool,
320 capability: Capability,
321 remote_id: u64,
322 replica_id: ReplicaId,
323 },
324}
325
326/// A link to display in a toast notification, useful to point to documentation.
327#[derive(PartialEq, Debug, Clone)]
328pub struct ToastLink {
329 pub label: &'static str,
330 pub url: &'static str,
331}
332
333#[derive(Clone, Debug, PartialEq)]
334pub enum Event {
335 LanguageServerAdded(LanguageServerId, LanguageServerName, Option<WorktreeId>),
336 LanguageServerRemoved(LanguageServerId),
337 LanguageServerLog(LanguageServerId, LanguageServerLogType, String),
338 // [`lsp::notification::DidOpenTextDocument`] was sent to this server using the buffer data.
339 // Zed's buffer-related data is updated accordingly.
340 LanguageServerBufferRegistered {
341 server_id: LanguageServerId,
342 buffer_id: BufferId,
343 buffer_abs_path: PathBuf,
344 name: Option<LanguageServerName>,
345 },
346 ToggleLspLogs {
347 server_id: LanguageServerId,
348 enabled: bool,
349 toggled_log_kind: LogKind,
350 },
351 Toast {
352 notification_id: SharedString,
353 message: String,
354 /// Optional link to display as a button in the toast.
355 link: Option<ToastLink>,
356 },
357 HideToast {
358 notification_id: SharedString,
359 },
360 LanguageServerPrompt(LanguageServerPromptRequest),
361 LanguageNotFound(Entity<Buffer>),
362 ActiveEntryChanged(Option<ProjectEntryId>),
363 ActivateProjectPanel,
364 WorktreeAdded(WorktreeId),
365 WorktreeOrderChanged,
366 WorktreeRemoved(WorktreeId),
367 WorktreeUpdatedEntries(WorktreeId, UpdatedEntriesSet),
368 WorktreeUpdatedRootRepoCommonDir(WorktreeId),
369 WorktreePathsChanged {
370 old_worktree_paths: WorktreePaths,
371 },
372 DiskBasedDiagnosticsStarted {
373 language_server_id: LanguageServerId,
374 },
375 DiskBasedDiagnosticsFinished {
376 language_server_id: LanguageServerId,
377 },
378 DiagnosticsUpdated {
379 paths: Vec<ProjectPath>,
380 language_server_id: LanguageServerId,
381 },
382 RemoteIdChanged(Option<u64>),
383 DisconnectedFromHost,
384 DisconnectedFromRemote {
385 server_not_running: bool,
386 },
387 Closed,
388 DeletedEntry(WorktreeId, ProjectEntryId),
389 CollaboratorUpdated {
390 old_peer_id: proto::PeerId,
391 new_peer_id: proto::PeerId,
392 },
393 CollaboratorJoined(proto::PeerId),
394 CollaboratorLeft(proto::PeerId),
395 HostReshared,
396 Reshared,
397 Rejoined,
398 RefreshInlayHints {
399 server_id: LanguageServerId,
400 request_id: Option<usize>,
401 },
402 RefreshSemanticTokens {
403 server_id: LanguageServerId,
404 request_id: Option<usize>,
405 },
406 RefreshCodeLens,
407 RevealInProjectPanel(ProjectEntryId),
408 SnippetEdit(BufferId, Vec<(lsp::Range, Snippet)>),
409 ExpandedAllForEntry(WorktreeId, ProjectEntryId),
410 EntryRenamed(ProjectTransaction, ProjectPath, PathBuf),
411 WorkspaceEditApplied(ProjectTransaction),
412 AgentLocationChanged,
413 BufferEdited,
414}
415
416pub struct AgentLocationChanged;
417
418pub enum DebugAdapterClientState {
419 Starting(Task<Option<Arc<DebugAdapterClient>>>),
420 Running(Arc<DebugAdapterClient>),
421}
422
423#[derive(Clone, Debug, Eq, PartialEq, Hash, PartialOrd, Ord)]
424pub struct ProjectPath {
425 pub worktree_id: WorktreeId,
426 pub path: Arc<RelPath>,
427}
428
429impl ProjectPath {
430 pub fn from_file(value: &dyn language::File, cx: &App) -> Self {
431 ProjectPath {
432 worktree_id: value.worktree_id(cx),
433 path: value.path().clone(),
434 }
435 }
436
437 pub fn from_proto(p: proto::ProjectPath) -> Option<Self> {
438 Some(Self {
439 worktree_id: WorktreeId::from_proto(p.worktree_id),
440 path: RelPath::from_proto(&p.path).log_err()?,
441 })
442 }
443
444 pub fn to_proto(&self) -> proto::ProjectPath {
445 proto::ProjectPath {
446 worktree_id: self.worktree_id.to_proto(),
447 path: self.path.as_ref().to_proto(),
448 }
449 }
450
451 pub fn root_path(worktree_id: WorktreeId) -> Self {
452 Self {
453 worktree_id,
454 path: RelPath::empty().into(),
455 }
456 }
457
458 pub fn starts_with(&self, other: &ProjectPath) -> bool {
459 self.worktree_id == other.worktree_id && self.path.starts_with(&other.path)
460 }
461}
462
463#[derive(Debug, Default)]
464pub enum PrepareRenameResponse {
465 Success(Range<Anchor>),
466 OnlyUnpreparedRenameSupported,
467 #[default]
468 InvalidPosition,
469}
470
471#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
472pub enum InlayId {
473 EditPrediction(usize),
474 DebuggerValue(usize),
475 // LSP
476 Hint(usize),
477 Color(usize),
478 ReplResult(usize),
479}
480
481impl InlayId {
482 pub fn id(&self) -> usize {
483 match self {
484 Self::EditPrediction(id) => *id,
485 Self::DebuggerValue(id) => *id,
486 Self::Hint(id) => *id,
487 Self::Color(id) => *id,
488 Self::ReplResult(id) => *id,
489 }
490 }
491}
492
493#[derive(Debug, Clone, PartialEq, Eq)]
494pub struct InlayHint {
495 pub position: language::Anchor,
496 pub label: InlayHintLabel,
497 pub kind: Option<InlayHintKind>,
498 pub padding_left: bool,
499 pub padding_right: bool,
500 pub tooltip: Option<InlayHintTooltip>,
501 pub resolve_state: ResolveState,
502}
503
504/// The user's intent behind a given completion confirmation.
505#[derive(PartialEq, Eq, Hash, Debug, Clone, Copy)]
506pub enum CompletionIntent {
507 /// The user intends to 'commit' this result, if possible.
508 /// Completion confirmations should run side effects.
509 ///
510 /// For LSP completions, will respect the setting `completions.lsp_insert_mode`.
511 Complete,
512 /// Similar to [Self::Complete], but behaves like `lsp_insert_mode` is set to `insert`.
513 CompleteWithInsert,
514 /// Similar to [Self::Complete], but behaves like `lsp_insert_mode` is set to `replace`.
515 CompleteWithReplace,
516 /// The user intends to continue 'composing' this completion.
517 /// Completion confirmations should not run side effects and
518 /// let the user continue composing their action.
519 Compose,
520}
521
522impl CompletionIntent {
523 pub fn is_complete(&self) -> bool {
524 self == &Self::Complete
525 }
526
527 pub fn is_compose(&self) -> bool {
528 self == &Self::Compose
529 }
530}
531
532/// Similar to `CoreCompletion`, but with extra metadata attached.
533#[derive(Clone)]
534pub struct Completion {
535 /// The range of text that will be replaced by this completion.
536 pub replace_range: Range<Anchor>,
537 /// The new text that will be inserted.
538 pub new_text: String,
539 /// A label for this completion that is shown in the menu.
540 pub label: CodeLabel,
541 /// The documentation for this completion.
542 pub documentation: Option<CompletionDocumentation>,
543 /// Completion data source which it was constructed from.
544 pub source: CompletionSource,
545 /// A path to an icon for this completion that is shown in the menu.
546 pub icon_path: Option<SharedString>,
547 /// Text starting here and ending at the cursor will be used as the query for filtering this completion.
548 ///
549 /// If None, the start of the surrounding word is used.
550 pub match_start: Option<text::Anchor>,
551 /// Key used for de-duplicating snippets. If None, always considered unique.
552 pub snippet_deduplication_key: Option<(usize, usize)>,
553 /// Whether to adjust indentation (the default) or not.
554 pub insert_text_mode: Option<InsertTextMode>,
555 /// An optional callback to invoke when this completion is confirmed.
556 /// Returns whether new completions should be retriggered after the current one.
557 /// If `true` is returned, the editor will show a new completion menu after this completion is confirmed.
558 /// if no confirmation is provided or `false` is returned, the completion will be committed.
559 pub confirm: Option<Arc<dyn Send + Sync + Fn(CompletionIntent, &mut Window, &mut App) -> bool>>,
560}
561
562#[derive(Debug, Clone)]
563pub enum CompletionSource {
564 Lsp {
565 /// The alternate `insert` range, if provided by the LSP server.
566 insert_range: Option<Range<Anchor>>,
567 /// The id of the language server that produced this completion.
568 server_id: LanguageServerId,
569 /// The raw completion provided by the language server.
570 lsp_completion: Box<lsp::CompletionItem>,
571 /// A set of defaults for this completion item.
572 lsp_defaults: Option<Arc<lsp::CompletionListItemDefaults>>,
573 /// Whether this completion has been resolved, to ensure it happens once per completion.
574 resolved: bool,
575 },
576 Dap {
577 /// The sort text for this completion.
578 sort_text: String,
579 },
580 Custom,
581 BufferWord {
582 word_range: Range<Anchor>,
583 resolved: bool,
584 },
585}
586
587impl CompletionSource {
588 pub fn server_id(&self) -> Option<LanguageServerId> {
589 if let CompletionSource::Lsp { server_id, .. } = self {
590 Some(*server_id)
591 } else {
592 None
593 }
594 }
595
596 pub fn lsp_completion(&self, apply_defaults: bool) -> Option<Cow<'_, lsp::CompletionItem>> {
597 if let Self::Lsp {
598 lsp_completion,
599 lsp_defaults,
600 ..
601 } = self
602 {
603 if apply_defaults && let Some(lsp_defaults) = lsp_defaults {
604 let mut completion_with_defaults = *lsp_completion.clone();
605 let default_commit_characters = lsp_defaults.commit_characters.as_ref();
606 let default_edit_range = lsp_defaults.edit_range.as_ref();
607 let default_insert_text_format = lsp_defaults.insert_text_format.as_ref();
608 let default_insert_text_mode = lsp_defaults.insert_text_mode.as_ref();
609
610 if default_commit_characters.is_some()
611 || default_edit_range.is_some()
612 || default_insert_text_format.is_some()
613 || default_insert_text_mode.is_some()
614 {
615 if completion_with_defaults.commit_characters.is_none()
616 && default_commit_characters.is_some()
617 {
618 completion_with_defaults.commit_characters =
619 default_commit_characters.cloned()
620 }
621 if completion_with_defaults.text_edit.is_none() {
622 match default_edit_range {
623 Some(lsp::CompletionListItemDefaultsEditRange::Range(range)) => {
624 completion_with_defaults.text_edit =
625 Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit {
626 range: *range,
627 new_text: completion_with_defaults.label.clone(),
628 }))
629 }
630 Some(lsp::CompletionListItemDefaultsEditRange::InsertAndReplace {
631 insert,
632 replace,
633 }) => {
634 completion_with_defaults.text_edit =
635 Some(lsp::CompletionTextEdit::InsertAndReplace(
636 lsp::InsertReplaceEdit {
637 new_text: completion_with_defaults.label.clone(),
638 insert: *insert,
639 replace: *replace,
640 },
641 ))
642 }
643 None => {}
644 }
645 }
646 if completion_with_defaults.insert_text_format.is_none()
647 && default_insert_text_format.is_some()
648 {
649 completion_with_defaults.insert_text_format =
650 default_insert_text_format.cloned()
651 }
652 if completion_with_defaults.insert_text_mode.is_none()
653 && default_insert_text_mode.is_some()
654 {
655 completion_with_defaults.insert_text_mode =
656 default_insert_text_mode.cloned()
657 }
658 }
659 return Some(Cow::Owned(completion_with_defaults));
660 }
661 Some(Cow::Borrowed(lsp_completion))
662 } else {
663 None
664 }
665 }
666}
667
668impl std::fmt::Debug for Completion {
669 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
670 f.debug_struct("Completion")
671 .field("replace_range", &self.replace_range)
672 .field("new_text", &self.new_text)
673 .field("label", &self.label)
674 .field("documentation", &self.documentation)
675 .field("source", &self.source)
676 .finish()
677 }
678}
679
680/// Response from a source of completions.
681pub struct CompletionResponse {
682 pub completions: Vec<Completion>,
683 pub display_options: CompletionDisplayOptions,
684 /// When false, indicates that the list is complete and does not need to be re-queried if it
685 /// can be filtered instead.
686 pub is_incomplete: bool,
687}
688
689#[derive(Default)]
690pub struct CompletionDisplayOptions {
691 pub dynamic_width: bool,
692}
693
694impl CompletionDisplayOptions {
695 pub fn merge(&mut self, other: &CompletionDisplayOptions) {
696 self.dynamic_width = self.dynamic_width && other.dynamic_width;
697 }
698}
699
700/// Response from language server completion request.
701#[derive(Clone, Debug, Default)]
702pub(crate) struct CoreCompletionResponse {
703 pub completions: Vec<CoreCompletion>,
704 /// When false, indicates that the list is complete and does not need to be re-queried if it
705 /// can be filtered instead.
706 pub is_incomplete: bool,
707}
708
709/// A generic completion that can come from different sources.
710#[derive(Clone, Debug)]
711pub(crate) struct CoreCompletion {
712 replace_range: Range<Anchor>,
713 new_text: String,
714 source: CompletionSource,
715}
716
717/// A code action provided by a language server.
718#[derive(Clone, Debug, PartialEq)]
719pub struct CodeAction {
720 /// The id of the language server that produced this code action.
721 pub server_id: LanguageServerId,
722 /// The range of the buffer where this code action is applicable.
723 pub range: Range<Anchor>,
724 /// The raw code action provided by the language server.
725 /// Can be either an action or a command.
726 pub lsp_action: LspAction,
727 /// Whether the action needs to be resolved using the language server.
728 pub resolved: bool,
729}
730
731/// An action sent back by a language server.
732#[derive(Clone, Debug, PartialEq)]
733pub enum LspAction {
734 /// An action with the full data, may have a command or may not.
735 /// May require resolving.
736 Action(Box<lsp::CodeAction>),
737 /// A command data to run as an action.
738 Command(lsp::Command),
739 /// A code lens data to run as an action.
740 CodeLens(lsp::CodeLens),
741}
742
743impl LspAction {
744 pub fn title(&self) -> &str {
745 match self {
746 Self::Action(action) => &action.title,
747 Self::Command(command) => &command.title,
748 Self::CodeLens(lens) => lens
749 .command
750 .as_ref()
751 .map(|command| command.title.as_str())
752 .unwrap_or("Unknown command"),
753 }
754 }
755
756 pub fn action_kind(&self) -> Option<lsp::CodeActionKind> {
757 match self {
758 Self::Action(action) => action.kind.clone(),
759 Self::Command(_) => Some(lsp::CodeActionKind::new("command")),
760 Self::CodeLens(_) => Some(lsp::CodeActionKind::new("code lens")),
761 }
762 }
763
764 pub fn edit(&self) -> Option<&lsp::WorkspaceEdit> {
765 match self {
766 Self::Action(action) => action.edit.as_ref(),
767 Self::Command(_) => None,
768 Self::CodeLens(_) => None,
769 }
770 }
771
772 pub fn command(&self) -> Option<&lsp::Command> {
773 match self {
774 Self::Action(action) => action.command.as_ref(),
775 Self::Command(command) => Some(command),
776 Self::CodeLens(lens) => lens.command.as_ref(),
777 }
778 }
779}
780
781#[derive(Debug, Clone, PartialEq, Eq)]
782pub enum ResolveState {
783 Resolved,
784 CanResolve(LanguageServerId, Option<lsp::LSPAny>),
785 Resolving,
786}
787impl InlayHint {
788 pub fn text(&self) -> Rope {
789 match &self.label {
790 InlayHintLabel::String(s) => Rope::from(s),
791 InlayHintLabel::LabelParts(parts) => parts.iter().map(|part| &*part.value).collect(),
792 }
793 }
794}
795
796#[derive(Debug, Clone, PartialEq, Eq)]
797pub enum InlayHintLabel {
798 String(String),
799 LabelParts(Vec<InlayHintLabelPart>),
800}
801
802#[derive(Debug, Clone, PartialEq, Eq)]
803pub struct InlayHintLabelPart {
804 pub value: String,
805 pub tooltip: Option<InlayHintLabelPartTooltip>,
806 pub location: Option<(LanguageServerId, lsp::Location)>,
807}
808
809#[derive(Debug, Clone, PartialEq, Eq)]
810pub enum InlayHintTooltip {
811 String(String),
812 MarkupContent(MarkupContent),
813}
814
815#[derive(Debug, Clone, PartialEq, Eq)]
816pub enum InlayHintLabelPartTooltip {
817 String(String),
818 MarkupContent(MarkupContent),
819}
820
821#[derive(Debug, Clone, PartialEq, Eq)]
822pub struct MarkupContent {
823 pub kind: HoverBlockKind,
824 pub value: String,
825}
826
827#[derive(Debug, Clone, PartialEq)]
828pub struct LocationLink {
829 pub origin: Option<Location>,
830 pub target: Location,
831}
832
833#[derive(Debug)]
834pub struct DocumentHighlight {
835 pub range: Range<language::Anchor>,
836 pub kind: DocumentHighlightKind,
837}
838
839#[derive(Clone, Debug)]
840pub struct Symbol {
841 pub language_server_name: LanguageServerName,
842 pub source_worktree_id: WorktreeId,
843 pub source_language_server_id: LanguageServerId,
844 pub path: SymbolLocation,
845 pub label: CodeLabel,
846 pub name: String,
847 pub kind: lsp::SymbolKind,
848 pub range: Range<Unclipped<PointUtf16>>,
849 pub container_name: Option<String>,
850}
851
852#[derive(Clone, Debug)]
853pub struct DocumentSymbol {
854 pub name: String,
855 pub kind: lsp::SymbolKind,
856 pub range: Range<Unclipped<PointUtf16>>,
857 pub selection_range: Range<Unclipped<PointUtf16>>,
858 pub children: Vec<DocumentSymbol>,
859}
860
861#[derive(Clone, Debug, PartialEq)]
862pub struct HoverBlock {
863 pub text: String,
864 pub kind: HoverBlockKind,
865}
866
867#[derive(Clone, Debug, PartialEq, Eq)]
868pub enum HoverBlockKind {
869 PlainText,
870 Markdown,
871 Code { language: String },
872}
873
874#[derive(Debug, Clone)]
875pub struct Hover {
876 pub contents: Vec<HoverBlock>,
877 pub range: Option<Range<language::Anchor>>,
878 pub language: Option<Arc<Language>>,
879}
880
881impl Hover {
882 pub fn is_empty(&self) -> bool {
883 self.contents.iter().all(|block| block.text.is_empty())
884 }
885}
886
887enum EntitySubscription {
888 Project(PendingEntitySubscription<Project>),
889 BufferStore(PendingEntitySubscription<BufferStore>),
890 GitStore(PendingEntitySubscription<GitStore>),
891 WorktreeStore(PendingEntitySubscription<WorktreeStore>),
892 LspStore(PendingEntitySubscription<LspStore>),
893 SettingsObserver(PendingEntitySubscription<SettingsObserver>),
894 DapStore(PendingEntitySubscription<DapStore>),
895 BreakpointStore(PendingEntitySubscription<BreakpointStore>),
896}
897
898#[derive(Debug, Clone)]
899pub struct DirectoryItem {
900 pub path: PathBuf,
901 pub is_dir: bool,
902}
903
904#[derive(Clone, Debug, PartialEq)]
905pub struct DocumentColor {
906 pub lsp_range: lsp::Range,
907 pub color: lsp::Color,
908 pub resolved: bool,
909 pub color_presentations: Vec<ColorPresentation>,
910}
911
912impl Eq for DocumentColor {}
913
914impl std::hash::Hash for DocumentColor {
915 fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
916 self.lsp_range.hash(state);
917 self.color.red.to_bits().hash(state);
918 self.color.green.to_bits().hash(state);
919 self.color.blue.to_bits().hash(state);
920 self.color.alpha.to_bits().hash(state);
921 self.resolved.hash(state);
922 self.color_presentations.hash(state);
923 }
924}
925
926#[derive(Clone, Debug, PartialEq, Eq)]
927pub struct ColorPresentation {
928 pub label: SharedString,
929 pub text_edit: Option<lsp::TextEdit>,
930 pub additional_text_edits: Vec<lsp::TextEdit>,
931}
932
933impl std::hash::Hash for ColorPresentation {
934 fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
935 self.label.hash(state);
936 if let Some(ref edit) = self.text_edit {
937 edit.range.hash(state);
938 edit.new_text.hash(state);
939 }
940 self.additional_text_edits.len().hash(state);
941 for edit in &self.additional_text_edits {
942 edit.range.hash(state);
943 edit.new_text.hash(state);
944 }
945 }
946}
947
948#[derive(Clone)]
949pub enum DirectoryLister {
950 Project(Entity<Project>),
951 Local(Entity<Project>, Arc<dyn Fs>),
952}
953
954impl std::fmt::Debug for DirectoryLister {
955 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
956 match self {
957 DirectoryLister::Project(project) => {
958 write!(f, "DirectoryLister::Project({project:?})")
959 }
960 DirectoryLister::Local(project, _) => {
961 write!(f, "DirectoryLister::Local({project:?})")
962 }
963 }
964 }
965}
966
967impl DirectoryLister {
968 pub fn is_local(&self, cx: &App) -> bool {
969 match self {
970 DirectoryLister::Local(..) => true,
971 DirectoryLister::Project(project) => project.read(cx).is_local(),
972 }
973 }
974
975 pub fn resolve_tilde<'a>(&self, path: &'a String, cx: &App) -> Cow<'a, str> {
976 if self.is_local(cx) {
977 shellexpand::tilde(path)
978 } else {
979 Cow::from(path)
980 }
981 }
982
983 pub fn default_query(&self, cx: &mut App) -> String {
984 let project = match self {
985 DirectoryLister::Project(project) => project,
986 DirectoryLister::Local(project, _) => project,
987 }
988 .read(cx);
989 let path_style = project.path_style(cx);
990 project
991 .visible_worktrees(cx)
992 .next()
993 .map(|worktree| worktree.read(cx).abs_path().to_string_lossy().into_owned())
994 .or_else(|| std::env::home_dir().map(|dir| dir.to_string_lossy().into_owned()))
995 .map(|mut s| {
996 s.push_str(path_style.primary_separator());
997 s
998 })
999 .unwrap_or_else(|| {
1000 if path_style.is_windows() {
1001 "C:\\"
1002 } else {
1003 "~/"
1004 }
1005 .to_string()
1006 })
1007 }
1008
1009 pub fn list_directory(&self, path: String, cx: &mut App) -> Task<Result<Vec<DirectoryItem>>> {
1010 match self {
1011 DirectoryLister::Project(project) => {
1012 project.update(cx, |project, cx| project.list_directory(path, cx))
1013 }
1014 DirectoryLister::Local(_, fs) => {
1015 let fs = fs.clone();
1016 cx.background_spawn(async move {
1017 let mut results = vec![];
1018 let expanded = shellexpand::tilde(&path);
1019 let query = Path::new(expanded.as_ref());
1020 let mut response = fs.read_dir(query).await?;
1021 while let Some(path) = response.next().await {
1022 let path = path?;
1023 if let Some(file_name) = path.file_name() {
1024 results.push(DirectoryItem {
1025 path: PathBuf::from(file_name.to_os_string()),
1026 is_dir: fs.is_dir(&path).await,
1027 });
1028 }
1029 }
1030 Ok(results)
1031 })
1032 }
1033 }
1034 }
1035
1036 pub fn path_style(&self, cx: &App) -> PathStyle {
1037 match self {
1038 Self::Local(project, ..) | Self::Project(project, ..) => {
1039 project.read(cx).path_style(cx)
1040 }
1041 }
1042 }
1043}
1044
1045pub const CURRENT_PROJECT_FEATURES: &[&str] = &["new-style-anchors"];
1046
1047#[cfg(feature = "test-support")]
1048pub const DEFAULT_COMPLETION_CONTEXT: CompletionContext = CompletionContext {
1049 trigger_kind: lsp::CompletionTriggerKind::INVOKED,
1050 trigger_character: None,
1051};
1052
1053/// An LSP diagnostics associated with a certain language server.
1054#[derive(Clone, Debug, Default)]
1055pub enum LspPullDiagnostics {
1056 #[default]
1057 Default,
1058 Response {
1059 /// The id of the language server that produced diagnostics.
1060 server_id: LanguageServerId,
1061 /// URI of the resource,
1062 uri: lsp::Uri,
1063 /// The ID provided by the dynamic registration that produced diagnostics.
1064 registration_id: Option<SharedString>,
1065 /// The diagnostics produced by this language server.
1066 diagnostics: PulledDiagnostics,
1067 },
1068}
1069
1070#[derive(Clone, Debug)]
1071pub enum PulledDiagnostics {
1072 Unchanged {
1073 /// An ID the current pulled batch for this file.
1074 /// If given, can be used to query workspace diagnostics partially.
1075 result_id: SharedString,
1076 },
1077 Changed {
1078 result_id: Option<SharedString>,
1079 diagnostics: Vec<lsp::Diagnostic>,
1080 },
1081}
1082
1083/// Whether to disable all AI features in Zed.
1084///
1085/// Default: false
1086#[derive(Copy, Clone, Debug, RegisterSetting)]
1087pub struct DisableAiSettings {
1088 pub disable_ai: bool,
1089}
1090
1091impl settings::Settings for DisableAiSettings {
1092 fn from_settings(content: &settings::SettingsContent) -> Self {
1093 Self {
1094 disable_ai: content.project.disable_ai.unwrap().0,
1095 }
1096 }
1097}
1098
1099impl DisableAiSettings {
1100 /// Returns whether AI is disabled for the given file.
1101 ///
1102 /// This checks the project-level settings for the file's worktree,
1103 /// allowing `disable_ai` to be configured per-project in `.zed/settings.json`.
1104 pub fn is_ai_disabled_for_buffer(buffer: Option<&Entity<Buffer>>, cx: &App) -> bool {
1105 Self::is_ai_disabled_for_file(buffer.and_then(|buffer| buffer.read(cx).file()), cx)
1106 }
1107
1108 pub fn is_ai_disabled_for_file(file: Option<&Arc<dyn language::File>>, cx: &App) -> bool {
1109 let location = file.map(|f| settings::SettingsLocation {
1110 worktree_id: f.worktree_id(cx),
1111 path: f.path().as_ref(),
1112 });
1113 Self::get(location, cx).disable_ai
1114 }
1115}
1116
1117impl Project {
1118 pub fn init(client: &Arc<Client>, cx: &mut App) {
1119 connection_manager::init(client.clone(), cx);
1120
1121 let client: AnyProtoClient = client.clone().into();
1122 client.add_entity_message_handler(Self::handle_add_collaborator);
1123 client.add_entity_message_handler(Self::handle_update_project_collaborator);
1124 client.add_entity_message_handler(Self::handle_remove_collaborator);
1125 client.add_entity_message_handler(Self::handle_update_project);
1126 client.add_entity_message_handler(Self::handle_unshare_project);
1127 client.add_entity_request_handler(Self::handle_update_buffer);
1128 client.add_entity_message_handler(Self::handle_update_worktree);
1129 client.add_entity_request_handler(Self::handle_synchronize_buffers);
1130
1131 client.add_entity_request_handler(Self::handle_search_candidate_buffers);
1132 client.add_entity_request_handler(Self::handle_open_buffer_by_id);
1133 client.add_entity_request_handler(Self::handle_open_buffer_by_path);
1134 client.add_entity_request_handler(Self::handle_open_new_buffer);
1135 client.add_entity_message_handler(Self::handle_create_buffer_for_peer);
1136 client.add_entity_message_handler(Self::handle_toggle_lsp_logs);
1137 client.add_entity_message_handler(Self::handle_create_image_for_peer);
1138 client.add_entity_request_handler(Self::handle_find_search_candidates_chunk);
1139 client.add_entity_message_handler(Self::handle_find_search_candidates_cancel);
1140 client.add_entity_message_handler(Self::handle_create_file_for_peer);
1141
1142 WorktreeStore::init(&client);
1143 BufferStore::init(&client);
1144 LspStore::init(&client);
1145 GitStore::init(&client);
1146 SettingsObserver::init(&client);
1147 TaskStore::init(Some(&client));
1148 ToolchainStore::init(&client);
1149 DapStore::init(&client, cx);
1150 BreakpointStore::init(&client);
1151 context_server_store::init(cx);
1152 }
1153
1154 pub fn local(
1155 client: Arc<Client>,
1156 node: NodeRuntime,
1157 user_store: Entity<UserStore>,
1158 languages: Arc<LanguageRegistry>,
1159 fs: Arc<dyn Fs>,
1160 env: Option<HashMap<String, String>>,
1161 flags: LocalProjectFlags,
1162 cx: &mut App,
1163 ) -> Entity<Self> {
1164 cx.new(|cx: &mut Context<Self>| {
1165 let (tx, rx) = mpsc::unbounded();
1166 cx.spawn(async move |this, cx| Self::send_buffer_ordered_messages(this, rx, cx).await)
1167 .detach();
1168 let snippets = SnippetProvider::new(fs.clone(), BTreeSet::from_iter([]), cx);
1169 let worktree_store =
1170 cx.new(|cx| WorktreeStore::local(false, fs.clone(), WorktreeIdCounter::get(cx)));
1171 if flags.init_worktree_trust {
1172 trusted_worktrees::track_worktree_trust(
1173 worktree_store.clone(),
1174 None,
1175 None,
1176 None,
1177 cx,
1178 );
1179 }
1180 cx.subscribe(&worktree_store, Self::on_worktree_store_event)
1181 .detach();
1182
1183 let weak_self = cx.weak_entity();
1184 let context_server_store = cx.new(|cx| {
1185 ContextServerStore::local(
1186 worktree_store.clone(),
1187 Some(weak_self.clone()),
1188 false,
1189 cx,
1190 )
1191 });
1192
1193 let environment = cx.new(|cx| {
1194 ProjectEnvironment::new(env, worktree_store.downgrade(), None, false, cx)
1195 });
1196 let manifest_tree = ManifestTree::new(worktree_store.clone(), cx);
1197 let toolchain_store = cx.new(|cx| {
1198 ToolchainStore::local(
1199 languages.clone(),
1200 worktree_store.clone(),
1201 environment.clone(),
1202 manifest_tree.clone(),
1203 cx,
1204 )
1205 });
1206
1207 let buffer_store = cx.new(|cx| BufferStore::local(worktree_store.clone(), cx));
1208 cx.subscribe(&buffer_store, Self::on_buffer_store_event)
1209 .detach();
1210
1211 let bookmark_store =
1212 cx.new(|_| BookmarkStore::new(worktree_store.clone(), buffer_store.clone()));
1213
1214 let breakpoint_store =
1215 cx.new(|_| BreakpointStore::local(worktree_store.clone(), buffer_store.clone()));
1216
1217 let dap_store = cx.new(|cx| {
1218 DapStore::new_local(
1219 client.http_client(),
1220 node.clone(),
1221 fs.clone(),
1222 environment.clone(),
1223 toolchain_store.read(cx).as_language_toolchain_store(),
1224 worktree_store.clone(),
1225 breakpoint_store.clone(),
1226 false,
1227 cx,
1228 )
1229 });
1230 cx.subscribe(&dap_store, Self::on_dap_store_event).detach();
1231
1232 let image_store = cx.new(|cx| ImageStore::local(worktree_store.clone(), cx));
1233 cx.subscribe(&image_store, Self::on_image_store_event)
1234 .detach();
1235
1236 let prettier_store = cx.new(|cx| {
1237 PrettierStore::new(
1238 node.clone(),
1239 fs.clone(),
1240 languages.clone(),
1241 worktree_store.clone(),
1242 cx,
1243 )
1244 });
1245
1246 let git_store = cx.new(|cx| {
1247 GitStore::local(
1248 &worktree_store,
1249 buffer_store.clone(),
1250 environment.clone(),
1251 fs.clone(),
1252 cx,
1253 )
1254 });
1255
1256 let task_store = cx.new(|cx| {
1257 TaskStore::local(
1258 buffer_store.downgrade(),
1259 worktree_store.clone(),
1260 toolchain_store.read(cx).as_language_toolchain_store(),
1261 environment.clone(),
1262 git_store.clone(),
1263 cx,
1264 )
1265 });
1266
1267 let settings_observer = cx.new(|cx| {
1268 SettingsObserver::new_local(
1269 fs.clone(),
1270 worktree_store.clone(),
1271 task_store.clone(),
1272 flags.watch_global_configs,
1273 cx,
1274 )
1275 });
1276 cx.subscribe(&settings_observer, Self::on_settings_observer_event)
1277 .detach();
1278
1279 let lsp_store = cx.new(|cx| {
1280 LspStore::new_local(
1281 buffer_store.clone(),
1282 worktree_store.clone(),
1283 prettier_store.clone(),
1284 toolchain_store
1285 .read(cx)
1286 .as_local_store()
1287 .expect("Toolchain store to be local")
1288 .clone(),
1289 environment.clone(),
1290 manifest_tree,
1291 languages.clone(),
1292 client.http_client(),
1293 fs.clone(),
1294 cx,
1295 )
1296 });
1297
1298 let agent_server_store = cx.new(|cx| {
1299 AgentServerStore::local(
1300 node.clone(),
1301 fs.clone(),
1302 environment.clone(),
1303 client.http_client(),
1304 cx,
1305 )
1306 });
1307
1308 cx.subscribe(&lsp_store, Self::on_lsp_store_event).detach();
1309
1310 Self {
1311 buffer_ordered_messages_tx: tx,
1312 collaborators: Default::default(),
1313 worktree_store,
1314 buffer_store,
1315 image_store,
1316 lsp_store,
1317 context_server_store,
1318 join_project_response_message_id: 0,
1319 client_state: ProjectClientState::Local,
1320 git_store,
1321 client_subscriptions: Vec::new(),
1322 _subscriptions: vec![cx.on_release(Self::release)],
1323 active_entry: None,
1324 snippets,
1325 languages,
1326 collab_client: client,
1327 task_store,
1328 user_store,
1329 settings_observer,
1330 fs,
1331 remote_client: None,
1332 bookmark_store,
1333 breakpoint_store,
1334 dap_store,
1335 agent_server_store,
1336
1337 buffers_needing_diff: Default::default(),
1338 git_diff_debouncer: DebouncedDelay::new(),
1339 terminals: Terminals {
1340 local_handles: Vec::new(),
1341 },
1342 node: Some(node),
1343 search_history: Self::new_search_history(),
1344 environment,
1345 remotely_created_models: Default::default(),
1346
1347 search_included_history: Self::new_search_history(),
1348 search_excluded_history: Self::new_search_history(),
1349
1350 toolchain_store: Some(toolchain_store),
1351
1352 agent_location: None,
1353 downloading_files: Default::default(),
1354 last_worktree_paths: WorktreePaths::default(),
1355 }
1356 })
1357 }
1358
1359 pub fn remote(
1360 remote: Entity<RemoteClient>,
1361 client: Arc<Client>,
1362 node: NodeRuntime,
1363 user_store: Entity<UserStore>,
1364 languages: Arc<LanguageRegistry>,
1365 fs: Arc<dyn Fs>,
1366 init_worktree_trust: bool,
1367 cx: &mut App,
1368 ) -> Entity<Self> {
1369 cx.new(|cx: &mut Context<Self>| {
1370 let (tx, rx) = mpsc::unbounded();
1371 cx.spawn(async move |this, cx| Self::send_buffer_ordered_messages(this, rx, cx).await)
1372 .detach();
1373 let snippets = SnippetProvider::new(fs.clone(), BTreeSet::from_iter([]), cx);
1374
1375 let (remote_proto, path_style, connection_options) =
1376 remote.read_with(cx, |remote, _| {
1377 (
1378 remote.proto_client(),
1379 remote.path_style(),
1380 remote.connection_options(),
1381 )
1382 });
1383 let worktree_store = cx.new(|cx| {
1384 WorktreeStore::remote(
1385 false,
1386 remote_proto.clone(),
1387 REMOTE_SERVER_PROJECT_ID,
1388 path_style,
1389 WorktreeIdCounter::get(cx),
1390 )
1391 });
1392
1393 cx.subscribe(&worktree_store, Self::on_worktree_store_event)
1394 .detach();
1395 if init_worktree_trust {
1396 trusted_worktrees::track_worktree_trust(
1397 worktree_store.clone(),
1398 Some(RemoteHostLocation::from(connection_options)),
1399 None,
1400 Some((remote_proto.clone(), ProjectId(REMOTE_SERVER_PROJECT_ID))),
1401 cx,
1402 );
1403 }
1404
1405 let weak_self = cx.weak_entity();
1406
1407 let buffer_store = cx.new(|cx| {
1408 BufferStore::remote(
1409 worktree_store.clone(),
1410 remote.read(cx).proto_client(),
1411 REMOTE_SERVER_PROJECT_ID,
1412 cx,
1413 )
1414 });
1415 let image_store = cx.new(|cx| {
1416 ImageStore::remote(
1417 worktree_store.clone(),
1418 remote.read(cx).proto_client(),
1419 REMOTE_SERVER_PROJECT_ID,
1420 cx,
1421 )
1422 });
1423 cx.subscribe(&buffer_store, Self::on_buffer_store_event)
1424 .detach();
1425 let toolchain_store = cx.new(|cx| {
1426 ToolchainStore::remote(
1427 REMOTE_SERVER_PROJECT_ID,
1428 worktree_store.clone(),
1429 remote.read(cx).proto_client(),
1430 cx,
1431 )
1432 });
1433
1434 let context_server_store = cx.new(|cx| {
1435 ContextServerStore::remote(
1436 rpc::proto::REMOTE_SERVER_PROJECT_ID,
1437 remote.clone(),
1438 worktree_store.clone(),
1439 Some(weak_self.clone()),
1440 cx,
1441 )
1442 });
1443
1444 let environment = cx.new(|cx| {
1445 ProjectEnvironment::new(
1446 None,
1447 worktree_store.downgrade(),
1448 Some(remote.downgrade()),
1449 false,
1450 cx,
1451 )
1452 });
1453
1454 let lsp_store = cx.new(|cx| {
1455 LspStore::new_remote(
1456 buffer_store.clone(),
1457 worktree_store.clone(),
1458 languages.clone(),
1459 remote_proto.clone(),
1460 REMOTE_SERVER_PROJECT_ID,
1461 cx,
1462 )
1463 });
1464 cx.subscribe(&lsp_store, Self::on_lsp_store_event).detach();
1465
1466 let bookmark_store =
1467 cx.new(|_| BookmarkStore::new(worktree_store.clone(), buffer_store.clone()));
1468
1469 let breakpoint_store = cx.new(|_| {
1470 BreakpointStore::remote(
1471 REMOTE_SERVER_PROJECT_ID,
1472 remote_proto.clone(),
1473 buffer_store.clone(),
1474 worktree_store.clone(),
1475 )
1476 });
1477
1478 let dap_store = cx.new(|cx| {
1479 DapStore::new_remote(
1480 REMOTE_SERVER_PROJECT_ID,
1481 remote.clone(),
1482 breakpoint_store.clone(),
1483 worktree_store.clone(),
1484 node.clone(),
1485 client.http_client(),
1486 fs.clone(),
1487 cx,
1488 )
1489 });
1490
1491 let git_store = cx.new(|cx| {
1492 GitStore::remote(
1493 &worktree_store,
1494 buffer_store.clone(),
1495 remote_proto.clone(),
1496 REMOTE_SERVER_PROJECT_ID,
1497 cx,
1498 )
1499 });
1500
1501 let task_store = cx.new(|cx| {
1502 TaskStore::remote(
1503 buffer_store.downgrade(),
1504 worktree_store.clone(),
1505 toolchain_store.read(cx).as_language_toolchain_store(),
1506 remote.read(cx).proto_client(),
1507 REMOTE_SERVER_PROJECT_ID,
1508 git_store.clone(),
1509 cx,
1510 )
1511 });
1512
1513 let settings_observer = cx.new(|cx| {
1514 SettingsObserver::new_remote(
1515 fs.clone(),
1516 worktree_store.clone(),
1517 task_store.clone(),
1518 Some(remote_proto.clone()),
1519 false,
1520 cx,
1521 )
1522 });
1523 cx.subscribe(&settings_observer, Self::on_settings_observer_event)
1524 .detach();
1525
1526 let agent_server_store = cx.new(|_| {
1527 AgentServerStore::remote(
1528 REMOTE_SERVER_PROJECT_ID,
1529 remote.clone(),
1530 worktree_store.clone(),
1531 )
1532 });
1533
1534 cx.subscribe(&remote, Self::on_remote_client_event).detach();
1535
1536 let this = Self {
1537 buffer_ordered_messages_tx: tx,
1538 collaborators: Default::default(),
1539 worktree_store,
1540 buffer_store,
1541 image_store,
1542 lsp_store,
1543 context_server_store,
1544 bookmark_store,
1545 breakpoint_store,
1546 dap_store,
1547 join_project_response_message_id: 0,
1548 client_state: ProjectClientState::Local,
1549 git_store,
1550 agent_server_store,
1551 client_subscriptions: Vec::new(),
1552 _subscriptions: vec![
1553 cx.on_release(Self::release),
1554 cx.on_app_quit(|this, cx| {
1555 let shutdown = this.remote_client.take().and_then(|client| {
1556 client.update(cx, |client, cx| {
1557 client.shutdown_processes(
1558 Some(proto::ShutdownRemoteServer {}),
1559 cx.background_executor().clone(),
1560 )
1561 })
1562 });
1563
1564 cx.background_executor().spawn(async move {
1565 if let Some(shutdown) = shutdown {
1566 shutdown.await;
1567 }
1568 })
1569 }),
1570 ],
1571 active_entry: None,
1572 snippets,
1573 languages,
1574 collab_client: client,
1575 task_store,
1576 user_store,
1577 settings_observer,
1578 fs,
1579 remote_client: Some(remote.clone()),
1580 buffers_needing_diff: Default::default(),
1581 git_diff_debouncer: DebouncedDelay::new(),
1582 terminals: Terminals {
1583 local_handles: Vec::new(),
1584 },
1585 node: Some(node),
1586 search_history: Self::new_search_history(),
1587 environment,
1588 remotely_created_models: Default::default(),
1589
1590 search_included_history: Self::new_search_history(),
1591 search_excluded_history: Self::new_search_history(),
1592
1593 toolchain_store: Some(toolchain_store),
1594 agent_location: None,
1595 downloading_files: Default::default(),
1596 last_worktree_paths: WorktreePaths::default(),
1597 };
1598
1599 // remote server -> local machine handlers
1600 remote_proto.subscribe_to_entity(REMOTE_SERVER_PROJECT_ID, &cx.entity());
1601 remote_proto.subscribe_to_entity(REMOTE_SERVER_PROJECT_ID, &this.buffer_store);
1602 remote_proto.subscribe_to_entity(REMOTE_SERVER_PROJECT_ID, &this.worktree_store);
1603 remote_proto.subscribe_to_entity(REMOTE_SERVER_PROJECT_ID, &this.lsp_store);
1604 remote_proto.subscribe_to_entity(REMOTE_SERVER_PROJECT_ID, &this.dap_store);
1605 remote_proto.subscribe_to_entity(REMOTE_SERVER_PROJECT_ID, &this.breakpoint_store);
1606 remote_proto.subscribe_to_entity(REMOTE_SERVER_PROJECT_ID, &this.settings_observer);
1607 remote_proto.subscribe_to_entity(REMOTE_SERVER_PROJECT_ID, &this.git_store);
1608 remote_proto.subscribe_to_entity(REMOTE_SERVER_PROJECT_ID, &this.agent_server_store);
1609
1610 remote_proto.add_entity_message_handler(Self::handle_create_buffer_for_peer);
1611 remote_proto.add_entity_message_handler(Self::handle_create_image_for_peer);
1612 remote_proto.add_entity_message_handler(Self::handle_create_file_for_peer);
1613 remote_proto.add_entity_message_handler(Self::handle_update_worktree);
1614 remote_proto.add_entity_message_handler(Self::handle_update_project);
1615 remote_proto.add_entity_message_handler(Self::handle_toast);
1616 remote_proto.add_entity_request_handler(Self::handle_language_server_prompt_request);
1617 remote_proto.add_entity_message_handler(Self::handle_hide_toast);
1618 remote_proto.add_entity_request_handler(Self::handle_update_buffer_from_remote_server);
1619 remote_proto.add_entity_request_handler(Self::handle_trust_worktrees);
1620 remote_proto.add_entity_request_handler(Self::handle_restrict_worktrees);
1621 remote_proto.add_entity_request_handler(Self::handle_find_search_candidates_chunk);
1622
1623 remote_proto.add_entity_message_handler(Self::handle_find_search_candidates_cancel);
1624 BufferStore::init(&remote_proto);
1625 WorktreeStore::init_remote(&remote_proto);
1626 LspStore::init(&remote_proto);
1627 SettingsObserver::init(&remote_proto);
1628 TaskStore::init(Some(&remote_proto));
1629 ToolchainStore::init(&remote_proto);
1630 DapStore::init(&remote_proto, cx);
1631 BreakpointStore::init(&remote_proto);
1632 GitStore::init(&remote_proto);
1633 AgentServerStore::init_remote(&remote_proto);
1634
1635 this
1636 })
1637 }
1638
1639 pub async fn in_room(
1640 remote_id: u64,
1641 client: Arc<Client>,
1642 user_store: Entity<UserStore>,
1643 languages: Arc<LanguageRegistry>,
1644 fs: Arc<dyn Fs>,
1645 cx: AsyncApp,
1646 ) -> Result<Entity<Self>> {
1647 client.connect(true, &cx).await.into_response()?;
1648
1649 let subscriptions = [
1650 EntitySubscription::Project(client.subscribe_to_entity::<Self>(remote_id)?),
1651 EntitySubscription::BufferStore(client.subscribe_to_entity::<BufferStore>(remote_id)?),
1652 EntitySubscription::GitStore(client.subscribe_to_entity::<GitStore>(remote_id)?),
1653 EntitySubscription::WorktreeStore(
1654 client.subscribe_to_entity::<WorktreeStore>(remote_id)?,
1655 ),
1656 EntitySubscription::LspStore(client.subscribe_to_entity::<LspStore>(remote_id)?),
1657 EntitySubscription::SettingsObserver(
1658 client.subscribe_to_entity::<SettingsObserver>(remote_id)?,
1659 ),
1660 EntitySubscription::DapStore(client.subscribe_to_entity::<DapStore>(remote_id)?),
1661 EntitySubscription::BreakpointStore(
1662 client.subscribe_to_entity::<BreakpointStore>(remote_id)?,
1663 ),
1664 ];
1665 let committer = get_git_committer(&cx).await;
1666 let response = client
1667 .request_envelope(proto::JoinProject {
1668 project_id: remote_id,
1669 committer_email: committer.email,
1670 committer_name: committer.name,
1671 features: CURRENT_PROJECT_FEATURES
1672 .iter()
1673 .map(|s| s.to_string())
1674 .collect(),
1675 })
1676 .await?;
1677 Self::from_join_project_response(
1678 response,
1679 subscriptions,
1680 client,
1681 false,
1682 user_store,
1683 languages,
1684 fs,
1685 cx,
1686 )
1687 .await
1688 }
1689
1690 async fn from_join_project_response(
1691 response: TypedEnvelope<proto::JoinProjectResponse>,
1692 subscriptions: [EntitySubscription; 8],
1693 client: Arc<Client>,
1694 run_tasks: bool,
1695 user_store: Entity<UserStore>,
1696 languages: Arc<LanguageRegistry>,
1697 fs: Arc<dyn Fs>,
1698 mut cx: AsyncApp,
1699 ) -> Result<Entity<Self>> {
1700 let remote_id = response.payload.project_id;
1701 let role = response.payload.role();
1702
1703 let path_style = if response.payload.windows_paths {
1704 PathStyle::Windows
1705 } else {
1706 PathStyle::Posix
1707 };
1708
1709 let worktree_store = cx.new(|cx| {
1710 WorktreeStore::remote(
1711 true,
1712 client.clone().into(),
1713 response.payload.project_id,
1714 path_style,
1715 WorktreeIdCounter::get(cx),
1716 )
1717 });
1718 let buffer_store = cx.new(|cx| {
1719 BufferStore::remote(worktree_store.clone(), client.clone().into(), remote_id, cx)
1720 });
1721 let image_store = cx.new(|cx| {
1722 ImageStore::remote(worktree_store.clone(), client.clone().into(), remote_id, cx)
1723 });
1724
1725 let environment =
1726 cx.new(|cx| ProjectEnvironment::new(None, worktree_store.downgrade(), None, true, cx));
1727
1728 let bookmark_store =
1729 cx.new(|_| BookmarkStore::new(worktree_store.clone(), buffer_store.clone()));
1730
1731 let breakpoint_store = cx.new(|_| {
1732 BreakpointStore::remote(
1733 remote_id,
1734 client.clone().into(),
1735 buffer_store.clone(),
1736 worktree_store.clone(),
1737 )
1738 });
1739 let dap_store = cx.new(|cx| {
1740 DapStore::new_collab(
1741 remote_id,
1742 client.clone().into(),
1743 breakpoint_store.clone(),
1744 worktree_store.clone(),
1745 fs.clone(),
1746 cx,
1747 )
1748 });
1749
1750 let lsp_store = cx.new(|cx| {
1751 LspStore::new_remote(
1752 buffer_store.clone(),
1753 worktree_store.clone(),
1754 languages.clone(),
1755 client.clone().into(),
1756 remote_id,
1757 cx,
1758 )
1759 });
1760
1761 let git_store = cx.new(|cx| {
1762 GitStore::remote(
1763 // In this remote case we pass None for the environment
1764 &worktree_store,
1765 buffer_store.clone(),
1766 client.clone().into(),
1767 remote_id,
1768 cx,
1769 )
1770 });
1771
1772 let task_store = cx.new(|cx| {
1773 if run_tasks {
1774 TaskStore::remote(
1775 buffer_store.downgrade(),
1776 worktree_store.clone(),
1777 Arc::new(EmptyToolchainStore),
1778 client.clone().into(),
1779 remote_id,
1780 git_store.clone(),
1781 cx,
1782 )
1783 } else {
1784 TaskStore::Noop
1785 }
1786 });
1787
1788 let settings_observer = cx.new(|cx| {
1789 SettingsObserver::new_remote(
1790 fs.clone(),
1791 worktree_store.clone(),
1792 task_store.clone(),
1793 None,
1794 true,
1795 cx,
1796 )
1797 });
1798
1799 let agent_server_store = cx.new(|_cx| AgentServerStore::collab());
1800 let replica_id = ReplicaId::new(response.payload.replica_id as u16);
1801
1802 let project = cx.new(|cx| {
1803 let snippets = SnippetProvider::new(fs.clone(), BTreeSet::from_iter([]), cx);
1804
1805 let weak_self = cx.weak_entity();
1806 let context_server_store = cx.new(|cx| {
1807 ContextServerStore::local(worktree_store.clone(), Some(weak_self), false, cx)
1808 });
1809
1810 let mut worktrees = Vec::new();
1811 for worktree in response.payload.worktrees {
1812 let worktree = Worktree::remote(
1813 remote_id,
1814 replica_id,
1815 worktree,
1816 client.clone().into(),
1817 path_style,
1818 cx,
1819 );
1820 worktrees.push(worktree);
1821 }
1822
1823 let (tx, rx) = mpsc::unbounded();
1824 cx.spawn(async move |this, cx| Self::send_buffer_ordered_messages(this, rx, cx).await)
1825 .detach();
1826
1827 cx.subscribe(&worktree_store, Self::on_worktree_store_event)
1828 .detach();
1829
1830 cx.subscribe(&buffer_store, Self::on_buffer_store_event)
1831 .detach();
1832 cx.subscribe(&lsp_store, Self::on_lsp_store_event).detach();
1833 cx.subscribe(&settings_observer, Self::on_settings_observer_event)
1834 .detach();
1835
1836 cx.subscribe(&dap_store, Self::on_dap_store_event).detach();
1837
1838 let mut project = Self {
1839 buffer_ordered_messages_tx: tx,
1840 buffer_store: buffer_store.clone(),
1841 image_store,
1842 worktree_store: worktree_store.clone(),
1843 lsp_store: lsp_store.clone(),
1844 context_server_store,
1845 active_entry: None,
1846 collaborators: Default::default(),
1847 join_project_response_message_id: response.message_id,
1848 languages,
1849 user_store: user_store.clone(),
1850 task_store,
1851 snippets,
1852 fs,
1853 remote_client: None,
1854 settings_observer: settings_observer.clone(),
1855 client_subscriptions: Default::default(),
1856 _subscriptions: vec![cx.on_release(Self::release)],
1857 collab_client: client.clone(),
1858 client_state: ProjectClientState::Collab {
1859 sharing_has_stopped: false,
1860 capability: Capability::ReadWrite,
1861 remote_id,
1862 replica_id,
1863 },
1864 bookmark_store: bookmark_store.clone(),
1865 breakpoint_store: breakpoint_store.clone(),
1866 dap_store: dap_store.clone(),
1867 git_store: git_store.clone(),
1868 agent_server_store,
1869 buffers_needing_diff: Default::default(),
1870 git_diff_debouncer: DebouncedDelay::new(),
1871 terminals: Terminals {
1872 local_handles: Vec::new(),
1873 },
1874 node: None,
1875 search_history: Self::new_search_history(),
1876 search_included_history: Self::new_search_history(),
1877 search_excluded_history: Self::new_search_history(),
1878 environment,
1879 remotely_created_models: Arc::new(Mutex::new(RemotelyCreatedModels::default())),
1880 toolchain_store: None,
1881 agent_location: None,
1882 downloading_files: Default::default(),
1883 last_worktree_paths: WorktreePaths::default(),
1884 };
1885 project.set_role(role, cx);
1886 for worktree in worktrees {
1887 project.add_worktree(&worktree, cx);
1888 }
1889 project
1890 });
1891
1892 let weak_project = project.downgrade();
1893 lsp_store.update(&mut cx, |lsp_store, cx| {
1894 lsp_store.set_language_server_statuses_from_proto(
1895 weak_project,
1896 response.payload.language_servers,
1897 response.payload.language_server_capabilities,
1898 cx,
1899 );
1900 });
1901
1902 let subscriptions = subscriptions
1903 .into_iter()
1904 .map(|s| match s {
1905 EntitySubscription::BufferStore(subscription) => {
1906 subscription.set_entity(&buffer_store, &cx)
1907 }
1908 EntitySubscription::WorktreeStore(subscription) => {
1909 subscription.set_entity(&worktree_store, &cx)
1910 }
1911 EntitySubscription::GitStore(subscription) => {
1912 subscription.set_entity(&git_store, &cx)
1913 }
1914 EntitySubscription::SettingsObserver(subscription) => {
1915 subscription.set_entity(&settings_observer, &cx)
1916 }
1917 EntitySubscription::Project(subscription) => subscription.set_entity(&project, &cx),
1918 EntitySubscription::LspStore(subscription) => {
1919 subscription.set_entity(&lsp_store, &cx)
1920 }
1921 EntitySubscription::DapStore(subscription) => {
1922 subscription.set_entity(&dap_store, &cx)
1923 }
1924 EntitySubscription::BreakpointStore(subscription) => {
1925 subscription.set_entity(&breakpoint_store, &cx)
1926 }
1927 })
1928 .collect::<Vec<_>>();
1929
1930 let user_ids = response
1931 .payload
1932 .collaborators
1933 .iter()
1934 .map(|peer| peer.user_id)
1935 .collect();
1936 user_store
1937 .update(&mut cx, |user_store, cx| user_store.get_users(user_ids, cx))
1938 .await?;
1939
1940 project.update(&mut cx, |this, cx| {
1941 this.set_collaborators_from_proto(response.payload.collaborators, cx)?;
1942 this.client_subscriptions.extend(subscriptions);
1943 anyhow::Ok(())
1944 })?;
1945
1946 Ok(project)
1947 }
1948
1949 fn new_search_history() -> SearchHistory {
1950 SearchHistory::new(
1951 Some(MAX_PROJECT_SEARCH_HISTORY_SIZE),
1952 search_history::QueryInsertionBehavior::AlwaysInsert,
1953 )
1954 }
1955
1956 fn release(&mut self, cx: &mut App) {
1957 if let Some(client) = self.remote_client.take() {
1958 let shutdown = client.update(cx, |client, cx| {
1959 client.shutdown_processes(
1960 Some(proto::ShutdownRemoteServer {}),
1961 cx.background_executor().clone(),
1962 )
1963 });
1964
1965 cx.background_spawn(async move {
1966 if let Some(shutdown) = shutdown {
1967 shutdown.await;
1968 }
1969 })
1970 .detach()
1971 }
1972
1973 match &self.client_state {
1974 ProjectClientState::Local => {}
1975 ProjectClientState::Shared { .. } => {
1976 let _ = self.unshare_internal(cx);
1977 }
1978 ProjectClientState::Collab { remote_id, .. } => {
1979 let _ = self.collab_client.send(proto::LeaveProject {
1980 project_id: *remote_id,
1981 });
1982 self.disconnected_from_host_internal(cx);
1983 }
1984 }
1985 }
1986
1987 #[cfg(feature = "test-support")]
1988 pub fn client_subscriptions(&self) -> &Vec<client::Subscription> {
1989 &self.client_subscriptions
1990 }
1991
1992 #[cfg(feature = "test-support")]
1993 pub async fn example(
1994 root_paths: impl IntoIterator<Item = &Path>,
1995 cx: &mut AsyncApp,
1996 ) -> Entity<Project> {
1997 use clock::FakeSystemClock;
1998
1999 let fs = Arc::new(RealFs::new(None, cx.background_executor().clone()));
2000 let languages = LanguageRegistry::test(cx.background_executor().clone());
2001 let clock = Arc::new(FakeSystemClock::new());
2002 let http_client = http_client::FakeHttpClient::with_404_response();
2003 let client = cx.update(|cx| client::Client::new(clock, http_client.clone(), cx));
2004 let user_store = cx.new(|cx| UserStore::new(client.clone(), cx));
2005 let project = cx.update(|cx| {
2006 Project::local(
2007 client,
2008 node_runtime::NodeRuntime::unavailable(),
2009 user_store,
2010 Arc::new(languages),
2011 fs,
2012 None,
2013 LocalProjectFlags {
2014 init_worktree_trust: false,
2015 ..Default::default()
2016 },
2017 cx,
2018 )
2019 });
2020 for path in root_paths {
2021 let (tree, _): (Entity<Worktree>, _) = project
2022 .update(cx, |project, cx| {
2023 project.find_or_create_worktree(path, true, cx)
2024 })
2025 .await
2026 .unwrap();
2027 tree.read_with(cx, |tree, _| tree.as_local().unwrap().scan_complete())
2028 .await;
2029 }
2030 project
2031 }
2032
2033 #[cfg(feature = "test-support")]
2034 pub async fn test(
2035 fs: Arc<dyn Fs>,
2036 root_paths: impl IntoIterator<Item = &Path>,
2037 cx: &mut gpui::TestAppContext,
2038 ) -> Entity<Project> {
2039 Self::test_project(fs, root_paths, false, cx).await
2040 }
2041
2042 #[cfg(feature = "test-support")]
2043 pub async fn test_with_worktree_trust(
2044 fs: Arc<dyn Fs>,
2045 root_paths: impl IntoIterator<Item = &Path>,
2046 cx: &mut gpui::TestAppContext,
2047 ) -> Entity<Project> {
2048 Self::test_project(fs, root_paths, true, cx).await
2049 }
2050
2051 #[cfg(feature = "test-support")]
2052 async fn test_project(
2053 fs: Arc<dyn Fs>,
2054 root_paths: impl IntoIterator<Item = &Path>,
2055 init_worktree_trust: bool,
2056 cx: &mut gpui::TestAppContext,
2057 ) -> Entity<Project> {
2058 use clock::FakeSystemClock;
2059
2060 let languages = LanguageRegistry::test(cx.executor());
2061 let clock = Arc::new(FakeSystemClock::new());
2062 let http_client = http_client::FakeHttpClient::with_404_response();
2063 let client = cx.update(|cx| client::Client::new(clock, http_client.clone(), cx));
2064 let user_store = cx.new(|cx| UserStore::new(client.clone(), cx));
2065 let project = cx.update(|cx| {
2066 Project::local(
2067 client,
2068 node_runtime::NodeRuntime::unavailable(),
2069 user_store,
2070 Arc::new(languages),
2071 fs,
2072 None,
2073 LocalProjectFlags {
2074 init_worktree_trust,
2075 ..Default::default()
2076 },
2077 cx,
2078 )
2079 });
2080 for path in root_paths {
2081 let (tree, _) = project
2082 .update(cx, |project, cx| {
2083 project.find_or_create_worktree(path, true, cx)
2084 })
2085 .await
2086 .unwrap();
2087
2088 tree.read_with(cx, |tree, _| tree.as_local().unwrap().scan_complete())
2089 .await;
2090 }
2091 project
2092 }
2093
2094 /// Transitions a local test project into the `Collab` client state so that
2095 /// `is_via_collab()` returns `true`. Use only in tests.
2096 #[cfg(any(test, feature = "test-support"))]
2097 pub fn mark_as_collab_for_testing(&mut self) {
2098 self.client_state = ProjectClientState::Collab {
2099 sharing_has_stopped: false,
2100 capability: Capability::ReadWrite,
2101 remote_id: 0,
2102 replica_id: clock::ReplicaId::new(1),
2103 };
2104 }
2105
2106 #[cfg(any(test, feature = "test-support"))]
2107 pub fn add_test_remote_worktree(
2108 &mut self,
2109 abs_path: &str,
2110 cx: &mut Context<Self>,
2111 ) -> Entity<Worktree> {
2112 use rpc::NoopProtoClient;
2113 use util::paths::PathStyle;
2114
2115 let root_name = std::path::Path::new(abs_path)
2116 .file_name()
2117 .map(|n| n.to_string_lossy().to_string())
2118 .unwrap_or_default();
2119
2120 let client = AnyProtoClient::new(NoopProtoClient::new());
2121 let worktree = Worktree::remote(
2122 0,
2123 ReplicaId::new(1),
2124 proto::WorktreeMetadata {
2125 id: 100 + self.visible_worktrees(cx).count() as u64,
2126 root_name,
2127 visible: true,
2128 abs_path: abs_path.to_string(),
2129 root_repo_common_dir: None,
2130 },
2131 client,
2132 PathStyle::Posix,
2133 cx,
2134 );
2135 self.worktree_store
2136 .update(cx, |store, cx| store.add(&worktree, cx));
2137 worktree
2138 }
2139
2140 #[inline]
2141 pub fn dap_store(&self) -> Entity<DapStore> {
2142 self.dap_store.clone()
2143 }
2144
2145 #[inline]
2146 pub fn bookmark_store(&self) -> Entity<BookmarkStore> {
2147 self.bookmark_store.clone()
2148 }
2149
2150 #[inline]
2151 pub fn breakpoint_store(&self) -> Entity<BreakpointStore> {
2152 self.breakpoint_store.clone()
2153 }
2154
2155 pub fn active_debug_session(&self, cx: &App) -> Option<(Entity<Session>, ActiveStackFrame)> {
2156 let active_position = self.breakpoint_store.read(cx).active_position()?;
2157 let session = self
2158 .dap_store
2159 .read(cx)
2160 .session_by_id(active_position.session_id)?;
2161 Some((session, active_position.clone()))
2162 }
2163
2164 #[inline]
2165 pub fn lsp_store(&self) -> Entity<LspStore> {
2166 self.lsp_store.clone()
2167 }
2168
2169 #[inline]
2170 pub fn worktree_store(&self) -> Entity<WorktreeStore> {
2171 self.worktree_store.clone()
2172 }
2173
2174 /// Returns a future that resolves when all visible worktrees have completed
2175 /// their initial scan.
2176 pub fn wait_for_initial_scan(&self, cx: &App) -> impl Future<Output = ()> + use<> {
2177 self.worktree_store.read(cx).wait_for_initial_scan()
2178 }
2179
2180 #[inline]
2181 pub fn context_server_store(&self) -> Entity<ContextServerStore> {
2182 self.context_server_store.clone()
2183 }
2184
2185 #[inline]
2186 pub fn buffer_for_id(&self, remote_id: BufferId, cx: &App) -> Option<Entity<Buffer>> {
2187 self.buffer_store.read(cx).get(remote_id)
2188 }
2189
2190 #[inline]
2191 pub fn languages(&self) -> &Arc<LanguageRegistry> {
2192 &self.languages
2193 }
2194
2195 #[inline]
2196 pub fn client(&self) -> Arc<Client> {
2197 self.collab_client.clone()
2198 }
2199
2200 #[inline]
2201 pub fn remote_client(&self) -> Option<Entity<RemoteClient>> {
2202 self.remote_client.clone()
2203 }
2204
2205 #[inline]
2206 pub fn user_store(&self) -> Entity<UserStore> {
2207 self.user_store.clone()
2208 }
2209
2210 #[inline]
2211 pub fn node_runtime(&self) -> Option<&NodeRuntime> {
2212 self.node.as_ref()
2213 }
2214
2215 #[inline]
2216 pub fn opened_buffers(&self, cx: &App) -> Vec<Entity<Buffer>> {
2217 self.buffer_store.read(cx).buffers().collect()
2218 }
2219
2220 #[inline]
2221 pub fn environment(&self) -> &Entity<ProjectEnvironment> {
2222 &self.environment
2223 }
2224
2225 #[inline]
2226 pub fn cli_environment(&self, cx: &App) -> Option<HashMap<String, String>> {
2227 self.environment.read(cx).get_cli_environment()
2228 }
2229
2230 #[inline]
2231 pub fn peek_environment_error<'a>(&'a self, cx: &'a App) -> Option<&'a String> {
2232 self.environment.read(cx).peek_environment_error()
2233 }
2234
2235 #[inline]
2236 pub fn pop_environment_error(&mut self, cx: &mut Context<Self>) {
2237 self.environment.update(cx, |environment, _| {
2238 environment.pop_environment_error();
2239 });
2240 }
2241
2242 #[cfg(feature = "test-support")]
2243 #[inline]
2244 pub fn has_open_buffer(&self, path: impl Into<ProjectPath>, cx: &App) -> bool {
2245 self.buffer_store
2246 .read(cx)
2247 .get_by_path(&path.into())
2248 .is_some()
2249 }
2250
2251 #[inline]
2252 pub fn fs(&self) -> &Arc<dyn Fs> {
2253 &self.fs
2254 }
2255
2256 #[inline]
2257 pub fn remote_id(&self) -> Option<u64> {
2258 match self.client_state {
2259 ProjectClientState::Local => None,
2260 ProjectClientState::Shared { remote_id, .. }
2261 | ProjectClientState::Collab { remote_id, .. } => Some(remote_id),
2262 }
2263 }
2264
2265 #[inline]
2266 pub fn supports_terminal(&self, _cx: &App) -> bool {
2267 if self.is_local() {
2268 return true;
2269 }
2270 if self.is_via_remote_server() {
2271 return true;
2272 }
2273
2274 false
2275 }
2276
2277 #[inline]
2278 pub fn remote_connection_state(&self, cx: &App) -> Option<remote::ConnectionState> {
2279 self.remote_client
2280 .as_ref()
2281 .map(|remote| remote.read(cx).connection_state())
2282 }
2283
2284 #[inline]
2285 pub fn remote_connection_options(&self, cx: &App) -> Option<RemoteConnectionOptions> {
2286 self.remote_client
2287 .as_ref()
2288 .map(|remote| remote.read(cx).connection_options())
2289 }
2290
2291 /// Reveals the given path in the system file manager.
2292 ///
2293 /// On Windows with a WSL remote connection, this converts the POSIX path
2294 /// to a Windows UNC path before revealing.
2295 pub fn reveal_path(&self, path: &Path, cx: &mut Context<Self>) {
2296 #[cfg(target_os = "windows")]
2297 if let Some(RemoteConnectionOptions::Wsl(wsl_options)) = self.remote_connection_options(cx)
2298 {
2299 let path = path.to_path_buf();
2300 cx.spawn(async move |_, cx| {
2301 wsl_path_to_windows_path(&wsl_options, &path)
2302 .await
2303 .map(|windows_path| cx.update(|cx| cx.reveal_path(&windows_path)))
2304 })
2305 .detach_and_log_err(cx);
2306 return;
2307 }
2308
2309 cx.reveal_path(path);
2310 }
2311
2312 #[inline]
2313 pub fn replica_id(&self) -> ReplicaId {
2314 match self.client_state {
2315 ProjectClientState::Collab { replica_id, .. } => replica_id,
2316 _ => {
2317 if self.remote_client.is_some() {
2318 ReplicaId::REMOTE_SERVER
2319 } else {
2320 ReplicaId::LOCAL
2321 }
2322 }
2323 }
2324 }
2325
2326 #[inline]
2327 pub fn task_store(&self) -> &Entity<TaskStore> {
2328 &self.task_store
2329 }
2330
2331 #[inline]
2332 pub fn snippets(&self) -> &Entity<SnippetProvider> {
2333 &self.snippets
2334 }
2335
2336 #[inline]
2337 pub fn search_history(&self, kind: SearchInputKind) -> &SearchHistory {
2338 match kind {
2339 SearchInputKind::Query => &self.search_history,
2340 SearchInputKind::Include => &self.search_included_history,
2341 SearchInputKind::Exclude => &self.search_excluded_history,
2342 }
2343 }
2344
2345 #[inline]
2346 pub fn search_history_mut(&mut self, kind: SearchInputKind) -> &mut SearchHistory {
2347 match kind {
2348 SearchInputKind::Query => &mut self.search_history,
2349 SearchInputKind::Include => &mut self.search_included_history,
2350 SearchInputKind::Exclude => &mut self.search_excluded_history,
2351 }
2352 }
2353
2354 #[inline]
2355 pub fn collaborators(&self) -> &HashMap<proto::PeerId, Collaborator> {
2356 &self.collaborators
2357 }
2358
2359 #[inline]
2360 pub fn host(&self) -> Option<&Collaborator> {
2361 self.collaborators.values().find(|c| c.is_host)
2362 }
2363
2364 #[inline]
2365 pub fn set_worktrees_reordered(&mut self, worktrees_reordered: bool, cx: &mut App) {
2366 self.worktree_store.update(cx, |store, _| {
2367 store.set_worktrees_reordered(worktrees_reordered);
2368 });
2369 }
2370
2371 /// Collect all worktrees, including ones that don't appear in the project panel
2372 #[inline]
2373 pub fn worktrees<'a>(
2374 &self,
2375 cx: &'a App,
2376 ) -> impl 'a + DoubleEndedIterator<Item = Entity<Worktree>> {
2377 self.worktree_store.read(cx).worktrees()
2378 }
2379
2380 /// Collect all user-visible worktrees, the ones that appear in the project panel.
2381 #[inline]
2382 pub fn visible_worktrees<'a>(
2383 &'a self,
2384 cx: &'a App,
2385 ) -> impl 'a + DoubleEndedIterator<Item = Entity<Worktree>> {
2386 self.worktree_store.read(cx).visible_worktrees(cx)
2387 }
2388
2389 pub(crate) fn default_visible_worktree_paths(
2390 worktree_store: &WorktreeStore,
2391 cx: &App,
2392 ) -> Vec<PathBuf> {
2393 worktree_store
2394 .visible_worktrees(cx)
2395 .sorted_by(|left, right| {
2396 left.read(cx)
2397 .is_single_file()
2398 .cmp(&right.read(cx).is_single_file())
2399 })
2400 .filter_map(|worktree| {
2401 let worktree = worktree.read(cx);
2402 let path = worktree.abs_path();
2403 if worktree.is_single_file() {
2404 Some(path.parent()?.to_path_buf())
2405 } else {
2406 Some(path.to_path_buf())
2407 }
2408 })
2409 .collect()
2410 }
2411
2412 pub fn default_path_list(&self, cx: &App) -> PathList {
2413 let worktree_roots =
2414 Self::default_visible_worktree_paths(&self.worktree_store.read(cx), cx);
2415
2416 if worktree_roots.is_empty() {
2417 PathList::new(&[paths::home_dir().as_path()])
2418 } else {
2419 PathList::new(&worktree_roots)
2420 }
2421 }
2422
2423 #[inline]
2424 pub fn worktree_for_root_name(&self, root_name: &str, cx: &App) -> Option<Entity<Worktree>> {
2425 self.visible_worktrees(cx)
2426 .find(|tree| tree.read(cx).root_name() == root_name)
2427 }
2428
2429 fn emit_group_key_changed_if_needed(&mut self, cx: &mut Context<Self>) {
2430 let new_worktree_paths = self.worktree_paths(cx);
2431 if new_worktree_paths != self.last_worktree_paths {
2432 let old_worktree_paths =
2433 std::mem::replace(&mut self.last_worktree_paths, new_worktree_paths);
2434 cx.emit(Event::WorktreePathsChanged { old_worktree_paths });
2435 }
2436 }
2437
2438 #[inline]
2439 pub fn worktree_root_names<'a>(&'a self, cx: &'a App) -> impl Iterator<Item = &'a str> {
2440 self.visible_worktrees(cx)
2441 .map(|tree| tree.read(cx).root_name().as_unix_str())
2442 }
2443
2444 #[inline]
2445 pub fn worktree_for_id(&self, id: WorktreeId, cx: &App) -> Option<Entity<Worktree>> {
2446 self.worktree_store.read(cx).worktree_for_id(id, cx)
2447 }
2448
2449 pub fn worktree_for_entry(
2450 &self,
2451 entry_id: ProjectEntryId,
2452 cx: &App,
2453 ) -> Option<Entity<Worktree>> {
2454 self.worktree_store
2455 .read(cx)
2456 .worktree_for_entry(entry_id, cx)
2457 }
2458
2459 #[inline]
2460 pub fn worktree_id_for_entry(&self, entry_id: ProjectEntryId, cx: &App) -> Option<WorktreeId> {
2461 self.worktree_for_entry(entry_id, cx)
2462 .map(|worktree| worktree.read(cx).id())
2463 }
2464
2465 /// Checks if the entry is the root of a worktree.
2466 #[inline]
2467 pub fn entry_is_worktree_root(&self, entry_id: ProjectEntryId, cx: &App) -> bool {
2468 self.worktree_for_entry(entry_id, cx)
2469 .map(|worktree| {
2470 worktree
2471 .read(cx)
2472 .root_entry()
2473 .is_some_and(|e| e.id == entry_id)
2474 })
2475 .unwrap_or(false)
2476 }
2477
2478 #[inline]
2479 pub fn project_path_git_status(
2480 &self,
2481 project_path: &ProjectPath,
2482 cx: &App,
2483 ) -> Option<FileStatus> {
2484 self.git_store
2485 .read(cx)
2486 .project_path_git_status(project_path, cx)
2487 }
2488
2489 #[inline]
2490 pub fn visibility_for_paths(
2491 &self,
2492 paths: &[PathBuf],
2493 exclude_sub_dirs: bool,
2494 cx: &App,
2495 ) -> Option<bool> {
2496 paths
2497 .iter()
2498 .map(|path| self.visibility_for_path(path, exclude_sub_dirs, cx))
2499 .max()
2500 .flatten()
2501 }
2502
2503 pub fn visibility_for_path(
2504 &self,
2505 path: &Path,
2506 exclude_sub_dirs: bool,
2507 cx: &App,
2508 ) -> Option<bool> {
2509 let path = SanitizedPath::new(path).as_path();
2510 let path_style = self.path_style(cx);
2511 self.worktrees(cx)
2512 .filter_map(|worktree| {
2513 let worktree = worktree.read(cx);
2514 let abs_path = worktree.abs_path();
2515 let relative_path = path_style.strip_prefix(path, abs_path.as_ref());
2516 let is_dir = relative_path
2517 .as_ref()
2518 .and_then(|p| worktree.entry_for_path(p))
2519 .is_some_and(|e| e.is_dir());
2520 // Don't exclude the worktree root itself, only actual subdirectories
2521 let is_subdir = relative_path
2522 .as_ref()
2523 .is_some_and(|p| !p.as_ref().as_unix_str().is_empty());
2524 let contains =
2525 relative_path.is_some() && (!exclude_sub_dirs || !is_dir || !is_subdir);
2526 contains.then(|| worktree.is_visible())
2527 })
2528 .max()
2529 }
2530
2531 pub fn create_entry(
2532 &mut self,
2533 project_path: impl Into<ProjectPath>,
2534 is_directory: bool,
2535 cx: &mut Context<Self>,
2536 ) -> Task<Result<CreatedEntry>> {
2537 let project_path = project_path.into();
2538 let Some(worktree) = self.worktree_for_id(project_path.worktree_id, cx) else {
2539 return Task::ready(Err(anyhow!(format!(
2540 "No worktree for path {project_path:?}"
2541 ))));
2542 };
2543 worktree.update(cx, |worktree, cx| {
2544 worktree.create_entry(project_path.path, is_directory, None, cx)
2545 })
2546 }
2547
2548 #[inline]
2549 pub fn copy_entry(
2550 &mut self,
2551 entry_id: ProjectEntryId,
2552 new_project_path: ProjectPath,
2553 cx: &mut Context<Self>,
2554 ) -> Task<Result<Option<Entry>>> {
2555 self.worktree_store.update(cx, |worktree_store, cx| {
2556 worktree_store.copy_entry(entry_id, new_project_path, cx)
2557 })
2558 }
2559
2560 /// Renames the project entry with given `entry_id`.
2561 ///
2562 /// `new_path` is a relative path to worktree root.
2563 /// If root entry is renamed then its new root name is used instead.
2564 pub fn rename_entry(
2565 &mut self,
2566 entry_id: ProjectEntryId,
2567 new_path: ProjectPath,
2568 cx: &mut Context<Self>,
2569 ) -> Task<Result<CreatedEntry>> {
2570 let worktree_store = self.worktree_store.clone();
2571 let Some((worktree, old_path, is_dir)) = worktree_store
2572 .read(cx)
2573 .worktree_and_entry_for_id(entry_id, cx)
2574 .map(|(worktree, entry)| (worktree, entry.path.clone(), entry.is_dir()))
2575 else {
2576 return Task::ready(Err(anyhow!(format!("No worktree for entry {entry_id:?}"))));
2577 };
2578
2579 let worktree_id = worktree.read(cx).id();
2580 let is_root_entry = self.entry_is_worktree_root(entry_id, cx);
2581
2582 let lsp_store = self.lsp_store().downgrade();
2583 cx.spawn(async move |project, cx| {
2584 let (old_abs_path, new_abs_path) = {
2585 let root_path = worktree.read_with(cx, |this, _| this.abs_path());
2586 let new_abs_path = if is_root_entry {
2587 root_path
2588 .parent()
2589 .unwrap()
2590 .join(new_path.path.as_std_path())
2591 } else {
2592 root_path.join(&new_path.path.as_std_path())
2593 };
2594 (root_path.join(old_path.as_std_path()), new_abs_path)
2595 };
2596 let transaction = LspStore::will_rename_entry(
2597 lsp_store.clone(),
2598 worktree_id,
2599 &old_abs_path,
2600 &new_abs_path,
2601 is_dir,
2602 cx.clone(),
2603 )
2604 .await;
2605
2606 let entry = worktree_store
2607 .update(cx, |worktree_store, cx| {
2608 worktree_store.rename_entry(entry_id, new_path.clone(), cx)
2609 })
2610 .await?;
2611
2612 project
2613 .update(cx, |_, cx| {
2614 cx.emit(Event::EntryRenamed(
2615 transaction,
2616 new_path.clone(),
2617 new_abs_path.clone(),
2618 ));
2619 })
2620 .ok();
2621
2622 lsp_store
2623 .read_with(cx, |this, _| {
2624 this.did_rename_entry(worktree_id, &old_abs_path, &new_abs_path, is_dir);
2625 })
2626 .ok();
2627 Ok(entry)
2628 })
2629 }
2630
2631 #[inline]
2632 pub fn delete_file(
2633 &mut self,
2634 path: ProjectPath,
2635 trash: bool,
2636 cx: &mut Context<Self>,
2637 ) -> Option<Task<Result<Option<TrashedEntry>>>> {
2638 let entry = self.entry_for_path(&path, cx)?;
2639 self.delete_entry(entry.id, trash, cx)
2640 }
2641
2642 #[inline]
2643 pub fn delete_entry(
2644 &mut self,
2645 entry_id: ProjectEntryId,
2646 trash: bool,
2647 cx: &mut Context<Self>,
2648 ) -> Option<Task<Result<Option<TrashedEntry>>>> {
2649 let worktree = self.worktree_for_entry(entry_id, cx)?;
2650 cx.emit(Event::DeletedEntry(worktree.read(cx).id(), entry_id));
2651 worktree.update(cx, |worktree, cx| {
2652 worktree.delete_entry(entry_id, trash, cx)
2653 })
2654 }
2655
2656 #[inline]
2657 pub fn restore_entry(
2658 &self,
2659 worktree_id: WorktreeId,
2660 trash_entry: TrashedEntry,
2661 cx: &mut Context<'_, Self>,
2662 ) -> Task<Result<ProjectPath>> {
2663 let Some(worktree) = self.worktree_for_id(worktree_id, cx) else {
2664 return Task::ready(Err(anyhow!("No worktree for id {worktree_id:?}")));
2665 };
2666
2667 cx.spawn(async move |_, cx| {
2668 Worktree::restore_entry(trash_entry, worktree, cx)
2669 .await
2670 .map(|rel_path_buf| ProjectPath {
2671 worktree_id: worktree_id,
2672 path: Arc::from(rel_path_buf.as_rel_path()),
2673 })
2674 })
2675 }
2676
2677 #[inline]
2678 pub fn expand_entry(
2679 &mut self,
2680 worktree_id: WorktreeId,
2681 entry_id: ProjectEntryId,
2682 cx: &mut Context<Self>,
2683 ) -> Option<Task<Result<()>>> {
2684 let worktree = self.worktree_for_id(worktree_id, cx)?;
2685 worktree.update(cx, |worktree, cx| worktree.expand_entry(entry_id, cx))
2686 }
2687
2688 pub fn expand_all_for_entry(
2689 &mut self,
2690 worktree_id: WorktreeId,
2691 entry_id: ProjectEntryId,
2692 cx: &mut Context<Self>,
2693 ) -> Option<Task<Result<()>>> {
2694 let worktree = self.worktree_for_id(worktree_id, cx)?;
2695 let task = worktree.update(cx, |worktree, cx| {
2696 worktree.expand_all_for_entry(entry_id, cx)
2697 });
2698 Some(cx.spawn(async move |this, cx| {
2699 task.context("no task")?.await?;
2700 this.update(cx, |_, cx| {
2701 cx.emit(Event::ExpandedAllForEntry(worktree_id, entry_id));
2702 })?;
2703 Ok(())
2704 }))
2705 }
2706
2707 pub fn shared(&mut self, project_id: u64, cx: &mut Context<Self>) -> Result<()> {
2708 anyhow::ensure!(
2709 matches!(self.client_state, ProjectClientState::Local),
2710 "project was already shared"
2711 );
2712
2713 self.client_subscriptions.extend([
2714 self.collab_client
2715 .subscribe_to_entity(project_id)?
2716 .set_entity(&cx.entity(), &cx.to_async()),
2717 self.collab_client
2718 .subscribe_to_entity(project_id)?
2719 .set_entity(&self.worktree_store, &cx.to_async()),
2720 self.collab_client
2721 .subscribe_to_entity(project_id)?
2722 .set_entity(&self.buffer_store, &cx.to_async()),
2723 self.collab_client
2724 .subscribe_to_entity(project_id)?
2725 .set_entity(&self.lsp_store, &cx.to_async()),
2726 self.collab_client
2727 .subscribe_to_entity(project_id)?
2728 .set_entity(&self.settings_observer, &cx.to_async()),
2729 self.collab_client
2730 .subscribe_to_entity(project_id)?
2731 .set_entity(&self.dap_store, &cx.to_async()),
2732 self.collab_client
2733 .subscribe_to_entity(project_id)?
2734 .set_entity(&self.breakpoint_store, &cx.to_async()),
2735 self.collab_client
2736 .subscribe_to_entity(project_id)?
2737 .set_entity(&self.git_store, &cx.to_async()),
2738 ]);
2739
2740 self.buffer_store.update(cx, |buffer_store, cx| {
2741 buffer_store.shared(project_id, self.collab_client.clone().into(), cx)
2742 });
2743 self.worktree_store.update(cx, |worktree_store, cx| {
2744 worktree_store.shared(project_id, self.collab_client.clone().into(), cx);
2745 });
2746 self.lsp_store.update(cx, |lsp_store, cx| {
2747 lsp_store.shared(project_id, self.collab_client.clone().into(), cx)
2748 });
2749 self.breakpoint_store.update(cx, |breakpoint_store, _| {
2750 breakpoint_store.shared(project_id, self.collab_client.clone().into())
2751 });
2752 self.dap_store.update(cx, |dap_store, cx| {
2753 dap_store.shared(project_id, self.collab_client.clone().into(), cx);
2754 });
2755 self.task_store.update(cx, |task_store, cx| {
2756 task_store.shared(project_id, self.collab_client.clone().into(), cx);
2757 });
2758 self.settings_observer.update(cx, |settings_observer, cx| {
2759 settings_observer.shared(project_id, self.collab_client.clone().into(), cx)
2760 });
2761 self.git_store.update(cx, |git_store, cx| {
2762 git_store.shared(project_id, self.collab_client.clone().into(), cx)
2763 });
2764
2765 self.client_state = ProjectClientState::Shared {
2766 remote_id: project_id,
2767 };
2768
2769 cx.emit(Event::RemoteIdChanged(Some(project_id)));
2770 Ok(())
2771 }
2772
2773 pub fn reshared(
2774 &mut self,
2775 message: proto::ResharedProject,
2776 cx: &mut Context<Self>,
2777 ) -> Result<()> {
2778 self.buffer_store
2779 .update(cx, |buffer_store, _| buffer_store.forget_shared_buffers());
2780 self.set_collaborators_from_proto(message.collaborators, cx)?;
2781
2782 self.worktree_store.update(cx, |worktree_store, cx| {
2783 worktree_store.send_project_updates(cx);
2784 });
2785 if let Some(remote_id) = self.remote_id() {
2786 self.git_store.update(cx, |git_store, cx| {
2787 git_store.shared(remote_id, self.collab_client.clone().into(), cx)
2788 });
2789 }
2790 cx.emit(Event::Reshared);
2791 Ok(())
2792 }
2793
2794 pub fn rejoined(
2795 &mut self,
2796 message: proto::RejoinedProject,
2797 message_id: u32,
2798 cx: &mut Context<Self>,
2799 ) -> Result<()> {
2800 cx.update_global::<SettingsStore, _>(|store, cx| {
2801 for worktree_metadata in &message.worktrees {
2802 store
2803 .clear_local_settings(WorktreeId::from_proto(worktree_metadata.id), cx)
2804 .log_err();
2805 }
2806 });
2807
2808 self.join_project_response_message_id = message_id;
2809 self.set_worktrees_from_proto(message.worktrees, cx)?;
2810 self.set_collaborators_from_proto(message.collaborators, cx)?;
2811
2812 let project = cx.weak_entity();
2813 self.lsp_store.update(cx, |lsp_store, cx| {
2814 lsp_store.set_language_server_statuses_from_proto(
2815 project,
2816 message.language_servers,
2817 message.language_server_capabilities,
2818 cx,
2819 )
2820 });
2821 self.enqueue_buffer_ordered_message(BufferOrderedMessage::Resync)
2822 .unwrap();
2823 cx.emit(Event::Rejoined);
2824 Ok(())
2825 }
2826
2827 #[inline]
2828 pub fn unshare(&mut self, cx: &mut Context<Self>) -> Result<()> {
2829 self.unshare_internal(cx)?;
2830 cx.emit(Event::RemoteIdChanged(None));
2831 Ok(())
2832 }
2833
2834 fn unshare_internal(&mut self, cx: &mut App) -> Result<()> {
2835 anyhow::ensure!(
2836 !self.is_via_collab(),
2837 "attempted to unshare a remote project"
2838 );
2839
2840 if let ProjectClientState::Shared { remote_id, .. } = self.client_state {
2841 self.client_state = ProjectClientState::Local;
2842 self.collaborators.clear();
2843 self.client_subscriptions.clear();
2844 self.worktree_store.update(cx, |store, cx| {
2845 store.unshared(cx);
2846 });
2847 self.buffer_store.update(cx, |buffer_store, cx| {
2848 buffer_store.forget_shared_buffers();
2849 buffer_store.unshared(cx)
2850 });
2851 self.task_store.update(cx, |task_store, cx| {
2852 task_store.unshared(cx);
2853 });
2854 self.breakpoint_store.update(cx, |breakpoint_store, cx| {
2855 breakpoint_store.unshared(cx);
2856 });
2857 self.dap_store.update(cx, |dap_store, cx| {
2858 dap_store.unshared(cx);
2859 });
2860 self.settings_observer.update(cx, |settings_observer, cx| {
2861 settings_observer.unshared(cx);
2862 });
2863 self.git_store.update(cx, |git_store, cx| {
2864 git_store.unshared(cx);
2865 });
2866
2867 self.collab_client
2868 .send(proto::UnshareProject {
2869 project_id: remote_id,
2870 })
2871 .ok();
2872 Ok(())
2873 } else {
2874 anyhow::bail!("attempted to unshare an unshared project");
2875 }
2876 }
2877
2878 pub fn disconnected_from_host(&mut self, cx: &mut Context<Self>) {
2879 if self.is_disconnected(cx) {
2880 return;
2881 }
2882 self.disconnected_from_host_internal(cx);
2883 cx.emit(Event::DisconnectedFromHost);
2884 }
2885
2886 pub fn set_role(&mut self, role: proto::ChannelRole, cx: &mut Context<Self>) {
2887 let new_capability =
2888 if role == proto::ChannelRole::Member || role == proto::ChannelRole::Admin {
2889 Capability::ReadWrite
2890 } else {
2891 Capability::ReadOnly
2892 };
2893 if let ProjectClientState::Collab { capability, .. } = &mut self.client_state {
2894 if *capability == new_capability {
2895 return;
2896 }
2897
2898 *capability = new_capability;
2899 for buffer in self.opened_buffers(cx) {
2900 buffer.update(cx, |buffer, cx| buffer.set_capability(new_capability, cx));
2901 }
2902 }
2903 }
2904
2905 fn disconnected_from_host_internal(&mut self, cx: &mut App) {
2906 if let ProjectClientState::Collab {
2907 sharing_has_stopped,
2908 ..
2909 } = &mut self.client_state
2910 {
2911 *sharing_has_stopped = true;
2912 self.client_subscriptions.clear();
2913 self.collaborators.clear();
2914 self.worktree_store.update(cx, |store, cx| {
2915 store.disconnected_from_host(cx);
2916 });
2917 self.buffer_store.update(cx, |buffer_store, cx| {
2918 buffer_store.disconnected_from_host(cx)
2919 });
2920 self.lsp_store
2921 .update(cx, |lsp_store, _cx| lsp_store.disconnected_from_host());
2922 }
2923 }
2924
2925 #[inline]
2926 pub fn close(&mut self, cx: &mut Context<Self>) {
2927 cx.emit(Event::Closed);
2928 }
2929
2930 #[inline]
2931 pub fn is_disconnected(&self, cx: &App) -> bool {
2932 match &self.client_state {
2933 ProjectClientState::Collab {
2934 sharing_has_stopped,
2935 ..
2936 } => *sharing_has_stopped,
2937 ProjectClientState::Local if self.is_via_remote_server() => {
2938 self.remote_client_is_disconnected(cx)
2939 }
2940 _ => false,
2941 }
2942 }
2943
2944 #[inline]
2945 fn remote_client_is_disconnected(&self, cx: &App) -> bool {
2946 self.remote_client
2947 .as_ref()
2948 .map(|remote| remote.read(cx).is_disconnected())
2949 .unwrap_or(false)
2950 }
2951
2952 #[inline]
2953 pub fn capability(&self) -> Capability {
2954 match &self.client_state {
2955 ProjectClientState::Collab { capability, .. } => *capability,
2956 ProjectClientState::Shared { .. } | ProjectClientState::Local => Capability::ReadWrite,
2957 }
2958 }
2959
2960 #[inline]
2961 pub fn is_read_only(&self, cx: &App) -> bool {
2962 self.is_disconnected(cx) || !self.capability().editable()
2963 }
2964
2965 #[inline]
2966 pub fn is_local(&self) -> bool {
2967 match &self.client_state {
2968 ProjectClientState::Local | ProjectClientState::Shared { .. } => {
2969 self.remote_client.is_none()
2970 }
2971 ProjectClientState::Collab { .. } => false,
2972 }
2973 }
2974
2975 /// Whether this project is a remote server (not counting collab).
2976 #[inline]
2977 pub fn is_via_remote_server(&self) -> bool {
2978 match &self.client_state {
2979 ProjectClientState::Local | ProjectClientState::Shared { .. } => {
2980 self.remote_client.is_some()
2981 }
2982 ProjectClientState::Collab { .. } => false,
2983 }
2984 }
2985
2986 /// Whether this project is from collab (not counting remote servers).
2987 #[inline]
2988 pub fn is_via_collab(&self) -> bool {
2989 match &self.client_state {
2990 ProjectClientState::Local | ProjectClientState::Shared { .. } => false,
2991 ProjectClientState::Collab { .. } => true,
2992 }
2993 }
2994
2995 /// `!self.is_local()`
2996 #[inline]
2997 pub fn is_remote(&self) -> bool {
2998 debug_assert_eq!(
2999 !self.is_local(),
3000 self.is_via_collab() || self.is_via_remote_server()
3001 );
3002 !self.is_local()
3003 }
3004
3005 #[inline]
3006 pub fn is_via_wsl_with_host_interop(&self, cx: &App) -> bool {
3007 match &self.client_state {
3008 ProjectClientState::Local | ProjectClientState::Shared { .. } => {
3009 matches!(
3010 &self.remote_client, Some(remote_client)
3011 if remote_client.read(cx).has_wsl_interop()
3012 )
3013 }
3014 _ => false,
3015 }
3016 }
3017
3018 pub fn disable_worktree_scanner(&mut self, cx: &mut Context<Self>) {
3019 self.worktree_store.update(cx, |worktree_store, _cx| {
3020 worktree_store.disable_scanner();
3021 });
3022 }
3023
3024 #[inline]
3025 pub fn create_buffer(
3026 &mut self,
3027 language: Option<Arc<Language>>,
3028 project_searchable: bool,
3029 cx: &mut Context<Self>,
3030 ) -> Task<Result<Entity<Buffer>>> {
3031 self.buffer_store.update(cx, |buffer_store, cx| {
3032 buffer_store.create_buffer(language, project_searchable, cx)
3033 })
3034 }
3035
3036 #[inline]
3037 pub fn create_local_buffer(
3038 &mut self,
3039 text: &str,
3040 language: Option<Arc<Language>>,
3041 project_searchable: bool,
3042 cx: &mut Context<Self>,
3043 ) -> Entity<Buffer> {
3044 if self.is_remote() {
3045 panic!("called create_local_buffer on a remote project")
3046 }
3047 self.buffer_store.update(cx, |buffer_store, cx| {
3048 buffer_store.create_local_buffer(text, language, project_searchable, cx)
3049 })
3050 }
3051
3052 pub fn open_path(
3053 &mut self,
3054 path: ProjectPath,
3055 cx: &mut Context<Self>,
3056 ) -> Task<Result<(Option<ProjectEntryId>, Entity<Buffer>)>> {
3057 let task = self.open_buffer(path, cx);
3058 cx.spawn(async move |_project, cx| {
3059 let buffer = task.await?;
3060 let project_entry_id = buffer.read_with(cx, |buffer, _cx| {
3061 File::from_dyn(buffer.file()).and_then(|file| file.project_entry_id())
3062 });
3063
3064 Ok((project_entry_id, buffer))
3065 })
3066 }
3067
3068 pub fn open_local_buffer(
3069 &mut self,
3070 abs_path: impl AsRef<Path>,
3071 cx: &mut Context<Self>,
3072 ) -> Task<Result<Entity<Buffer>>> {
3073 let worktree_task = self.find_or_create_worktree(abs_path.as_ref(), false, cx);
3074 cx.spawn(async move |this, cx| {
3075 let (worktree, relative_path) = worktree_task.await?;
3076 this.update(cx, |this, cx| {
3077 this.open_buffer((worktree.read(cx).id(), relative_path), cx)
3078 })?
3079 .await
3080 })
3081 }
3082
3083 #[cfg(feature = "test-support")]
3084 pub fn open_local_buffer_with_lsp(
3085 &mut self,
3086 abs_path: impl AsRef<Path>,
3087 cx: &mut Context<Self>,
3088 ) -> Task<Result<(Entity<Buffer>, lsp_store::OpenLspBufferHandle)>> {
3089 if let Some((worktree, relative_path)) = self.find_worktree(abs_path.as_ref(), cx) {
3090 self.open_buffer_with_lsp((worktree.read(cx).id(), relative_path), cx)
3091 } else {
3092 Task::ready(Err(anyhow!("no such path")))
3093 }
3094 }
3095
3096 pub fn download_file(
3097 &mut self,
3098 worktree_id: WorktreeId,
3099 path: Arc<RelPath>,
3100 destination_path: PathBuf,
3101 cx: &mut Context<Self>,
3102 ) -> Task<Result<()>> {
3103 log::debug!(
3104 "download_file called: worktree_id={:?}, path={:?}, destination={:?}",
3105 worktree_id,
3106 path,
3107 destination_path
3108 );
3109
3110 let Some(remote_client) = &self.remote_client else {
3111 log::error!("download_file: not a remote project");
3112 return Task::ready(Err(anyhow!("not a remote project")));
3113 };
3114
3115 let proto_client = remote_client.read(cx).proto_client();
3116 // For SSH remote projects, use REMOTE_SERVER_PROJECT_ID instead of remote_id()
3117 // because SSH projects have client_state: Local but still need to communicate with remote server
3118 let project_id = self.remote_id().unwrap_or(REMOTE_SERVER_PROJECT_ID);
3119 let downloading_files = self.downloading_files.clone();
3120 let path_str = path.to_proto();
3121
3122 static NEXT_FILE_ID: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
3123 let file_id = NEXT_FILE_ID.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
3124
3125 // Register BEFORE sending request to avoid race condition
3126 let key = (worktree_id, path_str.clone());
3127 log::debug!(
3128 "download_file: pre-registering download with key={:?}, file_id={}",
3129 key,
3130 file_id
3131 );
3132 downloading_files.lock().insert(
3133 key,
3134 DownloadingFile {
3135 destination_path: destination_path,
3136 chunks: Vec::new(),
3137 total_size: 0,
3138 file_id: Some(file_id),
3139 },
3140 );
3141 log::debug!(
3142 "download_file: sending DownloadFileByPath request, path_str={}",
3143 path_str
3144 );
3145
3146 cx.spawn(async move |_this, _cx| {
3147 log::debug!("download_file: sending request with file_id={}...", file_id);
3148 let response = proto_client
3149 .request(proto::DownloadFileByPath {
3150 project_id,
3151 worktree_id: worktree_id.to_proto(),
3152 path: path_str.clone(),
3153 file_id,
3154 })
3155 .await?;
3156
3157 log::debug!("download_file: got response, file_id={}", response.file_id);
3158 // The file_id is set from the State message, we just confirm the request succeeded
3159 Ok(())
3160 })
3161 }
3162
3163 #[ztracing::instrument(skip_all)]
3164 pub fn open_buffer(
3165 &mut self,
3166 path: impl Into<ProjectPath>,
3167 cx: &mut App,
3168 ) -> Task<Result<Entity<Buffer>>> {
3169 if self.is_disconnected(cx) {
3170 return Task::ready(Err(anyhow!(ErrorCode::Disconnected)));
3171 }
3172
3173 self.buffer_store.update(cx, |buffer_store, cx| {
3174 buffer_store.open_buffer(path.into(), cx)
3175 })
3176 }
3177
3178 #[cfg(feature = "test-support")]
3179 pub fn open_buffer_with_lsp(
3180 &mut self,
3181 path: impl Into<ProjectPath>,
3182 cx: &mut Context<Self>,
3183 ) -> Task<Result<(Entity<Buffer>, lsp_store::OpenLspBufferHandle)>> {
3184 let buffer = self.open_buffer(path, cx);
3185 cx.spawn(async move |this, cx| {
3186 let buffer = buffer.await?;
3187 let handle = this.update(cx, |project, cx| {
3188 project.register_buffer_with_language_servers(&buffer, cx)
3189 })?;
3190 Ok((buffer, handle))
3191 })
3192 }
3193
3194 pub fn register_buffer_with_language_servers(
3195 &self,
3196 buffer: &Entity<Buffer>,
3197 cx: &mut App,
3198 ) -> OpenLspBufferHandle {
3199 self.lsp_store.update(cx, |lsp_store, cx| {
3200 lsp_store.register_buffer_with_language_servers(buffer, HashSet::default(), false, cx)
3201 })
3202 }
3203
3204 pub fn open_unstaged_diff(
3205 &mut self,
3206 buffer: Entity<Buffer>,
3207 cx: &mut Context<Self>,
3208 ) -> Task<Result<Entity<BufferDiff>>> {
3209 if self.is_disconnected(cx) {
3210 return Task::ready(Err(anyhow!(ErrorCode::Disconnected)));
3211 }
3212 self.git_store
3213 .update(cx, |git_store, cx| git_store.open_unstaged_diff(buffer, cx))
3214 }
3215
3216 #[ztracing::instrument(skip_all)]
3217 pub fn open_uncommitted_diff(
3218 &mut self,
3219 buffer: Entity<Buffer>,
3220 cx: &mut Context<Self>,
3221 ) -> Task<Result<Entity<BufferDiff>>> {
3222 if self.is_disconnected(cx) {
3223 return Task::ready(Err(anyhow!(ErrorCode::Disconnected)));
3224 }
3225 self.git_store.update(cx, |git_store, cx| {
3226 git_store.open_uncommitted_diff(buffer, cx)
3227 })
3228 }
3229
3230 pub fn open_buffer_by_id(
3231 &mut self,
3232 id: BufferId,
3233 cx: &mut Context<Self>,
3234 ) -> Task<Result<Entity<Buffer>>> {
3235 if let Some(buffer) = self.buffer_for_id(id, cx) {
3236 Task::ready(Ok(buffer))
3237 } else if self.is_local() || self.is_via_remote_server() {
3238 Task::ready(Err(anyhow!("buffer {id} does not exist")))
3239 } else if let Some(project_id) = self.remote_id() {
3240 let request = self.collab_client.request(proto::OpenBufferById {
3241 project_id,
3242 id: id.into(),
3243 });
3244 cx.spawn(async move |project, cx| {
3245 let buffer_id = BufferId::new(request.await?.buffer_id)?;
3246 project
3247 .update(cx, |project, cx| {
3248 project.buffer_store.update(cx, |buffer_store, cx| {
3249 buffer_store.wait_for_remote_buffer(buffer_id, cx)
3250 })
3251 })?
3252 .await
3253 })
3254 } else {
3255 Task::ready(Err(anyhow!("cannot open buffer while disconnected")))
3256 }
3257 }
3258
3259 pub fn save_buffers(
3260 &self,
3261 buffers: HashSet<Entity<Buffer>>,
3262 cx: &mut Context<Self>,
3263 ) -> Task<Result<()>> {
3264 cx.spawn(async move |this, cx| {
3265 let save_tasks = buffers.into_iter().filter_map(|buffer| {
3266 this.update(cx, |this, cx| this.save_buffer(buffer, cx))
3267 .ok()
3268 });
3269 try_join_all(save_tasks).await?;
3270 Ok(())
3271 })
3272 }
3273
3274 pub fn save_buffer(&self, buffer: Entity<Buffer>, cx: &mut Context<Self>) -> Task<Result<()>> {
3275 self.buffer_store
3276 .update(cx, |buffer_store, cx| buffer_store.save_buffer(buffer, cx))
3277 }
3278
3279 pub fn save_buffer_as(
3280 &mut self,
3281 buffer: Entity<Buffer>,
3282 path: ProjectPath,
3283 cx: &mut Context<Self>,
3284 ) -> Task<Result<()>> {
3285 self.buffer_store.update(cx, |buffer_store, cx| {
3286 buffer_store.save_buffer_as(buffer.clone(), path, cx)
3287 })
3288 }
3289
3290 pub fn get_open_buffer(&self, path: &ProjectPath, cx: &App) -> Option<Entity<Buffer>> {
3291 self.buffer_store.read(cx).get_by_path(path)
3292 }
3293
3294 fn register_buffer(&mut self, buffer: &Entity<Buffer>, cx: &mut Context<Self>) -> Result<()> {
3295 {
3296 let mut remotely_created_models = self.remotely_created_models.lock();
3297 if remotely_created_models.retain_count > 0 {
3298 remotely_created_models.buffers.push(buffer.clone())
3299 }
3300 }
3301
3302 self.request_buffer_diff_recalculation(buffer, cx);
3303
3304 cx.subscribe(buffer, |this, buffer, event, cx| {
3305 this.on_buffer_event(buffer, event, cx);
3306 })
3307 .detach();
3308
3309 Ok(())
3310 }
3311
3312 pub fn open_image(
3313 &mut self,
3314 path: impl Into<ProjectPath>,
3315 cx: &mut Context<Self>,
3316 ) -> Task<Result<Entity<ImageItem>>> {
3317 if self.is_disconnected(cx) {
3318 return Task::ready(Err(anyhow!(ErrorCode::Disconnected)));
3319 }
3320
3321 let open_image_task = self.image_store.update(cx, |image_store, cx| {
3322 image_store.open_image(path.into(), cx)
3323 });
3324
3325 let weak_project = cx.entity().downgrade();
3326 cx.spawn(async move |_, cx| {
3327 let image_item = open_image_task.await?;
3328
3329 // Check if metadata already exists (e.g., for remote images)
3330 let needs_metadata =
3331 cx.read_entity(&image_item, |item, _| item.image_metadata.is_none());
3332
3333 if needs_metadata {
3334 let project = weak_project.upgrade().context("Project dropped")?;
3335 let metadata =
3336 ImageItem::load_image_metadata(image_item.clone(), project, cx).await?;
3337 image_item.update(cx, |image_item, cx| {
3338 image_item.image_metadata = Some(metadata);
3339 cx.emit(ImageItemEvent::MetadataUpdated);
3340 });
3341 }
3342
3343 Ok(image_item)
3344 })
3345 }
3346
3347 async fn send_buffer_ordered_messages(
3348 project: WeakEntity<Self>,
3349 rx: UnboundedReceiver<BufferOrderedMessage>,
3350 cx: &mut AsyncApp,
3351 ) -> Result<()> {
3352 const MAX_BATCH_SIZE: usize = 128;
3353
3354 let mut operations_by_buffer_id = HashMap::default();
3355 async fn flush_operations(
3356 this: &WeakEntity<Project>,
3357 operations_by_buffer_id: &mut HashMap<BufferId, Vec<proto::Operation>>,
3358 needs_resync_with_host: &mut bool,
3359 is_local: bool,
3360 cx: &mut AsyncApp,
3361 ) -> Result<()> {
3362 for (buffer_id, operations) in operations_by_buffer_id.drain() {
3363 let request = this.read_with(cx, |this, _| {
3364 let project_id = this.remote_id()?;
3365 Some(this.collab_client.request(proto::UpdateBuffer {
3366 buffer_id: buffer_id.into(),
3367 project_id,
3368 operations,
3369 }))
3370 })?;
3371 if let Some(request) = request
3372 && request.await.is_err()
3373 && !is_local
3374 {
3375 *needs_resync_with_host = true;
3376 break;
3377 }
3378 }
3379 Ok(())
3380 }
3381
3382 let mut needs_resync_with_host = false;
3383 let mut changes = rx.ready_chunks(MAX_BATCH_SIZE);
3384
3385 while let Some(changes) = changes.next().await {
3386 let is_local = project.read_with(cx, |this, _| this.is_local())?;
3387
3388 for change in changes {
3389 match change {
3390 BufferOrderedMessage::Operation {
3391 buffer_id,
3392 operation,
3393 } => {
3394 if needs_resync_with_host {
3395 continue;
3396 }
3397
3398 operations_by_buffer_id
3399 .entry(buffer_id)
3400 .or_insert(Vec::new())
3401 .push(operation);
3402 }
3403
3404 BufferOrderedMessage::Resync => {
3405 operations_by_buffer_id.clear();
3406 if project
3407 .update(cx, |this, cx| this.synchronize_remote_buffers(cx))?
3408 .await
3409 .is_ok()
3410 {
3411 needs_resync_with_host = false;
3412 }
3413 }
3414
3415 BufferOrderedMessage::LanguageServerUpdate {
3416 language_server_id,
3417 message,
3418 name,
3419 } => {
3420 flush_operations(
3421 &project,
3422 &mut operations_by_buffer_id,
3423 &mut needs_resync_with_host,
3424 is_local,
3425 cx,
3426 )
3427 .await?;
3428
3429 project.read_with(cx, |project, _| {
3430 if let Some(project_id) = project.remote_id() {
3431 project
3432 .collab_client
3433 .send(proto::UpdateLanguageServer {
3434 project_id,
3435 server_name: name.map(|name| String::from(name.0)),
3436 language_server_id: language_server_id.to_proto(),
3437 variant: Some(message),
3438 })
3439 .log_err();
3440 }
3441 })?;
3442 }
3443 }
3444 }
3445
3446 flush_operations(
3447 &project,
3448 &mut operations_by_buffer_id,
3449 &mut needs_resync_with_host,
3450 is_local,
3451 cx,
3452 )
3453 .await?;
3454 }
3455
3456 Ok(())
3457 }
3458
3459 fn on_buffer_store_event(
3460 &mut self,
3461 _: Entity<BufferStore>,
3462 event: &BufferStoreEvent,
3463 cx: &mut Context<Self>,
3464 ) {
3465 match event {
3466 BufferStoreEvent::BufferAdded(buffer) => {
3467 self.register_buffer(buffer, cx).log_err();
3468 }
3469 BufferStoreEvent::BufferDropped(buffer_id) => {
3470 if let Some(ref remote_client) = self.remote_client {
3471 remote_client
3472 .read(cx)
3473 .proto_client()
3474 .send(proto::CloseBuffer {
3475 project_id: 0,
3476 buffer_id: buffer_id.to_proto(),
3477 })
3478 .log_err();
3479 }
3480 }
3481 _ => {}
3482 }
3483 }
3484
3485 fn on_image_store_event(
3486 &mut self,
3487 _: Entity<ImageStore>,
3488 event: &ImageStoreEvent,
3489 cx: &mut Context<Self>,
3490 ) {
3491 match event {
3492 ImageStoreEvent::ImageAdded(image) => {
3493 cx.subscribe(image, |this, image, event, cx| {
3494 this.on_image_event(image, event, cx);
3495 })
3496 .detach();
3497 }
3498 }
3499 }
3500
3501 fn on_dap_store_event(
3502 &mut self,
3503 _: Entity<DapStore>,
3504 event: &DapStoreEvent,
3505 cx: &mut Context<Self>,
3506 ) {
3507 if let DapStoreEvent::Notification(message) = event {
3508 cx.emit(Event::Toast {
3509 notification_id: "dap".into(),
3510 message: message.clone(),
3511 link: None,
3512 });
3513 }
3514 }
3515
3516 fn on_lsp_store_event(
3517 &mut self,
3518 _: Entity<LspStore>,
3519 event: &LspStoreEvent,
3520 cx: &mut Context<Self>,
3521 ) {
3522 match event {
3523 LspStoreEvent::DiagnosticsUpdated { server_id, paths } => {
3524 cx.emit(Event::DiagnosticsUpdated {
3525 paths: paths.clone(),
3526 language_server_id: *server_id,
3527 })
3528 }
3529 LspStoreEvent::LanguageServerAdded(server_id, name, worktree_id) => cx.emit(
3530 Event::LanguageServerAdded(*server_id, name.clone(), *worktree_id),
3531 ),
3532 LspStoreEvent::LanguageServerRemoved(server_id) => {
3533 cx.emit(Event::LanguageServerRemoved(*server_id))
3534 }
3535 LspStoreEvent::LanguageServerLog(server_id, log_type, string) => cx.emit(
3536 Event::LanguageServerLog(*server_id, log_type.clone(), string.clone()),
3537 ),
3538 LspStoreEvent::LanguageDetected {
3539 buffer,
3540 new_language,
3541 } => {
3542 let Some(_) = new_language else {
3543 cx.emit(Event::LanguageNotFound(buffer.clone()));
3544 return;
3545 };
3546 }
3547 LspStoreEvent::RefreshInlayHints {
3548 server_id,
3549 request_id,
3550 } => cx.emit(Event::RefreshInlayHints {
3551 server_id: *server_id,
3552 request_id: *request_id,
3553 }),
3554 LspStoreEvent::RefreshSemanticTokens {
3555 server_id,
3556 request_id,
3557 } => cx.emit(Event::RefreshSemanticTokens {
3558 server_id: *server_id,
3559 request_id: *request_id,
3560 }),
3561 LspStoreEvent::RefreshCodeLens => cx.emit(Event::RefreshCodeLens),
3562 LspStoreEvent::LanguageServerPrompt(prompt) => {
3563 cx.emit(Event::LanguageServerPrompt(prompt.clone()))
3564 }
3565 LspStoreEvent::DiskBasedDiagnosticsStarted { language_server_id } => {
3566 cx.emit(Event::DiskBasedDiagnosticsStarted {
3567 language_server_id: *language_server_id,
3568 });
3569 }
3570 LspStoreEvent::DiskBasedDiagnosticsFinished { language_server_id } => {
3571 cx.emit(Event::DiskBasedDiagnosticsFinished {
3572 language_server_id: *language_server_id,
3573 });
3574 }
3575 LspStoreEvent::LanguageServerUpdate {
3576 language_server_id,
3577 name,
3578 message,
3579 } => {
3580 if self.is_local() {
3581 self.enqueue_buffer_ordered_message(
3582 BufferOrderedMessage::LanguageServerUpdate {
3583 language_server_id: *language_server_id,
3584 message: message.clone(),
3585 name: name.clone(),
3586 },
3587 )
3588 .ok();
3589 }
3590
3591 match message {
3592 proto::update_language_server::Variant::MetadataUpdated(update) => {
3593 self.lsp_store.update(cx, |lsp_store, _| {
3594 if let Some(capabilities) = update
3595 .capabilities
3596 .as_ref()
3597 .and_then(|capabilities| serde_json::from_str(capabilities).ok())
3598 {
3599 lsp_store
3600 .lsp_server_capabilities
3601 .insert(*language_server_id, capabilities);
3602 }
3603
3604 if let Some(language_server_status) = lsp_store
3605 .language_server_statuses
3606 .get_mut(language_server_id)
3607 {
3608 if let Some(binary) = &update.binary {
3609 language_server_status.binary = Some(LanguageServerBinary {
3610 path: PathBuf::from(&binary.path),
3611 arguments: binary
3612 .arguments
3613 .iter()
3614 .map(OsString::from)
3615 .collect(),
3616 env: None,
3617 });
3618 }
3619
3620 language_server_status.configuration = update
3621 .configuration
3622 .as_ref()
3623 .and_then(|config_str| serde_json::from_str(config_str).ok());
3624
3625 language_server_status.workspace_folders = update
3626 .workspace_folders
3627 .iter()
3628 .filter_map(|uri_str| lsp::Uri::from_str(uri_str).ok())
3629 .collect();
3630 }
3631 });
3632 }
3633 proto::update_language_server::Variant::RegisteredForBuffer(update) => {
3634 if let Some(buffer_id) = BufferId::new(update.buffer_id).ok() {
3635 cx.emit(Event::LanguageServerBufferRegistered {
3636 buffer_id,
3637 server_id: *language_server_id,
3638 buffer_abs_path: PathBuf::from(&update.buffer_abs_path),
3639 name: name.clone(),
3640 });
3641 }
3642 }
3643 _ => (),
3644 }
3645 }
3646 LspStoreEvent::Notification(message) => cx.emit(Event::Toast {
3647 notification_id: "lsp".into(),
3648 message: message.clone(),
3649 link: None,
3650 }),
3651 LspStoreEvent::SnippetEdit {
3652 buffer_id,
3653 edits,
3654 most_recent_edit,
3655 } => {
3656 if most_recent_edit.replica_id == self.replica_id() {
3657 cx.emit(Event::SnippetEdit(*buffer_id, edits.clone()))
3658 }
3659 }
3660 LspStoreEvent::WorkspaceEditApplied(transaction) => {
3661 cx.emit(Event::WorkspaceEditApplied(transaction.clone()))
3662 }
3663 }
3664 }
3665
3666 fn on_remote_client_event(
3667 &mut self,
3668 _: Entity<RemoteClient>,
3669 event: &remote::RemoteClientEvent,
3670 cx: &mut Context<Self>,
3671 ) {
3672 match event {
3673 &remote::RemoteClientEvent::Disconnected { server_not_running } => {
3674 self.worktree_store.update(cx, |store, cx| {
3675 store.disconnected_from_host(cx);
3676 });
3677 self.buffer_store.update(cx, |buffer_store, cx| {
3678 buffer_store.disconnected_from_host(cx)
3679 });
3680 self.lsp_store.update(cx, |lsp_store, _cx| {
3681 lsp_store.disconnected_from_ssh_remote()
3682 });
3683 cx.emit(Event::DisconnectedFromRemote { server_not_running });
3684 }
3685 }
3686 }
3687
3688 fn on_settings_observer_event(
3689 &mut self,
3690 _: Entity<SettingsObserver>,
3691 event: &SettingsObserverEvent,
3692 cx: &mut Context<Self>,
3693 ) {
3694 match event {
3695 SettingsObserverEvent::LocalSettingsUpdated(result) => match result {
3696 Err(InvalidSettingsError::LocalSettings { message, path }) => {
3697 let message = format!("Failed to set local settings in {path:?}:\n{message}");
3698 cx.emit(Event::Toast {
3699 notification_id: format!("local-settings-{path:?}").into(),
3700 link: None,
3701 message,
3702 });
3703 }
3704 Ok(path) => cx.emit(Event::HideToast {
3705 notification_id: format!("local-settings-{path:?}").into(),
3706 }),
3707 Err(_) => {}
3708 },
3709 SettingsObserverEvent::LocalTasksUpdated(result) => match result {
3710 Err(InvalidSettingsError::Tasks { message, path }) => {
3711 let message = format!("Failed to set local tasks in {path:?}:\n{message}");
3712 cx.emit(Event::Toast {
3713 notification_id: format!("local-tasks-{path:?}").into(),
3714 link: Some(ToastLink {
3715 label: "Open Tasks Documentation",
3716 url: "https://zed.dev/docs/tasks",
3717 }),
3718 message,
3719 });
3720 }
3721 Ok(path) => cx.emit(Event::HideToast {
3722 notification_id: format!("local-tasks-{path:?}").into(),
3723 }),
3724 Err(_) => {}
3725 },
3726 SettingsObserverEvent::LocalDebugScenariosUpdated(result) => match result {
3727 Err(InvalidSettingsError::Debug { message, path }) => {
3728 let message =
3729 format!("Failed to set local debug scenarios in {path:?}:\n{message}");
3730 cx.emit(Event::Toast {
3731 notification_id: format!("local-debug-scenarios-{path:?}").into(),
3732 link: None,
3733 message,
3734 });
3735 }
3736 Ok(path) => cx.emit(Event::HideToast {
3737 notification_id: format!("local-debug-scenarios-{path:?}").into(),
3738 }),
3739 Err(_) => {}
3740 },
3741 }
3742 }
3743
3744 fn on_worktree_store_event(
3745 &mut self,
3746 _: Entity<WorktreeStore>,
3747 event: &WorktreeStoreEvent,
3748 cx: &mut Context<Self>,
3749 ) {
3750 match event {
3751 WorktreeStoreEvent::WorktreeAdded(worktree) => {
3752 self.on_worktree_added(worktree, cx);
3753 cx.emit(Event::WorktreeAdded(worktree.read(cx).id()));
3754 self.emit_group_key_changed_if_needed(cx);
3755 }
3756 WorktreeStoreEvent::WorktreeRemoved(_, id) => {
3757 cx.emit(Event::WorktreeRemoved(*id));
3758 self.emit_group_key_changed_if_needed(cx);
3759 }
3760 WorktreeStoreEvent::WorktreeReleased(_, id) => {
3761 self.on_worktree_released(*id, cx);
3762 }
3763 WorktreeStoreEvent::WorktreeOrderChanged => cx.emit(Event::WorktreeOrderChanged),
3764 WorktreeStoreEvent::WorktreeUpdateSent(_) => {}
3765 WorktreeStoreEvent::WorktreeUpdatedEntries(worktree_id, changes) => {
3766 self.client()
3767 .telemetry()
3768 .report_discovered_project_type_events(*worktree_id, changes);
3769 cx.emit(Event::WorktreeUpdatedEntries(*worktree_id, changes.clone()))
3770 }
3771 WorktreeStoreEvent::WorktreeDeletedEntry(worktree_id, id) => {
3772 cx.emit(Event::DeletedEntry(*worktree_id, *id))
3773 }
3774 // Listen to the GitStore instead.
3775 WorktreeStoreEvent::WorktreeUpdatedGitRepositories(_, _) => {}
3776 WorktreeStoreEvent::WorktreeUpdatedRootRepoCommonDir(worktree_id) => {
3777 cx.emit(Event::WorktreeUpdatedRootRepoCommonDir(*worktree_id));
3778 self.emit_group_key_changed_if_needed(cx);
3779 }
3780 }
3781 }
3782
3783 fn on_worktree_added(&mut self, worktree: &Entity<Worktree>, _: &mut Context<Self>) {
3784 let mut remotely_created_models = self.remotely_created_models.lock();
3785 if remotely_created_models.retain_count > 0 {
3786 remotely_created_models.worktrees.push(worktree.clone())
3787 }
3788 }
3789
3790 fn on_worktree_released(&mut self, id_to_remove: WorktreeId, cx: &mut Context<Self>) {
3791 if let Some(remote) = &self.remote_client {
3792 remote
3793 .read(cx)
3794 .proto_client()
3795 .send(proto::RemoveWorktree {
3796 worktree_id: id_to_remove.to_proto(),
3797 })
3798 .log_err();
3799 }
3800 }
3801
3802 fn on_buffer_event(
3803 &mut self,
3804 buffer: Entity<Buffer>,
3805 event: &BufferEvent,
3806 cx: &mut Context<Self>,
3807 ) -> Option<()> {
3808 if matches!(event, BufferEvent::Edited { .. } | BufferEvent::Reloaded) {
3809 self.request_buffer_diff_recalculation(&buffer, cx);
3810 }
3811
3812 if matches!(event, BufferEvent::Edited { .. }) {
3813 cx.emit(Event::BufferEdited);
3814 }
3815
3816 let buffer_id = buffer.read(cx).remote_id();
3817 match event {
3818 BufferEvent::ReloadNeeded => {
3819 if !self.is_via_collab() {
3820 self.reload_buffers([buffer.clone()].into_iter().collect(), true, cx)
3821 .detach_and_log_err(cx);
3822 }
3823 }
3824 BufferEvent::Operation {
3825 operation,
3826 is_local: true,
3827 } => {
3828 let operation = language::proto::serialize_operation(operation);
3829
3830 if let Some(remote) = &self.remote_client {
3831 remote
3832 .read(cx)
3833 .proto_client()
3834 .send(proto::UpdateBuffer {
3835 project_id: 0,
3836 buffer_id: buffer_id.to_proto(),
3837 operations: vec![operation.clone()],
3838 })
3839 .ok();
3840 }
3841
3842 self.enqueue_buffer_ordered_message(BufferOrderedMessage::Operation {
3843 buffer_id,
3844 operation,
3845 })
3846 .ok();
3847 }
3848
3849 _ => {}
3850 }
3851
3852 None
3853 }
3854
3855 fn on_image_event(
3856 &mut self,
3857 image: Entity<ImageItem>,
3858 event: &ImageItemEvent,
3859 cx: &mut Context<Self>,
3860 ) -> Option<()> {
3861 // TODO: handle image events from remote
3862 if let ImageItemEvent::ReloadNeeded = event
3863 && !self.is_via_collab()
3864 {
3865 self.reload_images([image].into_iter().collect(), cx)
3866 .detach_and_log_err(cx);
3867 }
3868
3869 None
3870 }
3871
3872 fn request_buffer_diff_recalculation(
3873 &mut self,
3874 buffer: &Entity<Buffer>,
3875 cx: &mut Context<Self>,
3876 ) {
3877 self.buffers_needing_diff.insert(buffer.downgrade());
3878 let first_insertion = self.buffers_needing_diff.len() == 1;
3879 let settings = ProjectSettings::get_global(cx);
3880 let delay = settings.git.gutter_debounce;
3881
3882 if delay == 0 {
3883 if first_insertion {
3884 let this = cx.weak_entity();
3885 cx.defer(move |cx| {
3886 if let Some(this) = this.upgrade() {
3887 this.update(cx, |this, cx| {
3888 this.recalculate_buffer_diffs(cx).detach();
3889 });
3890 }
3891 });
3892 }
3893 return;
3894 }
3895
3896 const MIN_DELAY: u64 = 50;
3897 let delay = delay.max(MIN_DELAY);
3898 let duration = Duration::from_millis(delay);
3899
3900 self.git_diff_debouncer
3901 .fire_new(duration, cx, move |this, cx| {
3902 this.recalculate_buffer_diffs(cx)
3903 });
3904 }
3905
3906 fn recalculate_buffer_diffs(&mut self, cx: &mut Context<Self>) -> Task<()> {
3907 cx.spawn(async move |this, cx| {
3908 loop {
3909 let task = this
3910 .update(cx, |this, cx| {
3911 let buffers = this
3912 .buffers_needing_diff
3913 .drain()
3914 .filter_map(|buffer| buffer.upgrade())
3915 .collect::<Vec<_>>();
3916 if buffers.is_empty() {
3917 None
3918 } else {
3919 Some(this.git_store.update(cx, |git_store, cx| {
3920 git_store.recalculate_buffer_diffs(buffers, cx)
3921 }))
3922 }
3923 })
3924 .ok()
3925 .flatten();
3926
3927 if let Some(task) = task {
3928 task.await;
3929 } else {
3930 break;
3931 }
3932 }
3933 })
3934 }
3935
3936 pub fn set_language_for_buffer(
3937 &mut self,
3938 buffer: &Entity<Buffer>,
3939 new_language: Arc<Language>,
3940 cx: &mut Context<Self>,
3941 ) {
3942 self.lsp_store.update(cx, |lsp_store, cx| {
3943 lsp_store.set_language_for_buffer(buffer, new_language, cx)
3944 })
3945 }
3946
3947 pub fn restart_language_servers_for_buffers(
3948 &mut self,
3949 buffers: Vec<Entity<Buffer>>,
3950 only_restart_servers: HashSet<LanguageServerSelector>,
3951 cx: &mut Context<Self>,
3952 ) {
3953 self.lsp_store.update(cx, |lsp_store, cx| {
3954 lsp_store.restart_language_servers_for_buffers(buffers, only_restart_servers, cx)
3955 })
3956 }
3957
3958 pub fn stop_language_servers_for_buffers(
3959 &mut self,
3960 buffers: Vec<Entity<Buffer>>,
3961 also_restart_servers: HashSet<LanguageServerSelector>,
3962 cx: &mut Context<Self>,
3963 ) {
3964 self.lsp_store
3965 .update(cx, |lsp_store, cx| {
3966 lsp_store.stop_language_servers_for_buffers(buffers, also_restart_servers, cx)
3967 })
3968 .detach_and_log_err(cx);
3969 }
3970
3971 pub fn cancel_language_server_work_for_buffers(
3972 &mut self,
3973 buffers: impl IntoIterator<Item = Entity<Buffer>>,
3974 cx: &mut Context<Self>,
3975 ) {
3976 self.lsp_store.update(cx, |lsp_store, cx| {
3977 lsp_store.cancel_language_server_work_for_buffers(buffers, cx)
3978 })
3979 }
3980
3981 pub fn cancel_language_server_work(
3982 &mut self,
3983 server_id: LanguageServerId,
3984 token_to_cancel: Option<ProgressToken>,
3985 cx: &mut Context<Self>,
3986 ) {
3987 self.lsp_store.update(cx, |lsp_store, cx| {
3988 lsp_store.cancel_language_server_work(server_id, token_to_cancel, cx)
3989 })
3990 }
3991
3992 fn enqueue_buffer_ordered_message(&mut self, message: BufferOrderedMessage) -> Result<()> {
3993 self.buffer_ordered_messages_tx
3994 .unbounded_send(message)
3995 .map_err(|e| anyhow!(e))
3996 }
3997
3998 pub fn available_toolchains(
3999 &self,
4000 path: ProjectPath,
4001 language_name: LanguageName,
4002 cx: &App,
4003 ) -> Task<Option<Toolchains>> {
4004 if let Some(toolchain_store) = self.toolchain_store.as_ref().map(Entity::downgrade) {
4005 cx.spawn(async move |cx| {
4006 toolchain_store
4007 .update(cx, |this, cx| this.list_toolchains(path, language_name, cx))
4008 .ok()?
4009 .await
4010 })
4011 } else {
4012 Task::ready(None)
4013 }
4014 }
4015
4016 pub async fn toolchain_metadata(
4017 languages: Arc<LanguageRegistry>,
4018 language_name: LanguageName,
4019 ) -> Option<ToolchainMetadata> {
4020 languages
4021 .language_for_name(language_name.as_ref())
4022 .await
4023 .ok()?
4024 .toolchain_lister()
4025 .map(|lister| lister.meta())
4026 }
4027
4028 pub fn add_toolchain(
4029 &self,
4030 toolchain: Toolchain,
4031 scope: ToolchainScope,
4032 cx: &mut Context<Self>,
4033 ) {
4034 maybe!({
4035 self.toolchain_store.as_ref()?.update(cx, |this, cx| {
4036 this.add_toolchain(toolchain, scope, cx);
4037 });
4038 Some(())
4039 });
4040 }
4041
4042 pub fn remove_toolchain(
4043 &self,
4044 toolchain: Toolchain,
4045 scope: ToolchainScope,
4046 cx: &mut Context<Self>,
4047 ) {
4048 maybe!({
4049 self.toolchain_store.as_ref()?.update(cx, |this, cx| {
4050 this.remove_toolchain(toolchain, scope, cx);
4051 });
4052 Some(())
4053 });
4054 }
4055
4056 pub fn user_toolchains(
4057 &self,
4058 cx: &App,
4059 ) -> Option<BTreeMap<ToolchainScope, IndexSet<Toolchain>>> {
4060 Some(self.toolchain_store.as_ref()?.read(cx).user_toolchains())
4061 }
4062
4063 pub fn resolve_toolchain(
4064 &self,
4065 path: PathBuf,
4066 language_name: LanguageName,
4067 cx: &App,
4068 ) -> Task<Result<Toolchain>> {
4069 if let Some(toolchain_store) = self.toolchain_store.as_ref().map(Entity::downgrade) {
4070 cx.spawn(async move |cx| {
4071 toolchain_store
4072 .update(cx, |this, cx| {
4073 this.resolve_toolchain(path, language_name, cx)
4074 })?
4075 .await
4076 })
4077 } else {
4078 Task::ready(Err(anyhow!("This project does not support toolchains")))
4079 }
4080 }
4081
4082 pub fn toolchain_store(&self) -> Option<Entity<ToolchainStore>> {
4083 self.toolchain_store.clone()
4084 }
4085 pub fn activate_toolchain(
4086 &self,
4087 path: ProjectPath,
4088 toolchain: Toolchain,
4089 cx: &mut App,
4090 ) -> Task<Option<()>> {
4091 let Some(toolchain_store) = self.toolchain_store.clone() else {
4092 return Task::ready(None);
4093 };
4094 toolchain_store.update(cx, |this, cx| this.activate_toolchain(path, toolchain, cx))
4095 }
4096 pub fn active_toolchain(
4097 &self,
4098 path: ProjectPath,
4099 language_name: LanguageName,
4100 cx: &App,
4101 ) -> Task<Option<Toolchain>> {
4102 let Some(toolchain_store) = self.toolchain_store.clone() else {
4103 return Task::ready(None);
4104 };
4105 toolchain_store
4106 .read(cx)
4107 .active_toolchain(path, language_name, cx)
4108 }
4109 pub fn language_server_statuses<'a>(
4110 &'a self,
4111 cx: &'a App,
4112 ) -> impl DoubleEndedIterator<Item = (LanguageServerId, &'a LanguageServerStatus)> {
4113 self.lsp_store.read(cx).language_server_statuses()
4114 }
4115
4116 pub fn last_formatting_failure<'a>(&self, cx: &'a App) -> Option<&'a str> {
4117 self.lsp_store.read(cx).last_formatting_failure()
4118 }
4119
4120 pub fn reset_last_formatting_failure(&self, cx: &mut App) {
4121 self.lsp_store
4122 .update(cx, |store, _| store.reset_last_formatting_failure());
4123 }
4124
4125 pub fn reload_buffers(
4126 &self,
4127 buffers: HashSet<Entity<Buffer>>,
4128 push_to_history: bool,
4129 cx: &mut Context<Self>,
4130 ) -> Task<Result<ProjectTransaction>> {
4131 self.buffer_store.update(cx, |buffer_store, cx| {
4132 buffer_store.reload_buffers(buffers, push_to_history, cx)
4133 })
4134 }
4135
4136 pub fn reload_images(
4137 &self,
4138 images: HashSet<Entity<ImageItem>>,
4139 cx: &mut Context<Self>,
4140 ) -> Task<Result<()>> {
4141 self.image_store
4142 .update(cx, |image_store, cx| image_store.reload_images(images, cx))
4143 }
4144
4145 pub fn format(
4146 &mut self,
4147 buffers: HashSet<Entity<Buffer>>,
4148 target: LspFormatTarget,
4149 push_to_history: bool,
4150 trigger: lsp_store::FormatTrigger,
4151 cx: &mut Context<Project>,
4152 ) -> Task<anyhow::Result<ProjectTransaction>> {
4153 self.lsp_store.update(cx, |lsp_store, cx| {
4154 lsp_store.format(buffers, target, push_to_history, trigger, cx)
4155 })
4156 }
4157
4158 pub fn supports_range_formatting(&self, buffer: &Entity<Buffer>, cx: &App) -> bool {
4159 self.lsp_store
4160 .read(cx)
4161 .supports_range_formatting(buffer, cx)
4162 }
4163
4164 pub fn definitions<T: ToPointUtf16>(
4165 &mut self,
4166 buffer: &Entity<Buffer>,
4167 position: T,
4168 cx: &mut Context<Self>,
4169 ) -> Task<Result<Option<Vec<LocationLink>>>> {
4170 let position = position.to_point_utf16(buffer.read(cx));
4171 let guard = self.retain_remotely_created_models(cx);
4172 let task = self.lsp_store.update(cx, |lsp_store, cx| {
4173 lsp_store.definitions(buffer, position, cx)
4174 });
4175 cx.background_spawn(async move {
4176 let result = task.await;
4177 drop(guard);
4178 result
4179 })
4180 }
4181
4182 pub fn declarations<T: ToPointUtf16>(
4183 &mut self,
4184 buffer: &Entity<Buffer>,
4185 position: T,
4186 cx: &mut Context<Self>,
4187 ) -> Task<Result<Option<Vec<LocationLink>>>> {
4188 let position = position.to_point_utf16(buffer.read(cx));
4189 let guard = self.retain_remotely_created_models(cx);
4190 let task = self.lsp_store.update(cx, |lsp_store, cx| {
4191 lsp_store.declarations(buffer, position, cx)
4192 });
4193 cx.background_spawn(async move {
4194 let result = task.await;
4195 drop(guard);
4196 result
4197 })
4198 }
4199
4200 pub fn type_definitions<T: ToPointUtf16>(
4201 &mut self,
4202 buffer: &Entity<Buffer>,
4203 position: T,
4204 cx: &mut Context<Self>,
4205 ) -> Task<Result<Option<Vec<LocationLink>>>> {
4206 let position = position.to_point_utf16(buffer.read(cx));
4207 let guard = self.retain_remotely_created_models(cx);
4208 let task = self.lsp_store.update(cx, |lsp_store, cx| {
4209 lsp_store.type_definitions(buffer, position, cx)
4210 });
4211 cx.background_spawn(async move {
4212 let result = task.await;
4213 drop(guard);
4214 result
4215 })
4216 }
4217
4218 pub fn implementations<T: ToPointUtf16>(
4219 &mut self,
4220 buffer: &Entity<Buffer>,
4221 position: T,
4222 cx: &mut Context<Self>,
4223 ) -> Task<Result<Option<Vec<LocationLink>>>> {
4224 let position = position.to_point_utf16(buffer.read(cx));
4225 let guard = self.retain_remotely_created_models(cx);
4226 let task = self.lsp_store.update(cx, |lsp_store, cx| {
4227 lsp_store.implementations(buffer, position, cx)
4228 });
4229 cx.background_spawn(async move {
4230 let result = task.await;
4231 drop(guard);
4232 result
4233 })
4234 }
4235
4236 pub fn references<T: ToPointUtf16>(
4237 &mut self,
4238 buffer: &Entity<Buffer>,
4239 position: T,
4240 cx: &mut Context<Self>,
4241 ) -> Task<Result<Option<Vec<Location>>>> {
4242 let position = position.to_point_utf16(buffer.read(cx));
4243 let guard = self.retain_remotely_created_models(cx);
4244 let task = self.lsp_store.update(cx, |lsp_store, cx| {
4245 lsp_store.references(buffer, position, cx)
4246 });
4247 cx.background_spawn(async move {
4248 let result = task.await;
4249 drop(guard);
4250 result
4251 })
4252 }
4253
4254 pub fn document_highlights<T: ToPointUtf16>(
4255 &mut self,
4256 buffer: &Entity<Buffer>,
4257 position: T,
4258 cx: &mut Context<Self>,
4259 ) -> Task<Result<Vec<DocumentHighlight>>> {
4260 let position = position.to_point_utf16(buffer.read(cx));
4261 self.request_lsp(
4262 buffer.clone(),
4263 LanguageServerToQuery::FirstCapable,
4264 GetDocumentHighlights { position },
4265 cx,
4266 )
4267 }
4268
4269 pub fn document_symbols(
4270 &mut self,
4271 buffer: &Entity<Buffer>,
4272 cx: &mut Context<Self>,
4273 ) -> Task<Result<Vec<DocumentSymbol>>> {
4274 self.request_lsp(
4275 buffer.clone(),
4276 LanguageServerToQuery::FirstCapable,
4277 GetDocumentSymbols,
4278 cx,
4279 )
4280 }
4281
4282 pub fn symbols(&self, query: &str, cx: &mut Context<Self>) -> Task<Result<Vec<Symbol>>> {
4283 self.lsp_store
4284 .update(cx, |lsp_store, cx| lsp_store.symbols(query, cx))
4285 }
4286
4287 pub fn open_buffer_for_symbol(
4288 &mut self,
4289 symbol: &Symbol,
4290 cx: &mut Context<Self>,
4291 ) -> Task<Result<Entity<Buffer>>> {
4292 self.lsp_store.update(cx, |lsp_store, cx| {
4293 lsp_store.open_buffer_for_symbol(symbol, cx)
4294 })
4295 }
4296
4297 pub fn open_server_settings(&mut self, cx: &mut Context<Self>) -> Task<Result<Entity<Buffer>>> {
4298 let guard = self.retain_remotely_created_models(cx);
4299 let Some(remote) = self.remote_client.as_ref() else {
4300 return Task::ready(Err(anyhow!("not an ssh project")));
4301 };
4302
4303 let proto_client = remote.read(cx).proto_client();
4304
4305 cx.spawn(async move |project, cx| {
4306 let buffer = proto_client
4307 .request(proto::OpenServerSettings {
4308 project_id: REMOTE_SERVER_PROJECT_ID,
4309 })
4310 .await?;
4311
4312 let buffer = project
4313 .update(cx, |project, cx| {
4314 project.buffer_store.update(cx, |buffer_store, cx| {
4315 anyhow::Ok(
4316 buffer_store
4317 .wait_for_remote_buffer(BufferId::new(buffer.buffer_id)?, cx),
4318 )
4319 })
4320 })??
4321 .await;
4322
4323 drop(guard);
4324 buffer
4325 })
4326 }
4327
4328 pub fn open_local_buffer_via_lsp(
4329 &mut self,
4330 abs_path: lsp::Uri,
4331 language_server_id: LanguageServerId,
4332 cx: &mut Context<Self>,
4333 ) -> Task<Result<Entity<Buffer>>> {
4334 self.lsp_store.update(cx, |lsp_store, cx| {
4335 lsp_store.open_local_buffer_via_lsp(abs_path, language_server_id, cx)
4336 })
4337 }
4338
4339 pub fn hover<T: ToPointUtf16>(
4340 &self,
4341 buffer: &Entity<Buffer>,
4342 position: T,
4343 cx: &mut Context<Self>,
4344 ) -> Task<Option<Vec<Hover>>> {
4345 let position = position.to_point_utf16(buffer.read(cx));
4346 self.lsp_store
4347 .update(cx, |lsp_store, cx| lsp_store.hover(buffer, position, cx))
4348 }
4349
4350 pub fn linked_edits(
4351 &self,
4352 buffer: &Entity<Buffer>,
4353 position: Anchor,
4354 cx: &mut Context<Self>,
4355 ) -> Task<Result<Vec<Range<Anchor>>>> {
4356 self.lsp_store.update(cx, |lsp_store, cx| {
4357 lsp_store.linked_edits(buffer, position, cx)
4358 })
4359 }
4360
4361 pub fn completions<T: ToOffset + ToPointUtf16>(
4362 &self,
4363 buffer: &Entity<Buffer>,
4364 position: T,
4365 context: CompletionContext,
4366 cx: &mut Context<Self>,
4367 ) -> Task<Result<Vec<CompletionResponse>>> {
4368 let position = position.to_point_utf16(buffer.read(cx));
4369 self.lsp_store.update(cx, |lsp_store, cx| {
4370 lsp_store.completions(buffer, position, context, cx)
4371 })
4372 }
4373
4374 pub fn code_actions<T: Clone + ToOffset>(
4375 &mut self,
4376 buffer_handle: &Entity<Buffer>,
4377 range: Range<T>,
4378 kinds: Option<Vec<CodeActionKind>>,
4379 cx: &mut Context<Self>,
4380 ) -> Task<Result<Option<Vec<CodeAction>>>> {
4381 let buffer = buffer_handle.read(cx);
4382 let range = buffer.anchor_before(range.start)..buffer.anchor_before(range.end);
4383 self.lsp_store.update(cx, |lsp_store, cx| {
4384 lsp_store.code_actions(buffer_handle, range, kinds, cx)
4385 })
4386 }
4387
4388 pub fn apply_code_action(
4389 &self,
4390 buffer_handle: Entity<Buffer>,
4391 action: CodeAction,
4392 push_to_history: bool,
4393 cx: &mut Context<Self>,
4394 ) -> Task<Result<ProjectTransaction>> {
4395 self.lsp_store.update(cx, |lsp_store, cx| {
4396 lsp_store.apply_code_action(buffer_handle, action, push_to_history, cx)
4397 })
4398 }
4399
4400 pub fn apply_code_action_kind(
4401 &self,
4402 buffers: HashSet<Entity<Buffer>>,
4403 kind: CodeActionKind,
4404 push_to_history: bool,
4405 cx: &mut Context<Self>,
4406 ) -> Task<Result<ProjectTransaction>> {
4407 self.lsp_store.update(cx, |lsp_store, cx| {
4408 lsp_store.apply_code_action_kind(buffers, kind, push_to_history, cx)
4409 })
4410 }
4411
4412 pub fn prepare_rename<T: ToPointUtf16>(
4413 &mut self,
4414 buffer: Entity<Buffer>,
4415 position: T,
4416 cx: &mut Context<Self>,
4417 ) -> Task<Result<PrepareRenameResponse>> {
4418 let position = position.to_point_utf16(buffer.read(cx));
4419 self.request_lsp(
4420 buffer,
4421 LanguageServerToQuery::FirstCapable,
4422 PrepareRename { position },
4423 cx,
4424 )
4425 }
4426
4427 pub fn perform_rename<T: ToPointUtf16>(
4428 &mut self,
4429 buffer: Entity<Buffer>,
4430 position: T,
4431 new_name: String,
4432 cx: &mut Context<Self>,
4433 ) -> Task<Result<ProjectTransaction>> {
4434 let push_to_history = true;
4435 let position = position.to_point_utf16(buffer.read(cx));
4436 self.request_lsp(
4437 buffer,
4438 LanguageServerToQuery::FirstCapable,
4439 PerformRename {
4440 position,
4441 new_name,
4442 push_to_history,
4443 },
4444 cx,
4445 )
4446 }
4447
4448 pub fn on_type_format<T: ToPointUtf16>(
4449 &mut self,
4450 buffer: Entity<Buffer>,
4451 position: T,
4452 trigger: String,
4453 push_to_history: bool,
4454 cx: &mut Context<Self>,
4455 ) -> Task<Result<Option<Transaction>>> {
4456 self.lsp_store.update(cx, |lsp_store, cx| {
4457 lsp_store.on_type_format(buffer, position, trigger, push_to_history, cx)
4458 })
4459 }
4460
4461 pub fn inline_values(
4462 &mut self,
4463 session: Entity<Session>,
4464 active_stack_frame: ActiveStackFrame,
4465 buffer_handle: Entity<Buffer>,
4466 range: Range<text::Anchor>,
4467 cx: &mut Context<Self>,
4468 ) -> Task<anyhow::Result<Vec<InlayHint>>> {
4469 let snapshot = buffer_handle.read(cx).snapshot();
4470
4471 let captures =
4472 snapshot.debug_variables_query(Anchor::min_for_buffer(snapshot.remote_id())..range.end);
4473
4474 let row = snapshot
4475 .summary_for_anchor::<text::PointUtf16>(&range.end)
4476 .row as usize;
4477
4478 let inline_value_locations = provide_inline_values(captures, &snapshot, row);
4479
4480 let stack_frame_id = active_stack_frame.stack_frame_id;
4481 cx.spawn(async move |this, cx| {
4482 this.update(cx, |project, cx| {
4483 project.dap_store().update(cx, |dap_store, cx| {
4484 dap_store.resolve_inline_value_locations(
4485 session,
4486 stack_frame_id,
4487 buffer_handle,
4488 inline_value_locations,
4489 cx,
4490 )
4491 })
4492 })?
4493 .await
4494 })
4495 }
4496
4497 fn search_impl(&mut self, query: SearchQuery, cx: &mut Context<Self>) -> SearchResultsHandle {
4498 let client: Option<(AnyProtoClient, _)> = if let Some(ssh_client) = &self.remote_client {
4499 Some((ssh_client.read(cx).proto_client(), 0))
4500 } else if let Some(remote_id) = self.remote_id() {
4501 self.is_local()
4502 .not()
4503 .then(|| (self.collab_client.clone().into(), remote_id))
4504 } else {
4505 None
4506 };
4507 let searcher = if query.is_opened_only() {
4508 project_search::Search::open_buffers_only(
4509 self.buffer_store.clone(),
4510 self.worktree_store.clone(),
4511 project_search::Search::MAX_SEARCH_RESULT_FILES + 1,
4512 )
4513 } else {
4514 match client {
4515 Some((client, remote_id)) => project_search::Search::remote(
4516 self.buffer_store.clone(),
4517 self.worktree_store.clone(),
4518 project_search::Search::MAX_SEARCH_RESULT_FILES + 1,
4519 (client, remote_id, self.remotely_created_models.clone()),
4520 ),
4521 None => project_search::Search::local(
4522 self.fs.clone(),
4523 self.buffer_store.clone(),
4524 self.worktree_store.clone(),
4525 project_search::Search::MAX_SEARCH_RESULT_FILES + 1,
4526 cx,
4527 ),
4528 }
4529 };
4530 searcher.into_handle(query, cx)
4531 }
4532
4533 pub fn search(
4534 &mut self,
4535 query: SearchQuery,
4536 cx: &mut Context<Self>,
4537 ) -> SearchResults<SearchResult> {
4538 self.search_impl(query, cx).results(cx)
4539 }
4540
4541 pub fn request_lsp<R: LspCommand>(
4542 &mut self,
4543 buffer_handle: Entity<Buffer>,
4544 server: LanguageServerToQuery,
4545 request: R,
4546 cx: &mut Context<Self>,
4547 ) -> Task<Result<R::Response>>
4548 where
4549 <R::LspRequest as lsp::request::Request>::Result: Send,
4550 <R::LspRequest as lsp::request::Request>::Params: Send,
4551 {
4552 let guard = self.retain_remotely_created_models(cx);
4553 let task = self.lsp_store.update(cx, |lsp_store, cx| {
4554 lsp_store.request_lsp(buffer_handle, server, request, cx)
4555 });
4556 cx.background_spawn(async move {
4557 let result = task.await;
4558 drop(guard);
4559 result
4560 })
4561 }
4562
4563 /// Move a worktree to a new position in the worktree order.
4564 ///
4565 /// The worktree will moved to the opposite side of the destination worktree.
4566 ///
4567 /// # Example
4568 ///
4569 /// Given the worktree order `[11, 22, 33]` and a call to move worktree `22` to `33`,
4570 /// worktree_order will be updated to produce the indexes `[11, 33, 22]`.
4571 ///
4572 /// Given the worktree order `[11, 22, 33]` and a call to move worktree `22` to `11`,
4573 /// worktree_order will be updated to produce the indexes `[22, 11, 33]`.
4574 ///
4575 /// # Errors
4576 ///
4577 /// An error will be returned if the worktree or destination worktree are not found.
4578 pub fn move_worktree(
4579 &mut self,
4580 source: WorktreeId,
4581 destination: WorktreeId,
4582 cx: &mut Context<Self>,
4583 ) -> Result<()> {
4584 self.worktree_store.update(cx, |worktree_store, cx| {
4585 worktree_store.move_worktree(source, destination, cx)
4586 })
4587 }
4588
4589 /// Attempts to convert the input path to a WSL path if this is a wsl remote project and the input path is a host windows path.
4590 pub fn try_windows_path_to_wsl(
4591 &self,
4592 abs_path: &Path,
4593 cx: &App,
4594 ) -> impl Future<Output = Result<PathBuf>> + use<> {
4595 let fut = if cfg!(windows)
4596 && let (
4597 ProjectClientState::Local | ProjectClientState::Shared { .. },
4598 Some(remote_client),
4599 ) = (&self.client_state, &self.remote_client)
4600 && let RemoteConnectionOptions::Wsl(wsl) = remote_client.read(cx).connection_options()
4601 {
4602 Either::Left(wsl.abs_windows_path_to_wsl_path(abs_path))
4603 } else {
4604 Either::Right(abs_path.to_owned())
4605 };
4606 async move {
4607 match fut {
4608 Either::Left(fut) => fut.await.map(Into::into),
4609 Either::Right(path) => Ok(path),
4610 }
4611 }
4612 }
4613
4614 pub fn find_or_create_worktree(
4615 &mut self,
4616 abs_path: impl AsRef<Path>,
4617 visible: bool,
4618 cx: &mut Context<Self>,
4619 ) -> Task<Result<(Entity<Worktree>, Arc<RelPath>)>> {
4620 self.worktree_store.update(cx, |worktree_store, cx| {
4621 worktree_store.find_or_create_worktree(abs_path, visible, cx)
4622 })
4623 }
4624
4625 pub fn find_worktree(
4626 &self,
4627 abs_path: &Path,
4628 cx: &App,
4629 ) -> Option<(Entity<Worktree>, Arc<RelPath>)> {
4630 self.worktree_store.read(cx).find_worktree(abs_path, cx)
4631 }
4632
4633 pub fn is_shared(&self) -> bool {
4634 match &self.client_state {
4635 ProjectClientState::Shared { .. } => true,
4636 ProjectClientState::Local => false,
4637 ProjectClientState::Collab { .. } => true,
4638 }
4639 }
4640
4641 /// Returns the resolved version of `path`, that was found in `buffer`, if it exists.
4642 pub fn resolve_path_in_buffer(
4643 &self,
4644 path: &str,
4645 buffer: &Entity<Buffer>,
4646 cx: &mut Context<Self>,
4647 ) -> Task<Option<ResolvedPath>> {
4648 if util::paths::is_absolute(path, self.path_style(cx)) || path.starts_with("~") {
4649 self.resolve_abs_path(path, cx)
4650 } else {
4651 self.resolve_path_in_worktrees(path, buffer, cx)
4652 }
4653 }
4654
4655 pub fn resolve_abs_file_path(
4656 &self,
4657 path: &str,
4658 cx: &mut Context<Self>,
4659 ) -> Task<Option<ResolvedPath>> {
4660 let resolve_task = self.resolve_abs_path(path, cx);
4661 cx.background_spawn(async move {
4662 let resolved_path = resolve_task.await;
4663 resolved_path.filter(|path| path.is_file())
4664 })
4665 }
4666
4667 pub fn resolve_abs_path(&self, path: &str, cx: &App) -> Task<Option<ResolvedPath>> {
4668 if self.is_local() {
4669 let expanded = PathBuf::from(shellexpand::tilde(&path).into_owned());
4670 let fs = self.fs.clone();
4671 cx.background_spawn(async move {
4672 let metadata = fs.metadata(&expanded).await.ok().flatten();
4673
4674 metadata.map(|metadata| ResolvedPath::AbsPath {
4675 path: expanded.to_string_lossy().into_owned(),
4676 is_dir: metadata.is_dir,
4677 })
4678 })
4679 } else if let Some(ssh_client) = self.remote_client.as_ref() {
4680 let request = ssh_client
4681 .read(cx)
4682 .proto_client()
4683 .request(proto::GetPathMetadata {
4684 project_id: REMOTE_SERVER_PROJECT_ID,
4685 path: path.into(),
4686 });
4687 cx.background_spawn(async move {
4688 let response = request.await.log_err()?;
4689 if response.exists {
4690 Some(ResolvedPath::AbsPath {
4691 path: response.path,
4692 is_dir: response.is_dir,
4693 })
4694 } else {
4695 None
4696 }
4697 })
4698 } else {
4699 Task::ready(None)
4700 }
4701 }
4702
4703 fn resolve_path_in_worktrees(
4704 &self,
4705 path: &str,
4706 buffer: &Entity<Buffer>,
4707 cx: &mut Context<Self>,
4708 ) -> Task<Option<ResolvedPath>> {
4709 let mut candidates = vec![];
4710 let path_style = self.path_style(cx);
4711 if let Ok(path) = RelPath::new(path.as_ref(), path_style) {
4712 candidates.push(path.into_arc());
4713 }
4714
4715 if let Some(file) = buffer.read(cx).file()
4716 && let Some(dir) = file.path().parent()
4717 {
4718 if let Some(joined) = path_style.join(&*dir.display(path_style), path)
4719 && let Some(joined) = RelPath::new(joined.as_ref(), path_style).ok()
4720 {
4721 candidates.push(joined.into_arc());
4722 }
4723 }
4724
4725 let buffer_worktree_id = buffer.read(cx).file().map(|file| file.worktree_id(cx));
4726 let worktrees_with_ids: Vec<_> = self
4727 .worktrees(cx)
4728 .map(|worktree| {
4729 let id = worktree.read(cx).id();
4730 (worktree, id)
4731 })
4732 .collect();
4733
4734 cx.spawn(async move |_, cx| {
4735 if let Some(buffer_worktree_id) = buffer_worktree_id
4736 && let Some((worktree, _)) = worktrees_with_ids
4737 .iter()
4738 .find(|(_, id)| *id == buffer_worktree_id)
4739 {
4740 for candidate in candidates.iter() {
4741 if let Some(path) = Self::resolve_path_in_worktree(worktree, candidate, cx) {
4742 return Some(path);
4743 }
4744 }
4745 }
4746 for (worktree, id) in worktrees_with_ids {
4747 if Some(id) == buffer_worktree_id {
4748 continue;
4749 }
4750 for candidate in candidates.iter() {
4751 if let Some(path) = Self::resolve_path_in_worktree(&worktree, candidate, cx) {
4752 return Some(path);
4753 }
4754 }
4755 }
4756 None
4757 })
4758 }
4759
4760 fn resolve_path_in_worktree(
4761 worktree: &Entity<Worktree>,
4762 path: &RelPath,
4763 cx: &mut AsyncApp,
4764 ) -> Option<ResolvedPath> {
4765 worktree.read_with(cx, |worktree, _| {
4766 worktree.entry_for_path(path).map(|entry| {
4767 let project_path = ProjectPath {
4768 worktree_id: worktree.id(),
4769 path: entry.path.clone(),
4770 };
4771 ResolvedPath::ProjectPath {
4772 project_path,
4773 is_dir: entry.is_dir(),
4774 }
4775 })
4776 })
4777 }
4778
4779 pub fn list_directory(
4780 &self,
4781 query: String,
4782 cx: &mut Context<Self>,
4783 ) -> Task<Result<Vec<DirectoryItem>>> {
4784 if self.is_local() {
4785 DirectoryLister::Local(cx.entity(), self.fs.clone()).list_directory(query, cx)
4786 } else if let Some(session) = self.remote_client.as_ref() {
4787 let request = proto::ListRemoteDirectory {
4788 dev_server_id: REMOTE_SERVER_PROJECT_ID,
4789 path: query,
4790 config: Some(proto::ListRemoteDirectoryConfig { is_dir: true }),
4791 };
4792
4793 let response = session.read(cx).proto_client().request(request);
4794 cx.background_spawn(async move {
4795 let proto::ListRemoteDirectoryResponse {
4796 entries,
4797 entry_info,
4798 } = response.await?;
4799 Ok(entries
4800 .into_iter()
4801 .zip(entry_info)
4802 .map(|(entry, info)| DirectoryItem {
4803 path: PathBuf::from(entry),
4804 is_dir: info.is_dir,
4805 })
4806 .collect())
4807 })
4808 } else {
4809 Task::ready(Err(anyhow!("cannot list directory in remote project")))
4810 }
4811 }
4812
4813 pub fn create_worktree(
4814 &mut self,
4815 abs_path: impl AsRef<Path>,
4816 visible: bool,
4817 cx: &mut Context<Self>,
4818 ) -> Task<Result<Entity<Worktree>>> {
4819 self.worktree_store.update(cx, |worktree_store, cx| {
4820 worktree_store.create_worktree(abs_path, visible, cx)
4821 })
4822 }
4823
4824 /// Returns a task that resolves when the given worktree's `Entity` is
4825 /// fully dropped (all strong references released), not merely when
4826 /// `remove_worktree` is called. `remove_worktree` drops the store's
4827 /// reference and emits `WorktreeRemoved`, but other code may still
4828 /// hold a strong handle — the worktree isn't safe to delete from
4829 /// disk until every handle is gone.
4830 ///
4831 /// We use `observe_release` on the specific entity rather than
4832 /// listening for `WorktreeReleased` events because it's simpler at
4833 /// the call site (one awaitable task, no subscription / channel /
4834 /// ID filtering).
4835 pub fn wait_for_worktree_release(
4836 &mut self,
4837 worktree_id: WorktreeId,
4838 cx: &mut Context<Self>,
4839 ) -> Task<Result<()>> {
4840 let Some(worktree) = self.worktree_for_id(worktree_id, cx) else {
4841 return Task::ready(Ok(()));
4842 };
4843
4844 let (released_tx, released_rx) = futures::channel::oneshot::channel();
4845 let released_tx = std::sync::Arc::new(Mutex::new(Some(released_tx)));
4846 let release_subscription =
4847 cx.observe_release(&worktree, move |_project, _released_worktree, _cx| {
4848 if let Some(released_tx) = released_tx.lock().take() {
4849 let _ = released_tx.send(());
4850 }
4851 });
4852
4853 cx.spawn(async move |_project, _cx| {
4854 let _release_subscription = release_subscription;
4855 released_rx
4856 .await
4857 .map_err(|_| anyhow!("worktree release observer dropped before release"))?;
4858 Ok(())
4859 })
4860 }
4861
4862 pub fn remove_worktree(&mut self, id_to_remove: WorktreeId, cx: &mut Context<Self>) {
4863 self.worktree_store.update(cx, |worktree_store, cx| {
4864 worktree_store.remove_worktree(id_to_remove, cx);
4865 });
4866 }
4867
4868 pub fn remove_worktree_for_main_worktree_path(
4869 &mut self,
4870 path: impl AsRef<Path>,
4871 cx: &mut Context<Self>,
4872 ) {
4873 let path = path.as_ref();
4874 self.worktree_store.update(cx, |worktree_store, cx| {
4875 if let Some(worktree) = worktree_store.worktree_for_main_worktree_path(path, cx) {
4876 worktree_store.remove_worktree(worktree.read(cx).id(), cx);
4877 }
4878 });
4879 }
4880
4881 fn add_worktree(&mut self, worktree: &Entity<Worktree>, cx: &mut Context<Self>) {
4882 self.worktree_store.update(cx, |worktree_store, cx| {
4883 worktree_store.add(worktree, cx);
4884 });
4885 }
4886
4887 pub fn set_active_path(&mut self, entry: Option<ProjectPath>, cx: &mut Context<Self>) {
4888 let new_active_entry = entry.and_then(|project_path| {
4889 let worktree = self.worktree_for_id(project_path.worktree_id, cx)?;
4890 let entry = worktree.read(cx).entry_for_path(&project_path.path)?;
4891 Some(entry.id)
4892 });
4893 if new_active_entry != self.active_entry {
4894 self.active_entry = new_active_entry;
4895 self.lsp_store.update(cx, |lsp_store, _| {
4896 lsp_store.set_active_entry(new_active_entry);
4897 });
4898 cx.emit(Event::ActiveEntryChanged(new_active_entry));
4899 }
4900 }
4901
4902 pub fn language_servers_running_disk_based_diagnostics<'a>(
4903 &'a self,
4904 cx: &'a App,
4905 ) -> impl Iterator<Item = LanguageServerId> + 'a {
4906 self.lsp_store
4907 .read(cx)
4908 .language_servers_running_disk_based_diagnostics()
4909 }
4910
4911 pub fn diagnostic_summary(&self, include_ignored: bool, cx: &App) -> DiagnosticSummary {
4912 self.lsp_store
4913 .read(cx)
4914 .diagnostic_summary(include_ignored, cx)
4915 }
4916
4917 /// Returns a summary of the diagnostics for the provided project path only.
4918 pub fn diagnostic_summary_for_path(&self, path: &ProjectPath, cx: &App) -> DiagnosticSummary {
4919 self.lsp_store
4920 .read(cx)
4921 .diagnostic_summary_for_path(path, cx)
4922 }
4923
4924 pub fn diagnostic_summaries<'a>(
4925 &'a self,
4926 include_ignored: bool,
4927 cx: &'a App,
4928 ) -> impl Iterator<Item = (ProjectPath, LanguageServerId, DiagnosticSummary)> + 'a {
4929 self.lsp_store
4930 .read(cx)
4931 .diagnostic_summaries(include_ignored, cx)
4932 }
4933
4934 pub fn active_entry(&self) -> Option<ProjectEntryId> {
4935 self.active_entry
4936 }
4937
4938 pub fn entry_for_path<'a>(&'a self, path: &ProjectPath, cx: &'a App) -> Option<&'a Entry> {
4939 self.worktree_store.read(cx).entry_for_path(path, cx)
4940 }
4941
4942 pub fn path_for_entry(&self, entry_id: ProjectEntryId, cx: &App) -> Option<ProjectPath> {
4943 let worktree = self.worktree_for_entry(entry_id, cx)?;
4944 let worktree = worktree.read(cx);
4945 let worktree_id = worktree.id();
4946 let path = worktree.entry_for_id(entry_id)?.path.clone();
4947 Some(ProjectPath { worktree_id, path })
4948 }
4949
4950 pub fn absolute_path(&self, project_path: &ProjectPath, cx: &App) -> Option<PathBuf> {
4951 Some(
4952 self.worktree_for_id(project_path.worktree_id, cx)?
4953 .read(cx)
4954 .absolutize(&project_path.path),
4955 )
4956 }
4957
4958 /// Attempts to find a `ProjectPath` corresponding to the given path. If the path
4959 /// is a *full path*, meaning it starts with the root name of a worktree, we'll locate
4960 /// it in that worktree. Otherwise, we'll attempt to find it as a relative path in
4961 /// the first visible worktree that has an entry for that relative path.
4962 ///
4963 /// We use this to resolve edit steps, when there's a chance an LLM may omit the workree
4964 /// root name from paths.
4965 ///
4966 /// # Arguments
4967 ///
4968 /// * `path` - An absolute path, or a full path that starts with a worktree root name, or a
4969 /// relative path within a visible worktree.
4970 /// * `cx` - A reference to the `AppContext`.
4971 ///
4972 /// # Returns
4973 ///
4974 /// Returns `Some(ProjectPath)` if a matching worktree is found, otherwise `None`.
4975 pub fn find_project_path(&self, path: impl AsRef<Path>, cx: &App) -> Option<ProjectPath> {
4976 let path_style = self.path_style(cx);
4977 let path = path.as_ref();
4978 let worktree_store = self.worktree_store.read(cx);
4979
4980 if is_absolute(&path.to_string_lossy(), path_style) {
4981 for worktree in worktree_store.visible_worktrees(cx) {
4982 let worktree_abs_path = worktree.read(cx).abs_path();
4983
4984 if let Ok(relative_path) = path.strip_prefix(worktree_abs_path)
4985 && let Ok(path) = RelPath::new(relative_path, path_style)
4986 {
4987 return Some(ProjectPath {
4988 worktree_id: worktree.read(cx).id(),
4989 path: path.into_arc(),
4990 });
4991 }
4992 }
4993 } else {
4994 for worktree in worktree_store.visible_worktrees(cx) {
4995 let worktree = worktree.read(cx);
4996 if let Ok(rel_path) = RelPath::new(path, path_style) {
4997 if let Some(entry) = worktree.entry_for_path(&rel_path) {
4998 return Some(ProjectPath {
4999 worktree_id: worktree.id(),
5000 path: entry.path.clone(),
5001 });
5002 }
5003 }
5004 }
5005
5006 for worktree in worktree_store.visible_worktrees(cx) {
5007 let worktree_root_name = worktree.read(cx).root_name();
5008 if let Ok(relative_path) = path.strip_prefix(worktree_root_name.as_std_path())
5009 && let Ok(path) = RelPath::new(relative_path, path_style)
5010 {
5011 return Some(ProjectPath {
5012 worktree_id: worktree.read(cx).id(),
5013 path: path.into_arc(),
5014 });
5015 }
5016 }
5017 }
5018
5019 None
5020 }
5021
5022 /// If there's only one visible worktree, returns the given worktree-relative path with no prefix.
5023 ///
5024 /// Otherwise, returns the full path for the project path (obtained by prefixing the worktree-relative path with the name of the worktree).
5025 pub fn short_full_path_for_project_path(
5026 &self,
5027 project_path: &ProjectPath,
5028 cx: &App,
5029 ) -> Option<String> {
5030 let path_style = self.path_style(cx);
5031 if self.visible_worktrees(cx).take(2).count() < 2 {
5032 return Some(project_path.path.display(path_style).to_string());
5033 }
5034 self.worktree_for_id(project_path.worktree_id, cx)
5035 .map(|worktree| {
5036 let worktree_name = worktree.read(cx).root_name();
5037 worktree_name
5038 .join(&project_path.path)
5039 .display(path_style)
5040 .to_string()
5041 })
5042 }
5043
5044 pub fn project_path_for_absolute_path(&self, abs_path: &Path, cx: &App) -> Option<ProjectPath> {
5045 self.worktree_store
5046 .read(cx)
5047 .project_path_for_absolute_path(abs_path, cx)
5048 }
5049
5050 pub fn get_workspace_root(&self, project_path: &ProjectPath, cx: &App) -> Option<PathBuf> {
5051 Some(
5052 self.worktree_for_id(project_path.worktree_id, cx)?
5053 .read(cx)
5054 .abs_path()
5055 .to_path_buf(),
5056 )
5057 }
5058
5059 pub fn blame_buffer(
5060 &self,
5061 buffer: &Entity<Buffer>,
5062 version: Option<clock::Global>,
5063 cx: &mut App,
5064 ) -> Task<Result<Option<Blame>>> {
5065 self.git_store.update(cx, |git_store, cx| {
5066 git_store.blame_buffer(buffer, version, cx)
5067 })
5068 }
5069
5070 pub fn get_permalink_to_line(
5071 &self,
5072 buffer: &Entity<Buffer>,
5073 selection: Range<u32>,
5074 cx: &mut App,
5075 ) -> Task<Result<url::Url>> {
5076 self.git_store.update(cx, |git_store, cx| {
5077 git_store.get_permalink_to_line(buffer, selection, cx)
5078 })
5079 }
5080
5081 // RPC message handlers
5082
5083 async fn handle_unshare_project(
5084 this: Entity<Self>,
5085 _: TypedEnvelope<proto::UnshareProject>,
5086 mut cx: AsyncApp,
5087 ) -> Result<()> {
5088 this.update(&mut cx, |this, cx| {
5089 if this.is_local() || this.is_via_remote_server() {
5090 this.unshare(cx)?;
5091 } else {
5092 this.disconnected_from_host(cx);
5093 }
5094 Ok(())
5095 })
5096 }
5097
5098 async fn handle_add_collaborator(
5099 this: Entity<Self>,
5100 mut envelope: TypedEnvelope<proto::AddProjectCollaborator>,
5101 mut cx: AsyncApp,
5102 ) -> Result<()> {
5103 let collaborator = envelope
5104 .payload
5105 .collaborator
5106 .take()
5107 .context("empty collaborator")?;
5108
5109 let collaborator = Collaborator::from_proto(collaborator)?;
5110 this.update(&mut cx, |this, cx| {
5111 this.buffer_store.update(cx, |buffer_store, _| {
5112 buffer_store.forget_shared_buffers_for(&collaborator.peer_id);
5113 });
5114 this.breakpoint_store.read(cx).broadcast();
5115 cx.emit(Event::CollaboratorJoined(collaborator.peer_id));
5116 this.collaborators
5117 .insert(collaborator.peer_id, collaborator);
5118 });
5119
5120 Ok(())
5121 }
5122
5123 async fn handle_update_project_collaborator(
5124 this: Entity<Self>,
5125 envelope: TypedEnvelope<proto::UpdateProjectCollaborator>,
5126 mut cx: AsyncApp,
5127 ) -> Result<()> {
5128 let old_peer_id = envelope
5129 .payload
5130 .old_peer_id
5131 .context("missing old peer id")?;
5132 let new_peer_id = envelope
5133 .payload
5134 .new_peer_id
5135 .context("missing new peer id")?;
5136 this.update(&mut cx, |this, cx| {
5137 let collaborator = this
5138 .collaborators
5139 .remove(&old_peer_id)
5140 .context("received UpdateProjectCollaborator for unknown peer")?;
5141 let is_host = collaborator.is_host;
5142 this.collaborators.insert(new_peer_id, collaborator);
5143
5144 log::info!("peer {} became {}", old_peer_id, new_peer_id,);
5145 this.buffer_store.update(cx, |buffer_store, _| {
5146 buffer_store.update_peer_id(&old_peer_id, new_peer_id)
5147 });
5148
5149 if is_host {
5150 this.buffer_store
5151 .update(cx, |buffer_store, _| buffer_store.discard_incomplete());
5152 this.enqueue_buffer_ordered_message(BufferOrderedMessage::Resync)
5153 .unwrap();
5154 cx.emit(Event::HostReshared);
5155 }
5156
5157 cx.emit(Event::CollaboratorUpdated {
5158 old_peer_id,
5159 new_peer_id,
5160 });
5161 Ok(())
5162 })
5163 }
5164
5165 async fn handle_remove_collaborator(
5166 this: Entity<Self>,
5167 envelope: TypedEnvelope<proto::RemoveProjectCollaborator>,
5168 mut cx: AsyncApp,
5169 ) -> Result<()> {
5170 this.update(&mut cx, |this, cx| {
5171 let peer_id = envelope.payload.peer_id.context("invalid peer id")?;
5172 let replica_id = this
5173 .collaborators
5174 .remove(&peer_id)
5175 .with_context(|| format!("unknown peer {peer_id:?}"))?
5176 .replica_id;
5177 this.buffer_store.update(cx, |buffer_store, cx| {
5178 buffer_store.forget_shared_buffers_for(&peer_id);
5179 for buffer in buffer_store.buffers() {
5180 buffer.update(cx, |buffer, cx| buffer.remove_peer(replica_id, cx));
5181 }
5182 });
5183 this.git_store.update(cx, |git_store, _| {
5184 git_store.forget_shared_diffs_for(&peer_id);
5185 });
5186
5187 cx.emit(Event::CollaboratorLeft(peer_id));
5188 Ok(())
5189 })
5190 }
5191
5192 async fn handle_update_project(
5193 this: Entity<Self>,
5194 envelope: TypedEnvelope<proto::UpdateProject>,
5195 mut cx: AsyncApp,
5196 ) -> Result<()> {
5197 this.update(&mut cx, |this, cx| {
5198 // Don't handle messages that were sent before the response to us joining the project
5199 if envelope.message_id > this.join_project_response_message_id {
5200 cx.update_global::<SettingsStore, _>(|store, cx| {
5201 for worktree_metadata in &envelope.payload.worktrees {
5202 store
5203 .clear_local_settings(WorktreeId::from_proto(worktree_metadata.id), cx)
5204 .log_err();
5205 }
5206 });
5207
5208 this.set_worktrees_from_proto(envelope.payload.worktrees, cx)?;
5209 }
5210 Ok(())
5211 })
5212 }
5213
5214 async fn handle_toast(
5215 this: Entity<Self>,
5216 envelope: TypedEnvelope<proto::Toast>,
5217 mut cx: AsyncApp,
5218 ) -> Result<()> {
5219 this.update(&mut cx, |_, cx| {
5220 cx.emit(Event::Toast {
5221 notification_id: envelope.payload.notification_id.into(),
5222 message: envelope.payload.message,
5223 link: None,
5224 });
5225 Ok(())
5226 })
5227 }
5228
5229 async fn handle_language_server_prompt_request(
5230 this: Entity<Self>,
5231 envelope: TypedEnvelope<proto::LanguageServerPromptRequest>,
5232 mut cx: AsyncApp,
5233 ) -> Result<proto::LanguageServerPromptResponse> {
5234 let (tx, rx) = smol::channel::bounded(1);
5235 let actions: Vec<_> = envelope
5236 .payload
5237 .actions
5238 .into_iter()
5239 .map(|action| MessageActionItem {
5240 title: action,
5241 properties: Default::default(),
5242 })
5243 .collect();
5244 this.update(&mut cx, |_, cx| {
5245 cx.emit(Event::LanguageServerPrompt(
5246 LanguageServerPromptRequest::new(
5247 proto_to_prompt(envelope.payload.level.context("Invalid prompt level")?),
5248 envelope.payload.message,
5249 actions.clone(),
5250 envelope.payload.lsp_name,
5251 tx,
5252 ),
5253 ));
5254
5255 anyhow::Ok(())
5256 })?;
5257
5258 // We drop `this` to avoid holding a reference in this future for too
5259 // long.
5260 // If we keep the reference, we might not drop the `Project` early
5261 // enough when closing a window and it will only get releases on the
5262 // next `flush_effects()` call.
5263 drop(this);
5264
5265 let mut rx = pin!(rx);
5266 let answer = rx.next().await;
5267
5268 Ok(LanguageServerPromptResponse {
5269 action_response: answer.and_then(|answer| {
5270 actions
5271 .iter()
5272 .position(|action| *action == answer)
5273 .map(|index| index as u64)
5274 }),
5275 })
5276 }
5277
5278 async fn handle_hide_toast(
5279 this: Entity<Self>,
5280 envelope: TypedEnvelope<proto::HideToast>,
5281 mut cx: AsyncApp,
5282 ) -> Result<()> {
5283 this.update(&mut cx, |_, cx| {
5284 cx.emit(Event::HideToast {
5285 notification_id: envelope.payload.notification_id.into(),
5286 });
5287 Ok(())
5288 })
5289 }
5290
5291 // Collab sends UpdateWorktree protos as messages
5292 async fn handle_update_worktree(
5293 this: Entity<Self>,
5294 envelope: TypedEnvelope<proto::UpdateWorktree>,
5295 mut cx: AsyncApp,
5296 ) -> Result<()> {
5297 this.update(&mut cx, |project, cx| {
5298 let worktree_id = WorktreeId::from_proto(envelope.payload.worktree_id);
5299 if let Some(worktree) = project.worktree_for_id(worktree_id, cx) {
5300 worktree.update(cx, |worktree, _| {
5301 let worktree = worktree.as_remote_mut().unwrap();
5302 worktree.update_from_remote(envelope.payload);
5303 });
5304 }
5305 Ok(())
5306 })
5307 }
5308
5309 async fn handle_update_buffer_from_remote_server(
5310 this: Entity<Self>,
5311 envelope: TypedEnvelope<proto::UpdateBuffer>,
5312 cx: AsyncApp,
5313 ) -> Result<proto::Ack> {
5314 let buffer_store = this.read_with(&cx, |this, cx| {
5315 if let Some(remote_id) = this.remote_id() {
5316 let mut payload = envelope.payload.clone();
5317 payload.project_id = remote_id;
5318 cx.background_spawn(this.collab_client.request(payload))
5319 .detach_and_log_err(cx);
5320 }
5321 this.buffer_store.clone()
5322 });
5323 BufferStore::handle_update_buffer(buffer_store, envelope, cx).await
5324 }
5325
5326 async fn handle_trust_worktrees(
5327 this: Entity<Self>,
5328 envelope: TypedEnvelope<proto::TrustWorktrees>,
5329 mut cx: AsyncApp,
5330 ) -> Result<proto::Ack> {
5331 if this.read_with(&cx, |project, _| project.is_via_collab()) {
5332 return Ok(proto::Ack {});
5333 }
5334
5335 let trusted_worktrees = cx
5336 .update(|cx| TrustedWorktrees::try_get_global(cx))
5337 .context("missing trusted worktrees")?;
5338 trusted_worktrees.update(&mut cx, |trusted_worktrees, cx| {
5339 trusted_worktrees.trust(
5340 &this.read(cx).worktree_store(),
5341 envelope
5342 .payload
5343 .trusted_paths
5344 .into_iter()
5345 .filter_map(|proto_path| PathTrust::from_proto(proto_path))
5346 .collect(),
5347 cx,
5348 );
5349 });
5350 Ok(proto::Ack {})
5351 }
5352
5353 async fn handle_restrict_worktrees(
5354 this: Entity<Self>,
5355 envelope: TypedEnvelope<proto::RestrictWorktrees>,
5356 mut cx: AsyncApp,
5357 ) -> Result<proto::Ack> {
5358 if this.read_with(&cx, |project, _| project.is_via_collab()) {
5359 return Ok(proto::Ack {});
5360 }
5361
5362 let trusted_worktrees = cx
5363 .update(|cx| TrustedWorktrees::try_get_global(cx))
5364 .context("missing trusted worktrees")?;
5365 trusted_worktrees.update(&mut cx, |trusted_worktrees, cx| {
5366 let worktree_store = this.read(cx).worktree_store().downgrade();
5367 let restricted_paths = envelope
5368 .payload
5369 .worktree_ids
5370 .into_iter()
5371 .map(WorktreeId::from_proto)
5372 .map(PathTrust::Worktree)
5373 .collect::<HashSet<_>>();
5374 trusted_worktrees.restrict(worktree_store, restricted_paths, cx);
5375 });
5376 Ok(proto::Ack {})
5377 }
5378
5379 // Goes from host to client.
5380 async fn handle_find_search_candidates_chunk(
5381 this: Entity<Self>,
5382 envelope: TypedEnvelope<proto::FindSearchCandidatesChunk>,
5383 mut cx: AsyncApp,
5384 ) -> Result<proto::Ack> {
5385 let buffer_store = this.read_with(&mut cx, |this, _| this.buffer_store.clone());
5386 BufferStore::handle_find_search_candidates_chunk(buffer_store, envelope, cx).await
5387 }
5388
5389 // Goes from client to host.
5390 async fn handle_find_search_candidates_cancel(
5391 this: Entity<Self>,
5392 envelope: TypedEnvelope<proto::FindSearchCandidatesCancelled>,
5393 mut cx: AsyncApp,
5394 ) -> Result<()> {
5395 let buffer_store = this.read_with(&mut cx, |this, _| this.buffer_store.clone());
5396 BufferStore::handle_find_search_candidates_cancel(buffer_store, envelope, cx).await
5397 }
5398
5399 async fn handle_update_buffer(
5400 this: Entity<Self>,
5401 envelope: TypedEnvelope<proto::UpdateBuffer>,
5402 cx: AsyncApp,
5403 ) -> Result<proto::Ack> {
5404 let buffer_store = this.read_with(&cx, |this, cx| {
5405 if let Some(ssh) = &this.remote_client {
5406 let mut payload = envelope.payload.clone();
5407 payload.project_id = REMOTE_SERVER_PROJECT_ID;
5408 cx.background_spawn(ssh.read(cx).proto_client().request(payload))
5409 .detach_and_log_err(cx);
5410 }
5411 this.buffer_store.clone()
5412 });
5413 BufferStore::handle_update_buffer(buffer_store, envelope, cx).await
5414 }
5415
5416 fn retain_remotely_created_models(
5417 &mut self,
5418 cx: &mut Context<Self>,
5419 ) -> RemotelyCreatedModelGuard {
5420 Self::retain_remotely_created_models_impl(
5421 &self.remotely_created_models,
5422 &self.buffer_store,
5423 &self.worktree_store,
5424 cx,
5425 )
5426 }
5427
5428 fn retain_remotely_created_models_impl(
5429 models: &Arc<Mutex<RemotelyCreatedModels>>,
5430 buffer_store: &Entity<BufferStore>,
5431 worktree_store: &Entity<WorktreeStore>,
5432 cx: &mut App,
5433 ) -> RemotelyCreatedModelGuard {
5434 {
5435 let mut remotely_create_models = models.lock();
5436 if remotely_create_models.retain_count == 0 {
5437 remotely_create_models.buffers = buffer_store.read(cx).buffers().collect();
5438 remotely_create_models.worktrees = worktree_store.read(cx).worktrees().collect();
5439 }
5440 remotely_create_models.retain_count += 1;
5441 }
5442 RemotelyCreatedModelGuard {
5443 remote_models: Arc::downgrade(&models),
5444 }
5445 }
5446
5447 async fn handle_create_buffer_for_peer(
5448 this: Entity<Self>,
5449 envelope: TypedEnvelope<proto::CreateBufferForPeer>,
5450 mut cx: AsyncApp,
5451 ) -> Result<()> {
5452 this.update(&mut cx, |this, cx| {
5453 this.buffer_store.update(cx, |buffer_store, cx| {
5454 buffer_store.handle_create_buffer_for_peer(
5455 envelope,
5456 this.replica_id(),
5457 this.capability(),
5458 cx,
5459 )
5460 })
5461 })
5462 }
5463
5464 async fn handle_toggle_lsp_logs(
5465 project: Entity<Self>,
5466 envelope: TypedEnvelope<proto::ToggleLspLogs>,
5467 mut cx: AsyncApp,
5468 ) -> Result<()> {
5469 let toggled_log_kind =
5470 match proto::toggle_lsp_logs::LogType::from_i32(envelope.payload.log_type)
5471 .context("invalid log type")?
5472 {
5473 proto::toggle_lsp_logs::LogType::Log => LogKind::Logs,
5474 proto::toggle_lsp_logs::LogType::Trace => LogKind::Trace,
5475 proto::toggle_lsp_logs::LogType::Rpc => LogKind::Rpc,
5476 };
5477 project.update(&mut cx, |_, cx| {
5478 cx.emit(Event::ToggleLspLogs {
5479 server_id: LanguageServerId::from_proto(envelope.payload.server_id),
5480 enabled: envelope.payload.enabled,
5481 toggled_log_kind,
5482 })
5483 });
5484 Ok(())
5485 }
5486
5487 async fn handle_synchronize_buffers(
5488 this: Entity<Self>,
5489 envelope: TypedEnvelope<proto::SynchronizeBuffers>,
5490 mut cx: AsyncApp,
5491 ) -> Result<proto::SynchronizeBuffersResponse> {
5492 let response = this.update(&mut cx, |this, cx| {
5493 let client = this.collab_client.clone();
5494 this.buffer_store.update(cx, |this, cx| {
5495 this.handle_synchronize_buffers(envelope, cx, client)
5496 })
5497 })?;
5498
5499 Ok(response)
5500 }
5501
5502 // Goes from client to host.
5503 async fn handle_search_candidate_buffers(
5504 this: Entity<Self>,
5505 envelope: TypedEnvelope<proto::FindSearchCandidates>,
5506 mut cx: AsyncApp,
5507 ) -> Result<proto::Ack> {
5508 let peer_id = envelope.original_sender_id.unwrap_or(envelope.sender_id);
5509 let message = envelope.payload;
5510 let project_id = message.project_id;
5511 let path_style = this.read_with(&cx, |this, cx| this.path_style(cx));
5512 let query =
5513 SearchQuery::from_proto(message.query.context("missing query field")?, path_style)?;
5514
5515 let handle = message.handle;
5516 let buffer_store = this.read_with(&cx, |this, _| this.buffer_store().clone());
5517 let client = this.read_with(&cx, |this, _| this.client());
5518 let task = cx.spawn(async move |cx| {
5519 let results = this.update(cx, |this, cx| {
5520 this.search_impl(query, cx).matching_buffers(cx)
5521 });
5522 let (batcher, batches) = project_search::AdaptiveBatcher::new(cx.background_executor());
5523 let mut new_matches = Box::pin(results.rx);
5524
5525 let sender_task = cx.background_executor().spawn({
5526 let client = client.clone();
5527 async move {
5528 let mut batches = std::pin::pin!(batches);
5529 while let Some(buffer_ids) = batches.next().await {
5530 client
5531 .request(proto::FindSearchCandidatesChunk {
5532 handle,
5533 peer_id: Some(peer_id),
5534 project_id,
5535 variant: Some(
5536 proto::find_search_candidates_chunk::Variant::Matches(
5537 proto::FindSearchCandidatesMatches { buffer_ids },
5538 ),
5539 ),
5540 })
5541 .await?;
5542 }
5543 anyhow::Ok(())
5544 }
5545 });
5546
5547 while let Some(buffer) = new_matches.next().await {
5548 let buffer_id = this.update(cx, |this, cx| {
5549 this.create_buffer_for_peer(&buffer, peer_id, cx).to_proto()
5550 });
5551 batcher.push(buffer_id).await;
5552 }
5553 batcher.flush().await;
5554
5555 sender_task.await?;
5556
5557 let _ = client
5558 .request(proto::FindSearchCandidatesChunk {
5559 handle,
5560 peer_id: Some(peer_id),
5561 project_id,
5562 variant: Some(proto::find_search_candidates_chunk::Variant::Done(
5563 proto::FindSearchCandidatesDone {},
5564 )),
5565 })
5566 .await?;
5567 anyhow::Ok(())
5568 });
5569 buffer_store.update(&mut cx, |this, _| {
5570 this.register_ongoing_project_search((peer_id, handle), task);
5571 });
5572
5573 Ok(proto::Ack {})
5574 }
5575
5576 async fn handle_open_buffer_by_id(
5577 this: Entity<Self>,
5578 envelope: TypedEnvelope<proto::OpenBufferById>,
5579 mut cx: AsyncApp,
5580 ) -> Result<proto::OpenBufferResponse> {
5581 let peer_id = envelope.original_sender_id()?;
5582 let buffer_id = BufferId::new(envelope.payload.id)?;
5583 let buffer = this
5584 .update(&mut cx, |this, cx| this.open_buffer_by_id(buffer_id, cx))
5585 .await?;
5586 Project::respond_to_open_buffer_request(this, buffer, peer_id, &mut cx)
5587 }
5588
5589 async fn handle_open_buffer_by_path(
5590 this: Entity<Self>,
5591 envelope: TypedEnvelope<proto::OpenBufferByPath>,
5592 mut cx: AsyncApp,
5593 ) -> Result<proto::OpenBufferResponse> {
5594 let peer_id = envelope.original_sender_id()?;
5595 let worktree_id = WorktreeId::from_proto(envelope.payload.worktree_id);
5596 let path = RelPath::from_proto(&envelope.payload.path)?;
5597 let open_buffer = this
5598 .update(&mut cx, |this, cx| {
5599 this.open_buffer(ProjectPath { worktree_id, path }, cx)
5600 })
5601 .await?;
5602 Project::respond_to_open_buffer_request(this, open_buffer, peer_id, &mut cx)
5603 }
5604
5605 async fn handle_open_new_buffer(
5606 this: Entity<Self>,
5607 envelope: TypedEnvelope<proto::OpenNewBuffer>,
5608 mut cx: AsyncApp,
5609 ) -> Result<proto::OpenBufferResponse> {
5610 let buffer = this
5611 .update(&mut cx, |this, cx| this.create_buffer(None, true, cx))
5612 .await?;
5613 let peer_id = envelope.original_sender_id()?;
5614
5615 Project::respond_to_open_buffer_request(this, buffer, peer_id, &mut cx)
5616 }
5617
5618 fn respond_to_open_buffer_request(
5619 this: Entity<Self>,
5620 buffer: Entity<Buffer>,
5621 peer_id: proto::PeerId,
5622 cx: &mut AsyncApp,
5623 ) -> Result<proto::OpenBufferResponse> {
5624 this.update(cx, |this, cx| {
5625 let is_private = buffer
5626 .read(cx)
5627 .file()
5628 .map(|f| f.is_private())
5629 .unwrap_or_default();
5630 anyhow::ensure!(!is_private, ErrorCode::UnsharedItem);
5631 Ok(proto::OpenBufferResponse {
5632 buffer_id: this.create_buffer_for_peer(&buffer, peer_id, cx).into(),
5633 })
5634 })
5635 }
5636
5637 fn create_buffer_for_peer(
5638 &mut self,
5639 buffer: &Entity<Buffer>,
5640 peer_id: proto::PeerId,
5641 cx: &mut App,
5642 ) -> BufferId {
5643 self.buffer_store
5644 .update(cx, |buffer_store, cx| {
5645 buffer_store.create_buffer_for_peer(buffer, peer_id, cx)
5646 })
5647 .detach_and_log_err(cx);
5648 buffer.read(cx).remote_id()
5649 }
5650
5651 async fn handle_create_image_for_peer(
5652 this: Entity<Self>,
5653 envelope: TypedEnvelope<proto::CreateImageForPeer>,
5654 mut cx: AsyncApp,
5655 ) -> Result<()> {
5656 this.update(&mut cx, |this, cx| {
5657 this.image_store.update(cx, |image_store, cx| {
5658 image_store.handle_create_image_for_peer(envelope, cx)
5659 })
5660 })
5661 }
5662
5663 async fn handle_create_file_for_peer(
5664 this: Entity<Self>,
5665 envelope: TypedEnvelope<proto::CreateFileForPeer>,
5666 mut cx: AsyncApp,
5667 ) -> Result<()> {
5668 use proto::create_file_for_peer::Variant;
5669 log::debug!("handle_create_file_for_peer: received message");
5670
5671 let downloading_files: Arc<Mutex<HashMap<(WorktreeId, String), DownloadingFile>>> =
5672 this.update(&mut cx, |this, _| this.downloading_files.clone());
5673
5674 match &envelope.payload.variant {
5675 Some(Variant::State(state)) => {
5676 log::debug!(
5677 "handle_create_file_for_peer: got State: id={}, content_size={}",
5678 state.id,
5679 state.content_size
5680 );
5681
5682 // Extract worktree_id and path from the File field
5683 if let Some(ref file) = state.file {
5684 let worktree_id = WorktreeId::from_proto(file.worktree_id);
5685 let path = file.path.clone();
5686 let key = (worktree_id, path);
5687 log::debug!("handle_create_file_for_peer: looking up key={:?}", key);
5688
5689 let empty_file_destination: Option<PathBuf> = {
5690 let mut files = downloading_files.lock();
5691 log::trace!(
5692 "handle_create_file_for_peer: current downloading_files keys: {:?}",
5693 files.keys().collect::<Vec<_>>()
5694 );
5695
5696 if let Some(file_entry) = files.get_mut(&key) {
5697 file_entry.total_size = state.content_size;
5698 file_entry.file_id = Some(state.id);
5699 log::debug!(
5700 "handle_create_file_for_peer: updated file entry: total_size={}, file_id={}",
5701 state.content_size,
5702 state.id
5703 );
5704 } else {
5705 log::warn!(
5706 "handle_create_file_for_peer: key={:?} not found in downloading_files",
5707 key
5708 );
5709 }
5710
5711 if state.content_size == 0 {
5712 // No chunks will arrive for an empty file; write it now.
5713 files.remove(&key).map(|entry| entry.destination_path)
5714 } else {
5715 None
5716 }
5717 };
5718
5719 if let Some(destination) = empty_file_destination {
5720 log::debug!(
5721 "handle_create_file_for_peer: writing empty file to {:?}",
5722 destination
5723 );
5724 match smol::fs::write(&destination, &[] as &[u8]).await {
5725 Ok(_) => log::info!(
5726 "handle_create_file_for_peer: successfully wrote file to {:?}",
5727 destination
5728 ),
5729 Err(e) => log::error!(
5730 "handle_create_file_for_peer: failed to write empty file: {:?}",
5731 e
5732 ),
5733 }
5734 }
5735 } else {
5736 log::warn!("handle_create_file_for_peer: State has no file field");
5737 }
5738 }
5739 Some(Variant::Chunk(chunk)) => {
5740 log::debug!(
5741 "handle_create_file_for_peer: got Chunk: file_id={}, data_len={}",
5742 chunk.file_id,
5743 chunk.data.len()
5744 );
5745
5746 // Extract data while holding the lock, then release it before await
5747 let (key_to_remove, write_info): (
5748 Option<(WorktreeId, String)>,
5749 Option<(PathBuf, Vec<u8>)>,
5750 ) = {
5751 let mut files = downloading_files.lock();
5752 let mut found_key: Option<(WorktreeId, String)> = None;
5753 let mut write_data: Option<(PathBuf, Vec<u8>)> = None;
5754
5755 for (key, file_entry) in files.iter_mut() {
5756 if file_entry.file_id == Some(chunk.file_id) {
5757 file_entry.chunks.extend_from_slice(&chunk.data);
5758 log::debug!(
5759 "handle_create_file_for_peer: accumulated {} bytes, total_size={}",
5760 file_entry.chunks.len(),
5761 file_entry.total_size
5762 );
5763
5764 if file_entry.chunks.len() as u64 >= file_entry.total_size
5765 && file_entry.total_size > 0
5766 {
5767 let destination = file_entry.destination_path.clone();
5768 let content = std::mem::take(&mut file_entry.chunks);
5769 found_key = Some(key.clone());
5770 write_data = Some((destination, content));
5771 }
5772 break;
5773 }
5774 }
5775 (found_key, write_data)
5776 }; // MutexGuard is dropped here
5777
5778 // Perform the async write outside the lock
5779 if let Some((destination, content)) = write_info {
5780 log::debug!(
5781 "handle_create_file_for_peer: writing {} bytes to {:?}",
5782 content.len(),
5783 destination
5784 );
5785 match smol::fs::write(&destination, &content).await {
5786 Ok(_) => log::info!(
5787 "handle_create_file_for_peer: successfully wrote file to {:?}",
5788 destination
5789 ),
5790 Err(e) => log::error!(
5791 "handle_create_file_for_peer: failed to write file: {:?}",
5792 e
5793 ),
5794 }
5795 }
5796
5797 // Remove the completed entry
5798 if let Some(key) = key_to_remove {
5799 downloading_files.lock().remove(&key);
5800 log::debug!("handle_create_file_for_peer: removed completed download entry");
5801 }
5802 }
5803 None => {
5804 log::warn!("handle_create_file_for_peer: got None variant");
5805 }
5806 }
5807
5808 Ok(())
5809 }
5810
5811 fn synchronize_remote_buffers(&mut self, cx: &mut Context<Self>) -> Task<Result<()>> {
5812 let project_id = match self.client_state {
5813 ProjectClientState::Collab {
5814 sharing_has_stopped,
5815 remote_id,
5816 ..
5817 } => {
5818 if sharing_has_stopped {
5819 return Task::ready(Err(anyhow!(
5820 "can't synchronize remote buffers on a readonly project"
5821 )));
5822 } else {
5823 remote_id
5824 }
5825 }
5826 ProjectClientState::Shared { .. } | ProjectClientState::Local => {
5827 return Task::ready(Err(anyhow!(
5828 "can't synchronize remote buffers on a local project"
5829 )));
5830 }
5831 };
5832
5833 let client = self.collab_client.clone();
5834 cx.spawn(async move |this, cx| {
5835 let (buffers, incomplete_buffer_ids) = this.update(cx, |this, cx| {
5836 this.buffer_store.read(cx).buffer_version_info(cx)
5837 })?;
5838 let response = client
5839 .request(proto::SynchronizeBuffers {
5840 project_id,
5841 buffers,
5842 })
5843 .await?;
5844
5845 let send_updates_for_buffers = this.update(cx, |this, cx| {
5846 response
5847 .buffers
5848 .into_iter()
5849 .map(|buffer| {
5850 let client = client.clone();
5851 let buffer_id = match BufferId::new(buffer.id) {
5852 Ok(id) => id,
5853 Err(e) => {
5854 return Task::ready(Err(e));
5855 }
5856 };
5857 let remote_version = language::proto::deserialize_version(&buffer.version);
5858 if let Some(buffer) = this.buffer_for_id(buffer_id, cx) {
5859 let operations =
5860 buffer.read(cx).serialize_ops(Some(remote_version), cx);
5861 cx.background_spawn(async move {
5862 let operations = operations.await;
5863 for chunk in split_operations(operations) {
5864 client
5865 .request(proto::UpdateBuffer {
5866 project_id,
5867 buffer_id: buffer_id.into(),
5868 operations: chunk,
5869 })
5870 .await?;
5871 }
5872 anyhow::Ok(())
5873 })
5874 } else {
5875 Task::ready(Ok(()))
5876 }
5877 })
5878 .collect::<Vec<_>>()
5879 })?;
5880
5881 // Any incomplete buffers have open requests waiting. Request that the host sends
5882 // creates these buffers for us again to unblock any waiting futures.
5883 for id in incomplete_buffer_ids {
5884 cx.background_spawn(client.request(proto::OpenBufferById {
5885 project_id,
5886 id: id.into(),
5887 }))
5888 .detach();
5889 }
5890
5891 futures::future::join_all(send_updates_for_buffers)
5892 .await
5893 .into_iter()
5894 .collect()
5895 })
5896 }
5897
5898 pub fn worktree_metadata_protos(&self, cx: &App) -> Vec<proto::WorktreeMetadata> {
5899 self.worktree_store.read(cx).worktree_metadata_protos(cx)
5900 }
5901
5902 /// Iterator of all open buffers that have unsaved changes
5903 pub fn dirty_buffers<'a>(&'a self, cx: &'a App) -> impl Iterator<Item = ProjectPath> + 'a {
5904 self.buffer_store.read(cx).buffers().filter_map(|buf| {
5905 let buf = buf.read(cx);
5906 if buf.is_dirty() {
5907 buf.project_path(cx)
5908 } else {
5909 None
5910 }
5911 })
5912 }
5913
5914 fn set_worktrees_from_proto(
5915 &mut self,
5916 worktrees: Vec<proto::WorktreeMetadata>,
5917 cx: &mut Context<Project>,
5918 ) -> Result<()> {
5919 self.worktree_store.update(cx, |worktree_store, cx| {
5920 worktree_store.set_worktrees_from_proto(worktrees, self.replica_id(), cx)
5921 })
5922 }
5923
5924 fn set_collaborators_from_proto(
5925 &mut self,
5926 messages: Vec<proto::Collaborator>,
5927 cx: &mut Context<Self>,
5928 ) -> Result<()> {
5929 let mut collaborators = HashMap::default();
5930 for message in messages {
5931 let collaborator = Collaborator::from_proto(message)?;
5932 collaborators.insert(collaborator.peer_id, collaborator);
5933 }
5934 for old_peer_id in self.collaborators.keys() {
5935 if !collaborators.contains_key(old_peer_id) {
5936 cx.emit(Event::CollaboratorLeft(*old_peer_id));
5937 }
5938 }
5939 self.collaborators = collaborators;
5940 Ok(())
5941 }
5942
5943 pub fn supplementary_language_servers<'a>(
5944 &'a self,
5945 cx: &'a App,
5946 ) -> impl 'a + Iterator<Item = (LanguageServerId, LanguageServerName)> {
5947 self.lsp_store.read(cx).supplementary_language_servers()
5948 }
5949
5950 pub fn any_language_server_supports_inlay_hints(&self, buffer: &Buffer, cx: &mut App) -> bool {
5951 let Some(language) = buffer.language().cloned() else {
5952 return false;
5953 };
5954 self.lsp_store.update(cx, |lsp_store, _| {
5955 let relevant_language_servers = lsp_store
5956 .languages
5957 .lsp_adapters(&language.name())
5958 .into_iter()
5959 .map(|lsp_adapter| lsp_adapter.name())
5960 .collect::<HashSet<_>>();
5961 lsp_store
5962 .language_server_statuses()
5963 .filter_map(|(server_id, server_status)| {
5964 relevant_language_servers
5965 .contains(&server_status.name)
5966 .then_some(server_id)
5967 })
5968 .filter_map(|server_id| lsp_store.lsp_server_capabilities.get(&server_id))
5969 .any(InlayHints::check_capabilities)
5970 })
5971 }
5972
5973 pub fn any_language_server_supports_semantic_tokens(
5974 &self,
5975 buffer: &Buffer,
5976 cx: &mut App,
5977 ) -> bool {
5978 let Some(language) = buffer.language().cloned() else {
5979 return false;
5980 };
5981 let lsp_store = self.lsp_store.read(cx);
5982 let relevant_language_servers = lsp_store
5983 .languages
5984 .lsp_adapters(&language.name())
5985 .into_iter()
5986 .map(|lsp_adapter| lsp_adapter.name())
5987 .collect::<HashSet<_>>();
5988 lsp_store
5989 .language_server_statuses()
5990 .filter_map(|(server_id, server_status)| {
5991 relevant_language_servers
5992 .contains(&server_status.name)
5993 .then_some(server_id)
5994 })
5995 .filter_map(|server_id| lsp_store.lsp_server_capabilities.get(&server_id))
5996 .any(|capabilities| capabilities.semantic_tokens_provider.is_some())
5997 }
5998
5999 pub fn language_server_id_for_name(
6000 &self,
6001 buffer: &Buffer,
6002 name: &LanguageServerName,
6003 cx: &App,
6004 ) -> Option<LanguageServerId> {
6005 let language = buffer.language()?;
6006 let relevant_language_servers = self
6007 .languages
6008 .lsp_adapters(&language.name())
6009 .into_iter()
6010 .map(|lsp_adapter| lsp_adapter.name())
6011 .collect::<HashSet<_>>();
6012 if !relevant_language_servers.contains(name) {
6013 return None;
6014 }
6015 self.language_server_statuses(cx)
6016 .filter(|(_, server_status)| relevant_language_servers.contains(&server_status.name))
6017 .find_map(|(server_id, server_status)| {
6018 if &server_status.name == name {
6019 Some(server_id)
6020 } else {
6021 None
6022 }
6023 })
6024 }
6025
6026 #[cfg(feature = "test-support")]
6027 pub fn has_language_servers_for(&self, buffer: &Buffer, cx: &mut App) -> bool {
6028 self.lsp_store.update(cx, |this, cx| {
6029 this.running_language_servers_for_local_buffer(buffer, cx)
6030 .next()
6031 .is_some()
6032 })
6033 }
6034
6035 pub fn git_init(
6036 &self,
6037 path: Arc<Path>,
6038 fallback_branch_name: String,
6039 cx: &App,
6040 ) -> Task<Result<()>> {
6041 self.git_store
6042 .read(cx)
6043 .git_init(path, fallback_branch_name, cx)
6044 }
6045
6046 pub fn buffer_store(&self) -> &Entity<BufferStore> {
6047 &self.buffer_store
6048 }
6049
6050 pub fn git_store(&self) -> &Entity<GitStore> {
6051 &self.git_store
6052 }
6053
6054 pub fn agent_server_store(&self) -> &Entity<AgentServerStore> {
6055 &self.agent_server_store
6056 }
6057
6058 #[cfg(feature = "test-support")]
6059 pub fn git_scans_complete(&self, cx: &Context<Self>) -> Task<()> {
6060 use futures::future::join_all;
6061 cx.spawn(async move |this, cx| {
6062 let scans_complete = this
6063 .read_with(cx, |this, cx| {
6064 this.worktrees(cx)
6065 .filter_map(|worktree| Some(worktree.read(cx).as_local()?.scan_complete()))
6066 .collect::<Vec<_>>()
6067 })
6068 .unwrap();
6069 join_all(scans_complete).await;
6070 let barriers = this
6071 .update(cx, |this, cx| {
6072 let repos = this.repositories(cx).values().cloned().collect::<Vec<_>>();
6073 repos
6074 .into_iter()
6075 .map(|repo| repo.update(cx, |repo, _| repo.barrier()))
6076 .collect::<Vec<_>>()
6077 })
6078 .unwrap();
6079 join_all(barriers).await;
6080 })
6081 }
6082
6083 pub fn active_repository(&self, cx: &App) -> Option<Entity<Repository>> {
6084 self.git_store.read(cx).active_repository()
6085 }
6086
6087 pub fn repositories<'a>(&self, cx: &'a App) -> &'a HashMap<RepositoryId, Entity<Repository>> {
6088 self.git_store.read(cx).repositories()
6089 }
6090
6091 pub fn status_for_buffer_id(&self, buffer_id: BufferId, cx: &App) -> Option<FileStatus> {
6092 self.git_store.read(cx).status_for_buffer_id(buffer_id, cx)
6093 }
6094
6095 pub fn set_agent_location(
6096 &mut self,
6097 new_location: Option<AgentLocation>,
6098 cx: &mut Context<Self>,
6099 ) {
6100 if let Some(old_location) = self.agent_location.as_ref() {
6101 old_location
6102 .buffer
6103 .update(cx, |buffer, cx| buffer.remove_agent_selections(cx))
6104 .ok();
6105 }
6106
6107 if let Some(location) = new_location.as_ref() {
6108 location
6109 .buffer
6110 .update(cx, |buffer, cx| {
6111 buffer.set_agent_selections(
6112 Arc::from([language::Selection {
6113 id: 0,
6114 start: location.position,
6115 end: location.position,
6116 reversed: false,
6117 goal: language::SelectionGoal::None,
6118 }]),
6119 false,
6120 CursorShape::Hollow,
6121 cx,
6122 )
6123 })
6124 .ok();
6125 }
6126
6127 self.agent_location = new_location;
6128 cx.emit(Event::AgentLocationChanged);
6129 }
6130
6131 pub fn agent_location(&self) -> Option<AgentLocation> {
6132 self.agent_location.clone()
6133 }
6134
6135 pub fn path_style(&self, cx: &App) -> PathStyle {
6136 self.worktree_store.read(cx).path_style()
6137 }
6138
6139 pub fn contains_local_settings_file(
6140 &self,
6141 worktree_id: WorktreeId,
6142 rel_path: &RelPath,
6143 cx: &App,
6144 ) -> bool {
6145 self.worktree_for_id(worktree_id, cx)
6146 .map_or(false, |worktree| {
6147 worktree.read(cx).entry_for_path(rel_path).is_some()
6148 })
6149 }
6150
6151 pub fn worktree_paths(&self, cx: &App) -> WorktreePaths {
6152 self.worktree_store.read(cx).paths(cx)
6153 }
6154
6155 pub fn project_group_key(&self, cx: &App) -> ProjectGroupKey {
6156 ProjectGroupKey::from_project(self, cx)
6157 }
6158}
6159
6160/// Identifies a project group by a set of paths the workspaces in this group
6161/// have.
6162///
6163/// Paths are mapped to their main worktree path first so we can group
6164/// workspaces by main repos.
6165#[derive(PartialEq, Eq, Hash, Clone, Debug, Default)]
6166pub struct ProjectGroupKey {
6167 /// The paths of the main worktrees for this project group.
6168 paths: PathList,
6169 host: Option<RemoteConnectionOptions>,
6170}
6171
6172impl ProjectGroupKey {
6173 /// Creates a new `ProjectGroupKey` with the given path list.
6174 ///
6175 /// The path list should point to the git main worktree paths for a project.
6176 pub fn new(host: Option<RemoteConnectionOptions>, paths: PathList) -> Self {
6177 Self { paths, host }
6178 }
6179
6180 pub fn from_project(project: &Project, cx: &App) -> Self {
6181 let paths = project.worktree_paths(cx);
6182 let host = project.remote_connection_options(cx);
6183 Self {
6184 paths: paths.main_worktree_path_list().clone(),
6185 host,
6186 }
6187 }
6188
6189 pub fn from_worktree_paths(
6190 paths: &WorktreePaths,
6191 host: Option<RemoteConnectionOptions>,
6192 ) -> Self {
6193 Self {
6194 paths: paths.main_worktree_path_list().clone(),
6195 host,
6196 }
6197 }
6198
6199 pub fn path_list(&self) -> &PathList {
6200 &self.paths
6201 }
6202
6203 pub fn display_name(
6204 &self,
6205 path_detail_map: &std::collections::HashMap<PathBuf, usize>,
6206 ) -> SharedString {
6207 let mut names = Vec::with_capacity(self.paths.paths().len());
6208 for abs_path in self.paths.ordered_paths() {
6209 let detail = path_detail_map.get(abs_path).copied().unwrap_or(0);
6210 let suffix = path_suffix(abs_path, detail);
6211 if !suffix.is_empty() {
6212 names.push(suffix);
6213 }
6214 }
6215 if names.is_empty() {
6216 "Empty Workspace".into()
6217 } else {
6218 names.join(", ").into()
6219 }
6220 }
6221
6222 pub fn host(&self) -> Option<RemoteConnectionOptions> {
6223 self.host.clone()
6224 }
6225}
6226
6227pub fn path_suffix(path: &Path, detail: usize) -> String {
6228 let mut components: Vec<_> = path
6229 .components()
6230 .rev()
6231 .filter_map(|component| match component {
6232 std::path::Component::Normal(s) => Some(s.to_string_lossy()),
6233 _ => None,
6234 })
6235 .take(detail + 1)
6236 .collect();
6237 components.reverse();
6238 components.join("/")
6239}
6240
6241pub struct PathMatchCandidateSet {
6242 pub snapshot: Snapshot,
6243 pub include_ignored: bool,
6244 pub include_root_name: bool,
6245 pub candidates: Candidates,
6246}
6247
6248pub enum Candidates {
6249 /// Only consider directories.
6250 Directories,
6251 /// Only consider files.
6252 Files,
6253 /// Consider directories and files.
6254 Entries,
6255}
6256
6257impl<'a> fuzzy::PathMatchCandidateSet<'a> for PathMatchCandidateSet {
6258 type Candidates = PathMatchCandidateSetIter<'a>;
6259
6260 fn id(&self) -> usize {
6261 self.snapshot.id().to_usize()
6262 }
6263
6264 fn len(&self) -> usize {
6265 match self.candidates {
6266 Candidates::Files => {
6267 if self.include_ignored {
6268 self.snapshot.file_count()
6269 } else {
6270 self.snapshot.visible_file_count()
6271 }
6272 }
6273
6274 Candidates::Directories => {
6275 if self.include_ignored {
6276 self.snapshot.dir_count()
6277 } else {
6278 self.snapshot.visible_dir_count()
6279 }
6280 }
6281
6282 Candidates::Entries => {
6283 if self.include_ignored {
6284 self.snapshot.entry_count()
6285 } else {
6286 self.snapshot.visible_entry_count()
6287 }
6288 }
6289 }
6290 }
6291
6292 fn prefix(&self) -> Arc<RelPath> {
6293 if self.snapshot.root_entry().is_some_and(|e| e.is_file()) || self.include_root_name {
6294 self.snapshot.root_name().into()
6295 } else {
6296 RelPath::empty().into()
6297 }
6298 }
6299
6300 fn root_is_file(&self) -> bool {
6301 self.snapshot.root_entry().is_some_and(|f| f.is_file())
6302 }
6303
6304 fn path_style(&self) -> PathStyle {
6305 self.snapshot.path_style()
6306 }
6307
6308 fn candidates(&'a self, start: usize) -> Self::Candidates {
6309 PathMatchCandidateSetIter {
6310 traversal: match self.candidates {
6311 Candidates::Directories => self.snapshot.directories(self.include_ignored, start),
6312 Candidates::Files => self.snapshot.files(self.include_ignored, start),
6313 Candidates::Entries => self.snapshot.entries(self.include_ignored, start),
6314 },
6315 }
6316 }
6317}
6318
6319pub struct PathMatchCandidateSetIter<'a> {
6320 traversal: Traversal<'a>,
6321}
6322
6323impl<'a> Iterator for PathMatchCandidateSetIter<'a> {
6324 type Item = fuzzy::PathMatchCandidate<'a>;
6325
6326 fn next(&mut self) -> Option<Self::Item> {
6327 self.traversal
6328 .next()
6329 .map(|entry| fuzzy::PathMatchCandidate {
6330 is_dir: entry.kind.is_dir(),
6331 path: &entry.path,
6332 char_bag: entry.char_bag,
6333 })
6334 }
6335}
6336
6337impl<'a> fuzzy_nucleo::PathMatchCandidateSet<'a> for PathMatchCandidateSet {
6338 type Candidates = PathMatchCandidateSetNucleoIter<'a>;
6339 fn id(&self) -> usize {
6340 self.snapshot.id().to_usize()
6341 }
6342 fn len(&self) -> usize {
6343 match self.candidates {
6344 Candidates::Files => {
6345 if self.include_ignored {
6346 self.snapshot.file_count()
6347 } else {
6348 self.snapshot.visible_file_count()
6349 }
6350 }
6351 Candidates::Directories => {
6352 if self.include_ignored {
6353 self.snapshot.dir_count()
6354 } else {
6355 self.snapshot.visible_dir_count()
6356 }
6357 }
6358 Candidates::Entries => {
6359 if self.include_ignored {
6360 self.snapshot.entry_count()
6361 } else {
6362 self.snapshot.visible_entry_count()
6363 }
6364 }
6365 }
6366 }
6367 fn prefix(&self) -> Arc<RelPath> {
6368 if self.snapshot.root_entry().is_some_and(|e| e.is_file()) || self.include_root_name {
6369 self.snapshot.root_name().into()
6370 } else {
6371 RelPath::empty().into()
6372 }
6373 }
6374 fn root_is_file(&self) -> bool {
6375 self.snapshot.root_entry().is_some_and(|f| f.is_file())
6376 }
6377 fn path_style(&self) -> PathStyle {
6378 self.snapshot.path_style()
6379 }
6380 fn candidates(&'a self, start: usize) -> Self::Candidates {
6381 PathMatchCandidateSetNucleoIter {
6382 traversal: match self.candidates {
6383 Candidates::Directories => self.snapshot.directories(self.include_ignored, start),
6384 Candidates::Files => self.snapshot.files(self.include_ignored, start),
6385 Candidates::Entries => self.snapshot.entries(self.include_ignored, start),
6386 },
6387 }
6388 }
6389}
6390
6391pub struct PathMatchCandidateSetNucleoIter<'a> {
6392 traversal: Traversal<'a>,
6393}
6394
6395impl<'a> Iterator for PathMatchCandidateSetNucleoIter<'a> {
6396 type Item = fuzzy_nucleo::PathMatchCandidate<'a>;
6397 fn next(&mut self) -> Option<Self::Item> {
6398 self.traversal
6399 .next()
6400 .map(|entry| fuzzy_nucleo::PathMatchCandidate {
6401 is_dir: entry.kind.is_dir(),
6402 path: &entry.path,
6403 char_bag: entry.char_bag,
6404 })
6405 }
6406}
6407
6408impl EventEmitter<Event> for Project {}
6409
6410impl<'a> From<&'a ProjectPath> for SettingsLocation<'a> {
6411 fn from(val: &'a ProjectPath) -> Self {
6412 SettingsLocation {
6413 worktree_id: val.worktree_id,
6414 path: val.path.as_ref(),
6415 }
6416 }
6417}
6418
6419impl<P: Into<Arc<RelPath>>> From<(WorktreeId, P)> for ProjectPath {
6420 fn from((worktree_id, path): (WorktreeId, P)) -> Self {
6421 Self {
6422 worktree_id,
6423 path: path.into(),
6424 }
6425 }
6426}
6427
6428/// ResolvedPath is a path that has been resolved to either a ProjectPath
6429/// or an AbsPath and that *exists*.
6430#[derive(Debug, Clone)]
6431pub enum ResolvedPath {
6432 ProjectPath {
6433 project_path: ProjectPath,
6434 is_dir: bool,
6435 },
6436 AbsPath {
6437 path: String,
6438 is_dir: bool,
6439 },
6440}
6441
6442impl ResolvedPath {
6443 pub fn abs_path(&self) -> Option<&str> {
6444 match self {
6445 Self::AbsPath { path, .. } => Some(path),
6446 _ => None,
6447 }
6448 }
6449
6450 pub fn into_abs_path(self) -> Option<String> {
6451 match self {
6452 Self::AbsPath { path, .. } => Some(path),
6453 _ => None,
6454 }
6455 }
6456
6457 pub fn project_path(&self) -> Option<&ProjectPath> {
6458 match self {
6459 Self::ProjectPath { project_path, .. } => Some(project_path),
6460 _ => None,
6461 }
6462 }
6463
6464 pub fn is_file(&self) -> bool {
6465 !self.is_dir()
6466 }
6467
6468 pub fn is_dir(&self) -> bool {
6469 match self {
6470 Self::ProjectPath { is_dir, .. } => *is_dir,
6471 Self::AbsPath { is_dir, .. } => *is_dir,
6472 }
6473 }
6474}
6475
6476impl ProjectItem for Buffer {
6477 fn try_open(
6478 project: &Entity<Project>,
6479 path: &ProjectPath,
6480 cx: &mut App,
6481 ) -> Option<Task<Result<Entity<Self>>>> {
6482 Some(project.update(cx, |project, cx| project.open_buffer(path.clone(), cx)))
6483 }
6484
6485 fn entry_id(&self, _cx: &App) -> Option<ProjectEntryId> {
6486 File::from_dyn(self.file()).and_then(|file| file.project_entry_id())
6487 }
6488
6489 fn project_path(&self, cx: &App) -> Option<ProjectPath> {
6490 let file = self.file()?;
6491
6492 (!matches!(file.disk_state(), DiskState::Historic { .. })).then(|| ProjectPath {
6493 worktree_id: file.worktree_id(cx),
6494 path: file.path().clone(),
6495 })
6496 }
6497
6498 fn is_dirty(&self) -> bool {
6499 self.is_dirty()
6500 }
6501}
6502
6503impl Completion {
6504 pub fn kind(&self) -> Option<CompletionItemKind> {
6505 self.source
6506 // `lsp::CompletionListItemDefaults` has no `kind` field
6507 .lsp_completion(false)
6508 .and_then(|lsp_completion| lsp_completion.kind)
6509 }
6510
6511 pub fn label(&self) -> Option<String> {
6512 self.source
6513 .lsp_completion(false)
6514 .map(|lsp_completion| lsp_completion.label.clone())
6515 }
6516
6517 /// A key that can be used to sort completions when displaying
6518 /// them to the user.
6519 pub fn sort_key(&self) -> (usize, &str) {
6520 const DEFAULT_KIND_KEY: usize = 4;
6521 let kind_key = self
6522 .kind()
6523 .and_then(|lsp_completion_kind| match lsp_completion_kind {
6524 lsp::CompletionItemKind::KEYWORD => Some(0),
6525 lsp::CompletionItemKind::VARIABLE => Some(1),
6526 lsp::CompletionItemKind::CONSTANT => Some(2),
6527 lsp::CompletionItemKind::PROPERTY => Some(3),
6528 _ => None,
6529 })
6530 .unwrap_or(DEFAULT_KIND_KEY);
6531 (kind_key, self.label.filter_text())
6532 }
6533
6534 /// Whether this completion is a snippet.
6535 pub fn is_snippet_kind(&self) -> bool {
6536 matches!(
6537 &self.source,
6538 CompletionSource::Lsp { lsp_completion, .. }
6539 if lsp_completion.kind == Some(CompletionItemKind::SNIPPET)
6540 )
6541 }
6542
6543 /// Whether this completion is a snippet or snippet-style LSP completion.
6544 pub fn is_snippet(&self) -> bool {
6545 self.source
6546 // `lsp::CompletionListItemDefaults` has `insert_text_format` field
6547 .lsp_completion(true)
6548 .is_some_and(|lsp_completion| {
6549 lsp_completion.insert_text_format == Some(lsp::InsertTextFormat::SNIPPET)
6550 })
6551 }
6552
6553 /// Returns the corresponding color for this completion.
6554 ///
6555 /// Will return `None` if this completion's kind is not [`CompletionItemKind::COLOR`].
6556 pub fn color(&self) -> Option<Hsla> {
6557 // `lsp::CompletionListItemDefaults` has no `kind` field
6558 let lsp_completion = self.source.lsp_completion(false)?;
6559 if lsp_completion.kind? == CompletionItemKind::COLOR {
6560 return color_extractor::extract_color(&lsp_completion);
6561 }
6562 None
6563 }
6564}
6565
6566fn proto_to_prompt(level: proto::language_server_prompt_request::Level) -> gpui::PromptLevel {
6567 match level {
6568 proto::language_server_prompt_request::Level::Info(_) => gpui::PromptLevel::Info,
6569 proto::language_server_prompt_request::Level::Warning(_) => gpui::PromptLevel::Warning,
6570 proto::language_server_prompt_request::Level::Critical(_) => gpui::PromptLevel::Critical,
6571 }
6572}
6573
6574fn provide_inline_values(
6575 captures: impl Iterator<Item = (Range<usize>, language::DebuggerTextObject)>,
6576 snapshot: &language::BufferSnapshot,
6577 max_row: usize,
6578) -> Vec<InlineValueLocation> {
6579 let mut variables = Vec::new();
6580 let mut variable_position = HashSet::default();
6581 let mut scopes = Vec::new();
6582
6583 let active_debug_line_offset = snapshot.point_to_offset(Point::new(max_row as u32, 0));
6584
6585 for (capture_range, capture_kind) in captures {
6586 match capture_kind {
6587 language::DebuggerTextObject::Variable => {
6588 let variable_name = snapshot
6589 .text_for_range(capture_range.clone())
6590 .collect::<String>();
6591 let point = snapshot.offset_to_point(capture_range.end);
6592
6593 while scopes
6594 .last()
6595 .is_some_and(|scope: &Range<_>| !scope.contains(&capture_range.start))
6596 {
6597 scopes.pop();
6598 }
6599
6600 if point.row as usize > max_row {
6601 break;
6602 }
6603
6604 let scope = if scopes
6605 .last()
6606 .is_none_or(|scope| !scope.contains(&active_debug_line_offset))
6607 {
6608 VariableScope::Global
6609 } else {
6610 VariableScope::Local
6611 };
6612
6613 if variable_position.insert(capture_range.end) {
6614 variables.push(InlineValueLocation {
6615 variable_name,
6616 scope,
6617 lookup: VariableLookupKind::Variable,
6618 row: point.row as usize,
6619 column: point.column as usize,
6620 });
6621 }
6622 }
6623 language::DebuggerTextObject::Scope => {
6624 while scopes.last().map_or_else(
6625 || false,
6626 |scope: &Range<usize>| {
6627 !(scope.contains(&capture_range.start)
6628 && scope.contains(&capture_range.end))
6629 },
6630 ) {
6631 scopes.pop();
6632 }
6633 scopes.push(capture_range);
6634 }
6635 }
6636 }
6637
6638 variables
6639}