project: Fine-grained language server management (#24038)

Closes #ISSUE
https://github.com/zed-industries/zed/pull/23804
Release Notes:

- Improved detection of project roots for use by language servers.

Closes #ISSUE

Release Notes:

- N/A *or* Added/Fixed/Improved ...

---------

Co-authored-by: smit <0xtimsb@gmail.com>
Co-authored-by: Henrikh Kantuni <henrikh.kantuni@gmail.com>
Co-authored-by: Caleb! <48127194+kaf-lamed-beyt@users.noreply.github.com>
Co-authored-by: Marshall Bowers <git@maxdeviant.com>
Co-authored-by: Kirill Bulatov <kirill@zed.dev>
Co-authored-by: Agus Zubiaga <agus@zed.dev>
Co-authored-by: Danilo <danilo@zed.dev>
Co-authored-by: Nate Butler <iamnbutler@gmail.com>

crates/project/src/project_tree.rs

@@ -0,0 +1,243 @@
+//! This module defines a Project Tree.
+//!
+//! A Project Tree is responsible for determining where the roots of subprojects are located in a project.
+
+mod path_trie;
+mod server_tree;
+
+use std::{
+    borrow::Borrow,
+    collections::{hash_map::Entry, BTreeMap},
+    ops::ControlFlow,
+    sync::Arc,
+};
+
+use collections::HashMap;
+use gpui::{App, AppContext, Context, Entity, EventEmitter, Subscription};
+use language::{CachedLspAdapter, LspAdapterDelegate};
+use lsp::LanguageServerName;
+use path_trie::{LabelPresence, RootPathTrie, TriePath};
+use settings::{SettingsStore, WorktreeId};
+use worktree::{Event as WorktreeEvent, Worktree};
+
+use crate::{
+    worktree_store::{WorktreeStore, WorktreeStoreEvent},
+    ProjectPath,
+};
+
+pub(crate) use server_tree::{AdapterQuery, LanguageServerTree, LaunchDisposition};
+
+struct WorktreeRoots {
+    roots: RootPathTrie<LanguageServerName>,
+    worktree_store: Entity<WorktreeStore>,
+    _worktree_subscription: Subscription,
+}
+
+impl WorktreeRoots {
+    fn new(
+        worktree_store: Entity<WorktreeStore>,
+        worktree: Entity<Worktree>,
+        cx: &mut App,
+    ) -> Entity<Self> {
+        cx.new(|cx| Self {
+            roots: RootPathTrie::new(),
+            worktree_store,
+            _worktree_subscription: cx.subscribe(&worktree, |this: &mut Self, _, event, cx| {
+                match event {
+                    WorktreeEvent::UpdatedEntries(changes) => {
+                        for (path, _, kind) in changes.iter() {
+                            match kind {
+                                worktree::PathChange::Removed => {
+                                    let path = TriePath::from(path.as_ref());
+                                    this.roots.remove(&path);
+                                }
+                                _ => {}
+                            }
+                        }
+                    }
+                    WorktreeEvent::UpdatedGitRepositories(_) => {}
+                    WorktreeEvent::DeletedEntry(entry_id) => {
+                        let Some(entry) = this.worktree_store.read(cx).entry_for_id(*entry_id, cx)
+                        else {
+                            return;
+                        };
+                        let path = TriePath::from(entry.path.as_ref());
+                        this.roots.remove(&path);
+                    }
+                }
+            }),
+        })
+    }
+}
+
+pub struct ProjectTree {
+    root_points: HashMap<WorktreeId, Entity<WorktreeRoots>>,
+    worktree_store: Entity<WorktreeStore>,
+    _subscriptions: [Subscription; 2],
+}
+
+#[derive(Debug, Clone)]
+struct AdapterWrapper(Arc<CachedLspAdapter>);
+impl PartialEq for AdapterWrapper {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.name.eq(&other.0.name)
+    }
+}
+
+impl Eq for AdapterWrapper {}
+
+impl std::hash::Hash for AdapterWrapper {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.0.name.hash(state);
+    }
+}
+
+impl PartialOrd for AdapterWrapper {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.0.name.cmp(&other.0.name))
+    }
+}
+
+impl Ord for AdapterWrapper {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.0.name.cmp(&other.0.name)
+    }
+}
+
+impl Borrow<LanguageServerName> for AdapterWrapper {
+    fn borrow(&self) -> &LanguageServerName {
+        &self.0.name
+    }
+}
+
+#[derive(PartialEq)]
+pub(crate) enum ProjectTreeEvent {
+    WorktreeRemoved(WorktreeId),
+    Cleared,
+}
+
+impl EventEmitter<ProjectTreeEvent> for ProjectTree {}
+
+impl ProjectTree {
+    pub(crate) fn new(worktree_store: Entity<WorktreeStore>, cx: &mut App) -> Entity<Self> {
+        cx.new(|cx| Self {
+            root_points: Default::default(),
+            _subscriptions: [
+                cx.subscribe(&worktree_store, Self::on_worktree_store_event),
+                cx.observe_global::<SettingsStore>(|this, cx| {
+                    for (_, roots) in &mut this.root_points {
+                        roots.update(cx, |worktree_roots, _| {
+                            worktree_roots.roots = RootPathTrie::new();
+                        })
+                    }
+                    cx.emit(ProjectTreeEvent::Cleared);
+                }),
+            ],
+            worktree_store,
+        })
+    }
+    #[allow(clippy::mutable_key_type)]
+    fn root_for_path(
+        &mut self,
+        ProjectPath { worktree_id, path }: ProjectPath,
+        adapters: Vec<Arc<CachedLspAdapter>>,
+        delegate: Arc<dyn LspAdapterDelegate>,
+        cx: &mut App,
+    ) -> BTreeMap<AdapterWrapper, ProjectPath> {
+        debug_assert_eq!(delegate.worktree_id(), worktree_id);
+        #[allow(clippy::mutable_key_type)]
+        let mut roots = BTreeMap::from_iter(
+            adapters
+                .into_iter()
+                .map(|adapter| (AdapterWrapper(adapter), (None, LabelPresence::KnownAbsent))),
+        );
+        let worktree_roots = match self.root_points.entry(worktree_id) {
+            Entry::Occupied(occupied_entry) => occupied_entry.get().clone(),
+            Entry::Vacant(vacant_entry) => {
+                let Some(worktree) = self
+                    .worktree_store
+                    .read(cx)
+                    .worktree_for_id(worktree_id, cx)
+                else {
+                    return Default::default();
+                };
+                let roots = WorktreeRoots::new(self.worktree_store.clone(), worktree, cx);
+                vacant_entry.insert(roots).clone()
+            }
+        };
+
+        let key = TriePath::from(&*path);
+        worktree_roots.update(cx, |this, _| {
+            this.roots.walk(&key, &mut |path, labels| {
+                for (label, presence) in labels {
+                    if let Some((marked_path, current_presence)) = roots.get_mut(label) {
+                        if *current_presence > *presence {
+                            debug_assert!(false, "RootPathTrie precondition violation; while walking the tree label presence is only allowed to increase");
+                        }
+                        *marked_path = Some(ProjectPath {worktree_id, path: path.clone()});
+                        *current_presence = *presence;
+                    }
+
+                }
+                ControlFlow::Continue(())
+            });
+        });
+        for (adapter, (root_path, presence)) in &mut roots {
+            if *presence == LabelPresence::Present {
+                continue;
+            }
+
+            let depth = root_path
+                .as_ref()
+                .map(|root_path| {
+                    path.strip_prefix(&root_path.path)
+                        .unwrap()
+                        .components()
+                        .count()
+                })
+                .unwrap_or_else(|| path.components().count() + 1);
+
+            if depth > 0 {
+                let root = adapter.0.find_project_root(&path, depth, &delegate);
+                match root {
+                    Some(known_root) => worktree_roots.update(cx, |this, _| {
+                        let root = TriePath::from(&*known_root);
+                        this.roots
+                            .insert(&root, adapter.0.name(), LabelPresence::Present);
+                        *presence = LabelPresence::Present;
+                        *root_path = Some(ProjectPath {
+                            worktree_id,
+                            path: known_root,
+                        });
+                    }),
+                    None => worktree_roots.update(cx, |this, _| {
+                        this.roots
+                            .insert(&key, adapter.0.name(), LabelPresence::KnownAbsent);
+                    }),
+                }
+            }
+        }
+
+        roots
+            .into_iter()
+            .filter_map(|(k, (path, presence))| {
+                let path = path?;
+                presence.eq(&LabelPresence::Present).then(|| (k, path))
+            })
+            .collect()
+    }
+    fn on_worktree_store_event(
+        &mut self,
+        _: Entity<WorktreeStore>,
+        evt: &WorktreeStoreEvent,
+        cx: &mut Context<Self>,
+    ) {
+        match evt {
+            WorktreeStoreEvent::WorktreeRemoved(_, worktree_id) => {
+                self.root_points.remove(&worktree_id);
+                cx.emit(ProjectTreeEvent::WorktreeRemoved(*worktree_id));
+            }
+            _ => {}
+        }
+    }
+}