project: Allow running multiple instances of a single language server within a single worktree (#23473)

This PR introduces a new entity called Project Tree which is responsible
for finding subprojects within a worktree;
a subproject is a language-specific subset of a worktree which should be
accurately tracked on the language server side. We'll have an ability to
set multiple disjoint workspaceFolders on language server side OR spawn
multiple instances of a single language server (which will be the case
with e.g. Python language servers, as they need to interact with
multiple disjoint virtual environments).
Project Tree assumes that projects of the same LspAdapter kind cannot
overlap. Additionally project nesting is not allowed within the scope of
a single LspAdapter.

Closes https://github.com/zed-industries/zed/issues/5108
Re-lands #22182 which I had to revert due to merging it into todays
Preview.

Release Notes:

- Language servers now track their working directory more accurately.

---------

Co-authored-by: João <joao@zed.dev>

crates/project/src/project_tree/path_trie.rs

@@ -0,0 +1,241 @@
+use std::{
+    collections::{btree_map::Entry, BTreeMap},
+    ffi::OsStr,
+    ops::ControlFlow,
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+
+/// [RootPathTrie] is a workhorse of [super::ProjectTree]. It is responsible for determining the closest known project root for a given path.
+/// It also determines how much of a given path is unexplored, thus letting callers fill in that gap if needed.
+/// Conceptually, it allows one to annotate Worktree entries with arbitrary extra metadata and run closest-ancestor searches.
+///
+/// A path is unexplored when the closest ancestor of a path is not the path itself; that means that we have not yet ran the scan on that path.
+/// For example, if there's a project root at path `python/project` and we query for a path `python/project/subdir/another_subdir/file.py`, there is
+/// a known root at `python/project` and the unexplored part is `subdir/another_subdir` - we need to run a scan on these 2 directories.
+pub(super) struct RootPathTrie<Label> {
+    worktree_relative_path: Arc<Path>,
+    labels: BTreeMap<Label, LabelPresence>,
+    children: BTreeMap<Arc<OsStr>, RootPathTrie<Label>>,
+}
+
+/// Label presence is a marker that allows to optimize searches within [RootPathTrie]; node label can be:
+/// - Present; we know there's definitely a project root at this node and it is the only label of that kind on the path to the root of a worktree
+/// (none of it's ancestors or descendants can contain the same present label)
+/// - Known Absent - we know there's definitely no project root at this node and none of it's ancestors are Present (descendants can be present though!).
+/// - Forbidden - we know there's definitely no project root at this node and none of it's ancestors or descendants can be Present.
+/// The distinction is there to optimize searching; when we encounter a node with unknown status, we don't need to look at it's full path
+/// to the root of the worktree; it's sufficient to explore only the path between last node with a KnownAbsent state and the directory of a path, since we run searches
+/// from the leaf up to the root of the worktree. When any of the ancestors is forbidden, we don't need to look at the node or its ancestors.
+/// When there's a present labeled node on the path to the root, we don't need to ask the adapter to run the search at all.
+///
+/// In practical terms, it means that by storing label presence we don't need to do a project discovery on a given folder more than once
+/// (unless the node is invalidated, which can happen when FS entries are renamed/removed).
+///
+/// Storing project absence allows us to recognize which paths have already been scanned for a project root unsuccessfully. This way we don't need to run
+/// such scan more than once.
+#[derive(Clone, Copy, Debug, PartialOrd, PartialEq, Ord, Eq)]
+pub(super) enum LabelPresence {
+    KnownAbsent,
+    Present,
+}
+
+impl<Label: Ord + Clone> RootPathTrie<Label> {
+    pub(super) fn new() -> Self {
+        Self::new_with_key(Arc::from(Path::new("")))
+    }
+    fn new_with_key(worktree_relative_path: Arc<Path>) -> Self {
+        RootPathTrie {
+            worktree_relative_path,
+            labels: Default::default(),
+            children: Default::default(),
+        }
+    }
+    // Internal implementation of inner that allows one to visit descendants of insertion point for a node.
+    fn insert_inner(
+        &mut self,
+        path: &TriePath,
+        value: Label,
+        presence: LabelPresence,
+    ) -> &mut Self {
+        let mut current = self;
+
+        let mut path_so_far = PathBuf::new();
+        for key in path.0.iter() {
+            path_so_far.push(Path::new(key));
+            current = match current.children.entry(key.clone()) {
+                Entry::Vacant(vacant_entry) => vacant_entry
+                    .insert(RootPathTrie::new_with_key(Arc::from(path_so_far.as_path()))),
+                Entry::Occupied(occupied_entry) => occupied_entry.into_mut(),
+            };
+        }
+        let _previous_value = current.labels.insert(value, presence);
+        debug_assert_eq!(_previous_value, None);
+        current
+    }
+    pub(super) fn insert(&mut self, path: &TriePath, value: Label, presence: LabelPresence) {
+        self.insert_inner(path, value, presence);
+    }
+
+    pub(super) fn walk<'a>(
+        &'a self,
+        path: &TriePath,
+        callback: &mut dyn for<'b> FnMut(
+            &'b Arc<Path>,
+            &'a BTreeMap<Label, LabelPresence>,
+        ) -> ControlFlow<()>,
+    ) {
+        let mut current = self;
+        for key in path.0.iter() {
+            if !current.labels.is_empty() {
+                if (callback)(&current.worktree_relative_path, &current.labels).is_break() {
+                    return;
+                };
+            }
+            current = match current.children.get(key) {
+                Some(child) => child,
+                None => return,
+            };
+        }
+        if !current.labels.is_empty() {
+            (callback)(&current.worktree_relative_path, &current.labels);
+        }
+    }
+
+    pub(super) fn remove(&mut self, path: &TriePath) {
+        debug_assert_ne!(path.0.len(), 0);
+        let mut current = self;
+        for path in path.0.iter().take(path.0.len().saturating_sub(1)) {
+            current = match current.children.get_mut(path) {
+                Some(child) => child,
+                None => return,
+            };
+        }
+        if let Some(final_entry_name) = path.0.last() {
+            current.children.remove(final_entry_name);
+        }
+    }
+}
+
+/// [TriePath] is a [Path] preprocessed for amortizing the cost of doing multiple lookups in distinct [RootPathTrie]s.
+#[derive(Clone)]
+pub(super) struct TriePath(Arc<[Arc<OsStr>]>);
+
+impl From<&Path> for TriePath {
+    fn from(value: &Path) -> Self {
+        TriePath(value.components().map(|c| c.as_os_str().into()).collect())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::BTreeSet;
+
+    use super::*;
+
+    #[test]
+    fn test_insert_and_lookup() {
+        let mut trie = RootPathTrie::<()>::new();
+        trie.insert(
+            &TriePath::from(Path::new("a/b/c")),
+            (),
+            LabelPresence::Present,
+        );
+
+        trie.walk(&TriePath::from(Path::new("a/b/c")), &mut |path, nodes| {
+            assert_eq!(nodes.get(&()), Some(&LabelPresence::Present));
+            assert_eq!(path.as_ref(), Path::new("a/b/c"));
+            ControlFlow::Continue(())
+        });
+        // Now let's annotate a parent with "Known missing" node.
+        trie.insert(
+            &TriePath::from(Path::new("a")),
+            (),
+            LabelPresence::KnownAbsent,
+        );
+
+        // Ensure that we walk from the root to the leaf.
+        let mut visited_paths = BTreeSet::new();
+        trie.walk(&TriePath::from(Path::new("a/b/c")), &mut |path, nodes| {
+            if path.as_ref() == Path::new("a/b/c") {
+                assert_eq!(
+                    visited_paths,
+                    BTreeSet::from_iter([Arc::from(Path::new("a/"))])
+                );
+                assert_eq!(nodes.get(&()), Some(&LabelPresence::Present));
+            } else if path.as_ref() == Path::new("a/") {
+                assert!(visited_paths.is_empty());
+                assert_eq!(nodes.get(&()), Some(&LabelPresence::KnownAbsent));
+            } else {
+                panic!("Unknown path");
+            }
+            // Assert that we only ever visit a path once.
+            assert!(visited_paths.insert(path.clone()));
+            ControlFlow::Continue(())
+        });
+
+        // One can also pass a path whose prefix is in the tree, but not that path itself.
+        let mut visited_paths = BTreeSet::new();
+        trie.walk(
+            &TriePath::from(Path::new("a/b/c/d/e/f/g")),
+            &mut |path, nodes| {
+                if path.as_ref() == Path::new("a/b/c") {
+                    assert_eq!(
+                        visited_paths,
+                        BTreeSet::from_iter([Arc::from(Path::new("a/"))])
+                    );
+                    assert_eq!(nodes.get(&()), Some(&LabelPresence::Present));
+                } else if path.as_ref() == Path::new("a/") {
+                    assert!(visited_paths.is_empty());
+                    assert_eq!(nodes.get(&()), Some(&LabelPresence::KnownAbsent));
+                } else {
+                    panic!("Unknown path");
+                }
+                // Assert that we only ever visit a path once.
+                assert!(visited_paths.insert(path.clone()));
+                ControlFlow::Continue(())
+            },
+        );
+
+        // Test breaking from the tree-walk.
+        let mut visited_paths = BTreeSet::new();
+        trie.walk(&TriePath::from(Path::new("a/b/c")), &mut |path, nodes| {
+            if path.as_ref() == Path::new("a/") {
+                assert!(visited_paths.is_empty());
+                assert_eq!(nodes.get(&()), Some(&LabelPresence::KnownAbsent));
+            } else {
+                panic!("Unknown path");
+            }
+            // Assert that we only ever visit a path once.
+            assert!(visited_paths.insert(path.clone()));
+            ControlFlow::Break(())
+        });
+        assert_eq!(visited_paths.len(), 1);
+
+        // Entry removal.
+        trie.insert(
+            &TriePath::from(Path::new("a/b")),
+            (),
+            LabelPresence::KnownAbsent,
+        );
+        let mut visited_paths = BTreeSet::new();
+        trie.walk(&TriePath::from(Path::new("a/b/c")), &mut |path, _nodes| {
+            // Assert that we only ever visit a path once.
+            assert!(visited_paths.insert(path.clone()));
+            ControlFlow::Continue(())
+        });
+        assert_eq!(visited_paths.len(), 3);
+        trie.remove(&TriePath::from(Path::new("a/b/")));
+        let mut visited_paths = BTreeSet::new();
+        trie.walk(&TriePath::from(Path::new("a/b/c")), &mut |path, _nodes| {
+            // Assert that we only ever visit a path once.
+            assert!(visited_paths.insert(path.clone()));
+            ControlFlow::Continue(())
+        });
+        assert_eq!(visited_paths.len(), 1);
+        assert_eq!(
+            visited_paths.into_iter().next().unwrap().as_ref(),
+            Path::new("a/")
+        );
+    }
+}

crates/project/src/project_tree/server_tree.rs

@@ -0,0 +1,428 @@
+//! This module defines an LSP Tree.
+//!
+//! An LSP Tree is responsible for determining which language servers apply to a given project path.
+//!
+//! ## RPC
+//! LSP Tree is transparent to RPC peers; when clients ask host to spawn a new language server, the host will perform LSP Tree lookup for provided path; it may decide
+//! to reuse existing language server. The client maintains it's own LSP Tree that is a subset of host LSP Tree. Done this way, the client does not need to
+//! ask about suitable language server for each path it interacts with; it can resolve most of the queries locally.
+//! This module defines a Project Tree.
+
+use std::{
+    collections::{BTreeMap, BTreeSet},
+    path::Path,
+    sync::{Arc, Weak},
+};
+
+use collections::{HashMap, IndexMap};
+use gpui::{AppContext, Context as _, Model, Subscription};
+use language::{
+    language_settings::AllLanguageSettings, Attach, LanguageName, LanguageRegistry,
+    LspAdapterDelegate,
+};
+use lsp::LanguageServerName;
+use once_cell::sync::OnceCell;
+use settings::{Settings, SettingsLocation, WorktreeId};
+use util::maybe;
+
+use crate::{project_settings::LspSettings, LanguageServerId, ProjectPath};
+
+use super::{AdapterWrapper, ProjectTree, ProjectTreeEvent};
+
+#[derive(Debug, Default)]
+struct ServersForWorktree {
+    roots: BTreeMap<
+        Arc<Path>,
+        BTreeMap<LanguageServerName, (Arc<InnerTreeNode>, BTreeSet<LanguageName>)>,
+    >,
+}
+
+pub struct LanguageServerTree {
+    project_tree: Model<ProjectTree>,
+    instances: BTreeMap<WorktreeId, ServersForWorktree>,
+    attach_kind_cache: HashMap<LanguageServerName, Attach>,
+    languages: Arc<LanguageRegistry>,
+    _subscriptions: Subscription,
+}
+
+/// A node in language server tree represents either:
+/// - A language server that has already been initialized/updated for a given project
+/// - A soon-to-be-initialized language server.
+#[derive(Clone)]
+pub(crate) struct LanguageServerTreeNode(Weak<InnerTreeNode>);
+
+/// Describes a request to launch a language server.
+#[derive(Debug)]
+pub(crate) struct LaunchDisposition<'a> {
+    pub(crate) server_name: &'a LanguageServerName,
+    pub(crate) attach: Attach,
+    pub(crate) path: ProjectPath,
+    pub(crate) settings: Arc<LspSettings>,
+}
+
+impl<'a> From<&'a InnerTreeNode> for LaunchDisposition<'a> {
+    fn from(value: &'a InnerTreeNode) -> Self {
+        LaunchDisposition {
+            server_name: &value.name,
+            attach: value.attach,
+            path: value.path.clone(),
+            settings: value.settings.clone(),
+        }
+    }
+}
+impl LanguageServerTreeNode {
+    /// Returns a language server ID for this node if there is one.
+    /// Returns None if this node has not been initialized yet or it is no longer in the tree.
+    pub(crate) fn server_id(&self) -> Option<LanguageServerId> {
+        self.0.upgrade()?.id.get().copied()
+    }
+    /// Returns a language server ID for this node if it has already been initialized; otherwise runs the provided closure to initialize the language server node in a tree.
+    /// May return None if the node no longer belongs to the server tree it was created in.
+    pub(crate) fn server_id_or_init(
+        &self,
+        init: impl FnOnce(LaunchDisposition) -> LanguageServerId,
+    ) -> Option<LanguageServerId> {
+        self.server_id_or_try_init(|disposition| Ok(init(disposition)))
+    }
+    fn server_id_or_try_init(
+        &self,
+        init: impl FnOnce(LaunchDisposition) -> Result<LanguageServerId, ()>,
+    ) -> Option<LanguageServerId> {
+        let this = self.0.upgrade()?;
+        this.id
+            .get_or_try_init(|| init(LaunchDisposition::from(&*this)))
+            .ok()
+            .copied()
+    }
+}
+
+impl From<Weak<InnerTreeNode>> for LanguageServerTreeNode {
+    fn from(weak: Weak<InnerTreeNode>) -> Self {
+        LanguageServerTreeNode(weak)
+    }
+}
+
+#[derive(Debug)]
+struct InnerTreeNode {
+    id: OnceCell<LanguageServerId>,
+    name: LanguageServerName,
+    attach: Attach,
+    path: ProjectPath,
+    settings: Arc<LspSettings>,
+}
+
+impl InnerTreeNode {
+    fn new(
+        name: LanguageServerName,
+        attach: Attach,
+        path: ProjectPath,
+        settings: impl Into<Arc<LspSettings>>,
+    ) -> Self {
+        InnerTreeNode {
+            id: Default::default(),
+            name,
+            attach,
+            path,
+            settings: settings.into(),
+        }
+    }
+}
+
+impl LanguageServerTree {
+    pub(crate) fn new(
+        project_tree: Model<ProjectTree>,
+        languages: Arc<LanguageRegistry>,
+        cx: &mut AppContext,
+    ) -> Model<Self> {
+        cx.new_model(|cx| Self {
+            _subscriptions: cx.subscribe(
+                &project_tree,
+                |_: &mut Self, _, event, _| {
+                    if event == &ProjectTreeEvent::Cleared {}
+                },
+            ),
+            project_tree,
+            instances: Default::default(),
+            attach_kind_cache: Default::default(),
+            languages,
+        })
+    }
+    /// Memoize calls to attach_kind on LspAdapter (which might be a WASM extension, thus ~expensive to call).
+    fn attach_kind(&mut self, adapter: &AdapterWrapper) -> Attach {
+        *self
+            .attach_kind_cache
+            .entry(adapter.0.name.clone())
+            .or_insert_with(|| adapter.0.attach_kind())
+    }
+
+    /// Get all language server root points for a given path and language; the language servers might already be initialized at a given path.
+    pub(crate) fn get<'a>(
+        &'a mut self,
+        path: ProjectPath,
+        language_name: &LanguageName,
+        delegate: Arc<dyn LspAdapterDelegate>,
+        cx: &mut AppContext,
+    ) -> impl Iterator<Item = LanguageServerTreeNode> + 'a {
+        let settings_location = SettingsLocation {
+            worktree_id: path.worktree_id,
+            path: &path.path,
+        };
+        let adapters = self.adapters_for_language(settings_location, language_name, cx);
+        self.get_with_adapters(path, adapters, delegate, cx)
+    }
+
+    fn get_with_adapters<'a>(
+        &'a mut self,
+        path: ProjectPath,
+        adapters: IndexMap<AdapterWrapper, (LspSettings, BTreeSet<LanguageName>)>,
+        delegate: Arc<dyn LspAdapterDelegate>,
+        cx: &mut AppContext,
+    ) -> impl Iterator<Item = LanguageServerTreeNode> + 'a {
+        let worktree_id = path.worktree_id;
+        #[allow(clippy::mutable_key_type)]
+        let mut roots = self.project_tree.update(cx, |this, cx| {
+            this.root_for_path(
+                path,
+                adapters
+                    .iter()
+                    .map(|(adapter, _)| adapter.0.clone())
+                    .collect(),
+                delegate,
+                cx,
+            )
+        });
+        let mut root_path = None;
+        // Backwards-compat: Fill in any adapters for which we did not detect the root as having the project root at the root of a worktree.
+        for (adapter, _) in adapters.iter() {
+            roots.entry(adapter.clone()).or_insert_with(|| {
+                root_path
+                    .get_or_insert_with(|| ProjectPath {
+                        worktree_id,
+                        path: Arc::from("".as_ref()),
+                    })
+                    .clone()
+            });
+        }
+
+        roots.into_iter().filter_map(move |(adapter, root_path)| {
+            let attach = self.attach_kind(&adapter);
+            let (settings, new_languages) = adapters.get(&adapter).cloned()?;
+            let inner_node = self
+                .instances
+                .entry(root_path.worktree_id)
+                .or_default()
+                .roots
+                .entry(root_path.path.clone())
+                .or_default()
+                .entry(adapter.0.name.clone());
+            let (node, languages) = inner_node.or_insert_with(move || {
+                (
+                    Arc::new(InnerTreeNode::new(
+                        adapter.0.name(),
+                        attach,
+                        root_path,
+                        settings,
+                    )),
+                    Default::default(),
+                )
+            });
+            languages.extend(new_languages);
+            Some(Arc::downgrade(&node).into())
+        })
+    }
+
+    fn adapters_for_language(
+        &self,
+        settings_location: SettingsLocation,
+        language_name: &LanguageName,
+        cx: &AppContext,
+    ) -> IndexMap<AdapterWrapper, (LspSettings, BTreeSet<LanguageName>)> {
+        let settings = AllLanguageSettings::get(Some(settings_location), cx).language(
+            Some(settings_location),
+            Some(language_name),
+            cx,
+        );
+        if !settings.enable_language_server {
+            return Default::default();
+        }
+        let available_lsp_adapters = self.languages.lsp_adapters(&language_name);
+        let available_language_servers = available_lsp_adapters
+            .iter()
+            .map(|lsp_adapter| lsp_adapter.name.clone())
+            .collect::<Vec<_>>();
+
+        let desired_language_servers =
+            settings.customized_language_servers(&available_language_servers);
+        let adapters_with_settings = desired_language_servers
+            .into_iter()
+            .filter_map(|desired_adapter| {
+                let adapter = if let Some(adapter) = available_lsp_adapters
+                    .iter()
+                    .find(|adapter| adapter.name == desired_adapter)
+                {
+                    Some(adapter.clone())
+                } else if let Some(adapter) =
+                    self.languages.load_available_lsp_adapter(&desired_adapter)
+                {
+                    self.languages
+                        .register_lsp_adapter(language_name.clone(), adapter.adapter.clone());
+                    Some(adapter)
+                } else {
+                    None
+                }?;
+                let adapter_settings = crate::lsp_store::language_server_settings_for(
+                    settings_location,
+                    &adapter.name,
+                    cx,
+                )
+                .cloned()
+                .unwrap_or_default();
+                Some((
+                    AdapterWrapper(adapter),
+                    (
+                        adapter_settings,
+                        BTreeSet::from_iter([language_name.clone()]),
+                    ),
+                ))
+            })
+            .collect::<IndexMap<_, _>>();
+        adapters_with_settings
+    }
+
+    pub(crate) fn on_settings_changed(
+        &mut self,
+        get_delegate: &mut dyn FnMut(
+            WorktreeId,
+            &mut AppContext,
+        ) -> Option<Arc<dyn LspAdapterDelegate>>,
+        spawn_language_server: &mut dyn FnMut(
+            LaunchDisposition,
+            &mut AppContext,
+        ) -> LanguageServerId,
+        on_language_server_removed: &mut dyn FnMut(LanguageServerId),
+        cx: &mut AppContext,
+    ) {
+        // Settings are checked at query time. Thus, to avoid messing with inference of applicable settings, we're just going to clear ourselves and let the next query repopulate.
+        // We're going to optimistically re-run the queries and re-assign the same language server id when a language server still exists at a given tree node.
+        let old_instances = std::mem::take(&mut self.instances);
+        let old_attach_kinds = std::mem::take(&mut self.attach_kind_cache);
+
+        let mut referenced_instances = BTreeSet::new();
+        // Re-map the old tree onto a new one. In the process we'll get a list of servers we have to shut down.
+        let mut all_instances = BTreeSet::new();
+
+        for (worktree_id, servers) in &old_instances {
+            // Record all initialized node ids.
+            all_instances.extend(servers.roots.values().flat_map(|servers_at_node| {
+                servers_at_node
+                    .values()
+                    .filter_map(|(server_node, _)| server_node.id.get().copied())
+            }));
+            let Some(delegate) = get_delegate(*worktree_id, cx) else {
+                // If worktree is no longer around, we're just going to shut down all of the language servers (since they've been added to all_instances).
+                continue;
+            };
+
+            for (path, servers_for_path) in &servers.roots {
+                for (server_name, (_, languages)) in servers_for_path {
+                    let settings_location = SettingsLocation {
+                        worktree_id: *worktree_id,
+                        path: &path,
+                    };
+                    // Verify which of the previous languages still have this server enabled.
+
+                    let mut adapter_with_settings = IndexMap::default();
+
+                    for language_name in languages {
+                        self.adapters_for_language(settings_location, language_name, cx)
+                            .into_iter()
+                            .for_each(|(lsp_adapter, lsp_settings)| {
+                                if &lsp_adapter.0.name() != server_name {
+                                    return;
+                                }
+                                adapter_with_settings
+                                    .entry(lsp_adapter)
+                                    .and_modify(|x: &mut (_, BTreeSet<LanguageName>)| {
+                                        x.1.extend(lsp_settings.1.clone())
+                                    })
+                                    .or_insert(lsp_settings);
+                            });
+                    }
+
+                    if adapter_with_settings.is_empty() {
+                        // Since all languages that have had this server enabled are now disabled, we can remove the server entirely.
+                        continue;
+                    };
+
+                    for new_node in self.get_with_adapters(
+                        ProjectPath {
+                            path: path.clone(),
+                            worktree_id: *worktree_id,
+                        },
+                        adapter_with_settings,
+                        delegate.clone(),
+                        cx,
+                    ) {
+                        new_node.server_id_or_try_init(|disposition| {
+                            let Some((existing_node, _)) = servers
+                                .roots
+                                .get(&disposition.path.path)
+                                .and_then(|roots| roots.get(disposition.server_name))
+                                .filter(|(old_node, _)| {
+                                    old_attach_kinds.get(disposition.server_name).map_or(
+                                        false,
+                                        |old_attach| {
+                                            disposition.attach == *old_attach
+                                                && disposition.settings == old_node.settings
+                                        },
+                                    )
+                                })
+                            else {
+                                return Ok(spawn_language_server(disposition, cx));
+                            };
+                            if let Some(id) = existing_node.id.get().copied() {
+                                // If we have a node with ID assigned (and it's parameters match `disposition`), reuse the id.
+                                referenced_instances.insert(id);
+                                Ok(id)
+                            } else {
+                                // Otherwise, if we do have a node but it does not have an ID assigned, keep it that way.
+                                Err(())
+                            }
+                        });
+                    }
+                }
+            }
+        }
+        for server_to_remove in all_instances.difference(&referenced_instances) {
+            on_language_server_removed(*server_to_remove);
+        }
+    }
+
+    /// Updates nodes in language server tree in place, changing the ID of initialized nodes.
+    pub(crate) fn restart_language_servers(
+        &mut self,
+        worktree_id: WorktreeId,
+        ids: BTreeSet<LanguageServerId>,
+        restart_callback: &mut dyn FnMut(LanguageServerId, LaunchDisposition) -> LanguageServerId,
+    ) {
+        maybe! {{
+                for (_, nodes) in &mut self.instances.get_mut(&worktree_id)?.roots {
+                    for (_, (node, _)) in nodes {
+                        let Some(old_server_id) = node.id.get().copied() else {
+                            continue;
+                        };
+                        if !ids.contains(&old_server_id) {
+                            continue;
+                        }
+
+                        let new_id = restart_callback(old_server_id, LaunchDisposition::from(&**node));
+
+                        *node = Arc::new(InnerTreeNode::new(node.name.clone(), node.attach, node.path.clone(), node.settings.clone()));
+                        node.id.set(new_id).expect("The id to be unset after clearing the node.");
+                    }
+            }
+            Some(())
+        }
+        };
+    }
+}