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/editor/src/editor.rs

@@ -12476,28 +12476,27 @@ impl Editor {
                 cx.emit(SearchEvent::MatchesInvalidated);
                 if *singleton_buffer_edited {
                     if let Some(project) = &self.project {
-                        let project = project.read(cx);
                         #[allow(clippy::mutable_key_type)]
-                        let languages_affected = multibuffer
-                            .read(cx)
-                            .all_buffers()
-                            .into_iter()
-                            .filter_map(|buffer| {
-                                let buffer = buffer.read(cx);
-                                let language = buffer.language()?;
-                                if project.is_local()
-                                    && project
-                                        .language_servers_for_local_buffer(buffer, cx)
-                                        .count()
-                                        == 0
-                                {
-                                    None
-                                } else {
-                                    Some(language)
-                                }
-                            })
-                            .cloned()
-                            .collect::<HashSet<_>>();
+                        let languages_affected = multibuffer.update(cx, |multibuffer, cx| {
+                            multibuffer
+                                .all_buffers()
+                                .into_iter()
+                                .filter_map(|buffer| {
+                                    buffer.update(cx, |buffer, cx| {
+                                        let language = buffer.language()?;
+                                        let should_discard = project.update(cx, |project, cx| {
+                                            project.is_local()
+                                                && project.for_language_servers_for_local_buffer(
+                                                    buffer,
+                                                    |it| it.count() == 0,
+                                                    cx,
+                                                )
+                                        });
+                                        should_discard.not().then_some(language.clone())
+                                    })
+                                })
+                                .collect::<HashSet<_>>()
+                        });
                         if !languages_affected.is_empty() {
                             self.refresh_inlay_hints(
                                 InlayHintRefreshReason::BufferEdited(languages_affected),
@@ -13051,15 +13050,18 @@ impl Editor {
         self.handle_input(text, cx);
     }
 
-    pub fn supports_inlay_hints(&self, cx: &AppContext) -> bool {
+    pub fn supports_inlay_hints(&self, cx: &mut AppContext) -> bool {
         let Some(provider) = self.semantics_provider.as_ref() else {
             return false;
         };
 
         let mut supports = false;
-        self.buffer().read(cx).for_each_buffer(|buffer| {
-            supports |= provider.supports_inlay_hints(buffer, cx);
+        self.buffer().update(cx, |this, cx| {
+            this.for_each_buffer(|buffer| {
+                supports |= provider.supports_inlay_hints(buffer, cx);
+            })
         });
+
         supports
     }
 
@@ -13671,7 +13673,7 @@ pub trait SemanticsProvider {
         cx: &mut AppContext,
     ) -> Option<Task<anyhow::Result<InlayHint>>>;
 
-    fn supports_inlay_hints(&self, buffer: &Model<Buffer>, cx: &AppContext) -> bool;
+    fn supports_inlay_hints(&self, buffer: &Model<Buffer>, cx: &mut AppContext) -> bool;
 
     fn document_highlights(
         &self,
@@ -14056,17 +14058,25 @@ impl SemanticsProvider for Model<Project> {
         }))
     }
 
-    fn supports_inlay_hints(&self, buffer: &Model<Buffer>, cx: &AppContext) -> bool {
+    fn supports_inlay_hints(&self, buffer: &Model<Buffer>, cx: &mut AppContext) -> bool {
         // TODO: make this work for remote projects
-        self.read(cx)
-            .language_servers_for_local_buffer(buffer.read(cx), cx)
-            .any(
-                |(_, server)| match server.capabilities().inlay_hint_provider {
-                    Some(lsp::OneOf::Left(enabled)) => enabled,
-                    Some(lsp::OneOf::Right(_)) => true,
-                    None => false,
-                },
-            )
+        buffer.update(cx, |buffer, cx| {
+            self.update(cx, |this, cx| {
+                this.for_language_servers_for_local_buffer(
+                    buffer,
+                    |mut it| {
+                        it.any(
+                            |(_, server)| match server.capabilities().inlay_hint_provider {
+                                Some(lsp::OneOf::Left(enabled)) => enabled,
+                                Some(lsp::OneOf::Right(_)) => true,
+                                None => false,
+                            },
+                        )
+                    },
+                    cx,
+                )
+            })
+        })
     }
 
     fn inlay_hints(

crates/editor/src/editor_tests.rs

@@ -6839,7 +6839,7 @@ async fn test_document_format_during_save(cx: &mut gpui::TestAppContext) {
     let fs = FakeFs::new(cx.executor());
     fs.insert_file("/file.rs", Default::default()).await;
 
-    let project = Project::test(fs, ["/file.rs".as_ref()], cx).await;
+    let project = Project::test(fs, ["/".as_ref()], cx).await;
 
     let language_registry = project.read_with(cx, |project, _| project.languages().clone());
     language_registry.add(rust_lang());
@@ -7193,7 +7193,7 @@ async fn test_range_format_during_save(cx: &mut gpui::TestAppContext) {
     let fs = FakeFs::new(cx.executor());
     fs.insert_file("/file.rs", Default::default()).await;
 
-    let project = Project::test(fs, ["/file.rs".as_ref()], cx).await;
+    let project = Project::test(fs, ["/".as_ref()], cx).await;
 
     let language_registry = project.read_with(cx, |project, _| project.languages().clone());
     language_registry.add(rust_lang());
@@ -7327,7 +7327,7 @@ async fn test_document_format_manual_trigger(cx: &mut gpui::TestAppContext) {
     let fs = FakeFs::new(cx.executor());
     fs.insert_file("/file.rs", Default::default()).await;
 
-    let project = Project::test(fs, ["/file.rs".as_ref()], cx).await;
+    let project = Project::test(fs, ["/".as_ref()], cx).await;
 
     let language_registry = project.read_with(cx, |project, _| project.languages().clone());
     language_registry.add(Arc::new(Language::new(
@@ -10742,7 +10742,6 @@ async fn test_language_server_restart_due_to_settings_change(cx: &mut gpui::Test
         0,
         "Should not restart LSP server on an unrelated LSP settings change"
     );
-
     update_test_project_settings(cx, |project_settings| {
         project_settings.lsp.insert(
             language_server_name.into(),

crates/editor/src/lsp_ext.rs

@@ -11,7 +11,7 @@ use multi_buffer::Anchor;
 
 pub(crate) fn find_specific_language_server_in_selection<F>(
     editor: &Editor,
-    cx: &WindowContext,
+    cx: &mut WindowContext,
     filter_language: F,
     language_server_name: &str,
 ) -> Option<(Anchor, Arc<Language>, LanguageServerId, Model<Buffer>)>
@@ -21,7 +21,6 @@ where
     let Some(project) = &editor.project else {
         return None;
     };
-    let multibuffer = editor.buffer().read(cx);
     let mut language_servers_for = HashMap::default();
     editor
         .selections
@@ -29,29 +28,33 @@ where
         .iter()
         .filter(|selection| selection.start == selection.end)
         .filter_map(|selection| Some((selection.start.buffer_id?, selection.start)))
-        .filter_map(|(buffer_id, trigger_anchor)| {
-            let buffer = multibuffer.buffer(buffer_id)?;
+        .find_map(|(buffer_id, trigger_anchor)| {
+            let buffer = editor.buffer().read(cx).buffer(buffer_id)?;
             let server_id = *match language_servers_for.entry(buffer_id) {
                 Entry::Occupied(occupied_entry) => occupied_entry.into_mut(),
                 Entry::Vacant(vacant_entry) => {
-                    let language_server_id = project
-                        .read(cx)
-                        .language_servers_for_local_buffer(buffer.read(cx), cx)
-                        .find_map(|(adapter, server)| {
-                            if adapter.name.0.as_ref() == language_server_name {
-                                Some(server.server_id())
-                            } else {
-                                None
-                            }
-                        });
+                    let language_server_id = buffer.update(cx, |buffer, cx| {
+                        project.update(cx, |project, cx| {
+                            project.for_language_servers_for_local_buffer(
+                                buffer,
+                                |mut it| {
+                                    it.find_map(|(adapter, server)| {
+                                        if adapter.name.0.as_ref() == language_server_name {
+                                            Some(server.server_id())
+                                        } else {
+                                            None
+                                        }
+                                    })
+                                },
+                                cx,
+                            )
+                        })
+                    });
                     vacant_entry.insert(language_server_id)
                 }
             }
             .as_ref()?;
 
-            Some((buffer, trigger_anchor, server_id))
-        })
-        .find_map(|(buffer, trigger_anchor, server_id)| {
             let language = buffer.read(cx).language_at(trigger_anchor.text_anchor)?;
             if !filter_language(&language) {
                 return None;

crates/editor/src/proposed_changes_editor.rs

@@ -455,7 +455,7 @@ impl SemanticsProvider for BranchBufferSemanticsProvider {
         self.0.resolve_inlay_hint(hint, buffer, server_id, cx)
     }
 
-    fn supports_inlay_hints(&self, buffer: &Model<Buffer>, cx: &AppContext) -> bool {
+    fn supports_inlay_hints(&self, buffer: &Model<Buffer>, cx: &mut AppContext) -> bool {
         if let Some(buffer) = self.to_base(&buffer, &[], cx) {
             self.0.supports_inlay_hints(&buffer, cx)
         } else {