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