Merge pull request #2293 from zed-industries/yaml-hover-bug

Fix hover popover rendering lots of `&emsp` for YAML
2023-03-16 16:15:14 +01:00
parent ed9927b495 9498f02f2c
commit 356b8c6980
11 changed files with 421 additions and 195 deletions
@@ -44,7 +44,7 @@ use syntax_map::SyntaxSnapshot;
 use theme::{SyntaxTheme, Theme};
 use tree_sitter::{self, Query};
 use unicase::UniCase;
-use util::{ResultExt, TryFutureExt as _, UnwrapFuture};
+use util::{merge_json_value_into, post_inc, ResultExt, TryFutureExt as _, UnwrapFuture};

 #[cfg(any(test, feature = "test-support"))]
 use futures::channel::mpsc;
@@ -87,11 +87,11 @@ pub struct CachedLspAdapter {
    pub disk_based_diagnostic_sources: Vec<String>,
    pub disk_based_diagnostics_progress_token: Option<String>,
    pub language_ids: HashMap<String, String>,
-    pub adapter: Box<dyn LspAdapter>,
+    pub adapter: Arc<dyn LspAdapter>,
 }

 impl CachedLspAdapter {
-    pub async fn new(adapter: Box<dyn LspAdapter>) -> Arc<Self> {
+    pub async fn new(adapter: Arc<dyn LspAdapter>) -> Arc<Self> {
        let name = adapter.name().await;
        let server_args = adapter.server_args().await;
        let initialization_options = adapter.initialization_options().await;
@@ -133,6 +133,13 @@ impl CachedLspAdapter {
        self.adapter.cached_server_binary(container_dir).await
    }

+    pub fn workspace_configuration(
+        &self,
+        cx: &mut MutableAppContext,
+    ) -> Option<BoxFuture<'static, Value>> {
+        self.adapter.workspace_configuration(cx)
+    }
+
    pub async fn process_diagnostics(&self, params: &mut lsp::PublishDiagnosticsParams) {
        self.adapter.process_diagnostics(params).await
    }
@@ -208,6 +215,13 @@ pub trait LspAdapter: 'static + Send + Sync {
        None
    }

+    fn workspace_configuration(
+        &self,
+        _: &mut MutableAppContext,
+    ) -> Option<BoxFuture<'static, Value>> {
+        None
+    }
+
    async fn disk_based_diagnostic_sources(&self) -> Vec<String> {
        Default::default()
    }
@@ -228,7 +242,7 @@ pub struct CodeLabel {
    pub filter_range: Range<usize>,
 }

-#[derive(Deserialize)]
+#[derive(Clone, Deserialize)]
 pub struct LanguageConfig {
    pub name: Arc<str>,
    pub path_suffixes: Vec<String>,
@@ -265,7 +279,7 @@ pub struct LanguageScope {
    override_id: Option<u32>,
 }

-#[derive(Deserialize, Default, Debug)]
+#[derive(Clone, Deserialize, Default, Debug)]
 pub struct LanguageConfigOverride {
    #[serde(default)]
    pub line_comment: Override<Arc<str>>,
@@ -275,7 +289,7 @@ pub struct LanguageConfigOverride {
    pub disabled_bracket_ixs: Vec<u16>,
 }

-#[derive(Deserialize, Debug)]
+#[derive(Clone, Deserialize, Debug)]
 #[serde(untagged)]
 pub enum Override<T> {
    Remove { remove: bool },
@@ -452,17 +466,20 @@ pub enum LanguageServerBinaryStatus {
    Failed { error: String },
 }

+type AvailableLanguageId = usize;
+
+#[derive(Clone)]
 struct AvailableLanguage {
+    id: AvailableLanguageId,
    path: &'static str,
    config: LanguageConfig,
    grammar: tree_sitter::Language,
-    lsp_adapter: Option<Box<dyn LspAdapter>>,
+    lsp_adapter: Option<Arc<dyn LspAdapter>>,
    get_queries: fn(&str) -> LanguageQueries,
 }

 pub struct LanguageRegistry {
-    languages: RwLock<Vec<Arc<Language>>>,
-    available_languages: RwLock<Vec<AvailableLanguage>>,
+    state: RwLock<LanguageRegistryState>,
    language_server_download_dir: Option<Arc<Path>>,
    lsp_binary_statuses_tx: async_broadcast::Sender<(Arc<Language>, LanguageServerBinaryStatus)>,
    lsp_binary_statuses_rx: async_broadcast::Receiver<(Arc<Language>, LanguageServerBinaryStatus)>,
@@ -474,26 +491,37 @@ pub struct LanguageRegistry {
            Shared<BoxFuture<'static, Result<PathBuf, Arc<anyhow::Error>>>>,
        >,
    >,
-    subscription: RwLock<(watch::Sender<()>, watch::Receiver<()>)>,
-    theme: RwLock<Option<Arc<Theme>>>,
    executor: Option<Arc<Background>>,
-    version: AtomicUsize,
+}
+
+struct LanguageRegistryState {
+    languages: Vec<Arc<Language>>,
+    available_languages: Vec<AvailableLanguage>,
+    next_available_language_id: AvailableLanguageId,
+    loading_languages: HashMap<AvailableLanguageId, Vec<oneshot::Sender<Result<Arc<Language>>>>>,
+    subscription: (watch::Sender<()>, watch::Receiver<()>),
+    theme: Option<Arc<Theme>>,
+    version: usize,
 }

 impl LanguageRegistry {
    pub fn new(login_shell_env_loaded: Task<()>) -> Self {
        let (lsp_binary_statuses_tx, lsp_binary_statuses_rx) = async_broadcast::broadcast(16);
        Self {
+            state: RwLock::new(LanguageRegistryState {
+                languages: vec![PLAIN_TEXT.clone()],
+                available_languages: Default::default(),
+                next_available_language_id: 0,
+                loading_languages: Default::default(),
+                subscription: watch::channel(),
+                theme: Default::default(),
+                version: 0,
+            }),
            language_server_download_dir: None,
-            languages: RwLock::new(vec![PLAIN_TEXT.clone()]),
-            available_languages: Default::default(),
            lsp_binary_statuses_tx,
            lsp_binary_statuses_rx,
            login_shell_env_loaded: login_shell_env_loaded.shared(),
            lsp_binary_paths: Default::default(),
-            subscription: RwLock::new(watch::channel()),
-            theme: Default::default(),
-            version: Default::default(),
            executor: None,
        }
    }
@@ -512,10 +540,12 @@ impl LanguageRegistry {
        path: &'static str,
        config: LanguageConfig,
        grammar: tree_sitter::Language,
-        lsp_adapter: Option<Box<dyn LspAdapter>>,
+        lsp_adapter: Option<Arc<dyn LspAdapter>>,
        get_queries: fn(&str) -> LanguageQueries,
    ) {
-        self.available_languages.write().push(AvailableLanguage {
+        let state = &mut *self.state.write();
+        state.available_languages.push(AvailableLanguage {
+            id: post_inc(&mut state.next_available_language_id),
            path,
            config,
            grammar,
@@ -525,42 +555,61 @@ impl LanguageRegistry {
    }

    pub fn language_names(&self) -> Vec<String> {
-        let mut result = self
+        let state = self.state.read();
+        let mut result = state
            .available_languages
-            .read()
            .iter()
            .map(|l| l.config.name.to_string())
-            .chain(
-                self.languages
-                    .read()
-                    .iter()
-                    .map(|l| l.config.name.to_string()),
-            )
+            .chain(state.languages.iter().map(|l| l.config.name.to_string()))
            .collect::<Vec<_>>();
        result.sort_unstable_by_key(|language_name| language_name.to_lowercase());
        result
    }

-    pub fn add(&self, language: Arc<Language>) {
-        if let Some(theme) = self.theme.read().clone() {
-            language.set_theme(&theme.editor.syntax);
+    pub fn workspace_configuration(&self, cx: &mut MutableAppContext) -> Task<serde_json::Value> {
+        let state = self.state.read();
+        let mut language_configs = Vec::new();
+        for language in &state.available_languages {
+            if let Some(adapter) = language.lsp_adapter.as_ref() {
+                if let Some(language_config) = adapter.workspace_configuration(cx) {
+                    language_configs.push(language_config);
+                }
+            }
        }
-        self.languages.write().push(language);
-        self.version.fetch_add(1, SeqCst);
-        *self.subscription.write().0.borrow_mut() = ();
+        for language in &state.languages {
+            if let Some(adapter) = language.lsp_adapter() {
+                if let Some(language_config) = adapter.workspace_configuration(cx) {
+                    language_configs.push(language_config);
+                }
+            }
+        }
+
+        cx.background().spawn(async move {
+            let mut config = serde_json::json!({});
+            let language_configs = futures::future::join_all(language_configs).await;
+            for language_config in language_configs {
+                merge_json_value_into(language_config, &mut config);
+            }
+            config
+        })
+    }
+
+    pub fn add(&self, language: Arc<Language>) {
+        self.state.write().add(language);
    }

    pub fn subscribe(&self) -> watch::Receiver<()> {
-        self.subscription.read().1.clone()
+        self.state.read().subscription.1.clone()
    }

    pub fn version(&self) -> usize {
-        self.version.load(SeqCst)
+        self.state.read().version
    }

    pub fn set_theme(&self, theme: Arc<Theme>) {
-        *self.theme.write() = Some(theme.clone());
-        for language in self.languages.read().iter() {
+        let mut state = self.state.write();
+        state.theme = Some(theme.clone());
+        for language in &state.languages {
            language.set_theme(&theme.editor.syntax);
        }
    }
@@ -613,43 +662,70 @@ impl LanguageRegistry {
    ) -> UnwrapFuture<oneshot::Receiver<Result<Arc<Language>>>> {
        let (tx, rx) = oneshot::channel();

-        if let Some(language) = self
+        let mut state = self.state.write();
+        if let Some(language) = state
            .languages
-            .read()
            .iter()
            .find(|language| callback(&language.config))
        {
            let _ = tx.send(Ok(language.clone()));
        } else if let Some(executor) = self.executor.clone() {
-            let mut available_languages = self.available_languages.write();
+            if let Some(language) = state
+                .available_languages
+                .iter()
+                .find(|l| callback(&l.config))
+                .cloned()
+            {
+                let txs = state
+                    .loading_languages
+                    .entry(language.id)
+                    .or_insert_with(|| {
+                        let this = self.clone();
+                        executor
+                            .spawn(async move {
+                                let id = language.id;
+                                let queries = (language.get_queries)(&language.path);
+                                let language =
+                                    Language::new(language.config, Some(language.grammar))
+                                        .with_lsp_adapter(language.lsp_adapter)
+                                        .await;
+                                let name = language.name();
+                                match language.with_queries(queries) {
+                                    Ok(language) => {
+                                        let language = Arc::new(language);
+                                        let mut state = this.state.write();
+                                        state.add(language.clone());
+                                        state
+                                            .available_languages
+                                            .retain(|language| language.id != id);
+                                        if let Some(mut txs) = state.loading_languages.remove(&id) {
+                                            for tx in txs.drain(..) {
+                                                let _ = tx.send(Ok(language.clone()));
+                                            }
+                                        }
+                                    }
+                                    Err(err) => {
+                                        let mut state = this.state.write();
+                                        state
+                                            .available_languages
+                                            .retain(|language| language.id != id);
+                                        if let Some(mut txs) = state.loading_languages.remove(&id) {
+                                            for tx in txs.drain(..) {
+                                                let _ = tx.send(Err(anyhow!(
+                                                    "failed to load language {}: {}",
+                                                    name,
+                                                    err
+                                                )));
+                                            }
+                                        }
+                                    }
+                                };
+                            })
+                            .detach();

-            if let Some(ix) = available_languages.iter().position(|l| callback(&l.config)) {
-                let language = available_languages.remove(ix);
-                drop(available_languages);
-                let name = language.config.name.clone();
-                let this = self.clone();
-                executor
-                    .spawn(async move {
-                        let queries = (language.get_queries)(&language.path);
-                        let language = Language::new(language.config, Some(language.grammar))
-                            .with_lsp_adapter(language.lsp_adapter)
-                            .await;
-                        match language.with_queries(queries) {
-                            Ok(language) => {
-                                let language = Arc::new(language);
-                                this.add(language.clone());
-                                let _ = tx.send(Ok(language));
-                            }
-                            Err(err) => {
-                                let _ = tx.send(Err(anyhow!(
-                                    "failed to load language {}: {}",
-                                    name,
-                                    err
-                                )));
-                            }
-                        };
-                    })
-                    .detach();
+                        Vec::new()
+                    });
+                txs.push(tx);
            } else {
                let _ = tx.send(Err(anyhow!("language not found")));
            }
@@ -661,7 +737,7 @@ impl LanguageRegistry {
    }

    pub fn to_vec(&self) -> Vec<Arc<Language>> {
-        self.languages.read().iter().cloned().collect()
+        self.state.read().languages.iter().cloned().collect()
    }

    pub fn start_language_server(
@@ -754,6 +830,17 @@ impl LanguageRegistry {
    }
 }

+impl LanguageRegistryState {
+    fn add(&mut self, language: Arc<Language>) {
+        if let Some(theme) = self.theme.as_ref() {
+            language.set_theme(&theme.editor.syntax);
+        }
+        self.languages.push(language);
+        self.version += 1;
+        *self.subscription.0.borrow_mut() = ();
+    }
+}
+
 #[cfg(any(test, feature = "test-support"))]
 impl Default for LanguageRegistry {
    fn default() -> Self {
@@ -1085,7 +1172,7 @@ impl Language {
        Arc::get_mut(self.grammar.as_mut().unwrap()).unwrap()
    }

-    pub async fn with_lsp_adapter(mut self, lsp_adapter: Option<Box<dyn LspAdapter>>) -> Self {
+    pub async fn with_lsp_adapter(mut self, lsp_adapter: Option<Arc<dyn LspAdapter>>) -> Self {
        if let Some(adapter) = lsp_adapter {
            self.adapter = Some(CachedLspAdapter::new(adapter).await);
        }
@@ -1099,7 +1186,7 @@ impl Language {
    ) -> mpsc::UnboundedReceiver<lsp::FakeLanguageServer> {
        let (servers_tx, servers_rx) = mpsc::unbounded();
        self.fake_adapter = Some((servers_tx, fake_lsp_adapter.clone()));
-        let adapter = CachedLspAdapter::new(Box::new(fake_lsp_adapter)).await;
+        let adapter = CachedLspAdapter::new(Arc::new(fake_lsp_adapter)).await;
        self.adapter = Some(adapter);
        servers_rx
    }
@@ -1415,3 +1502,76 @@ pub fn range_from_lsp(range: lsp::Range) -> Range<Unclipped<PointUtf16>> {
    }
    start..end
 }
+
+#[cfg(test)]
+mod tests {
+    use gpui::TestAppContext;
+
+    use super::*;
+
+    #[gpui::test(iterations = 10)]
+    async fn test_language_loading(cx: &mut TestAppContext) {
+        let mut languages = LanguageRegistry::new(Task::ready(()));
+        languages.set_executor(cx.background());
+        let languages = Arc::new(languages);
+        languages.register(
+            "/JSON",
+            LanguageConfig {
+                name: "JSON".into(),
+                path_suffixes: vec!["json".into()],
+                ..Default::default()
+            },
+            tree_sitter_json::language(),
+            None,
+            |_| Default::default(),
+        );
+        languages.register(
+            "/rust",
+            LanguageConfig {
+                name: "Rust".into(),
+                path_suffixes: vec!["rs".into()],
+                ..Default::default()
+            },
+            tree_sitter_rust::language(),
+            None,
+            |_| Default::default(),
+        );
+        assert_eq!(
+            languages.language_names(),
+            &[
+                "JSON".to_string(),
+                "Plain Text".to_string(),
+                "Rust".to_string(),
+            ]
+        );
+
+        let rust1 = languages.language_for_name("Rust");
+        let rust2 = languages.language_for_name("Rust");
+
+        // Ensure language is still listed even if it's being loaded.
+        assert_eq!(
+            languages.language_names(),
+            &[
+                "JSON".to_string(),
+                "Plain Text".to_string(),
+                "Rust".to_string(),
+            ]
+        );
+
+        let (rust1, rust2) = futures::join!(rust1, rust2);
+        assert!(Arc::ptr_eq(&rust1.unwrap(), &rust2.unwrap()));
+
+        // Ensure language is still listed even after loading it.
+        assert_eq!(
+            languages.language_names(),
+            &[
+                "JSON".to_string(),
+                "Plain Text".to_string(),
+                "Rust".to_string(),
+            ]
+        );
+
+        // Loading an unknown language returns an error.
+        assert!(languages.language_for_name("Unknown").await.is_err());
+    }
+}
@@ -37,7 +37,6 @@ use lsp::{
    MarkedString,
 };
 use lsp_command::*;
-use parking_lot::Mutex;
 use postage::watch;
 use rand::prelude::*;
 use search::SearchQuery;
@@ -64,7 +63,7 @@ use std::{
 };
 use terminals::Terminals;

-use util::{debug_panic, defer, post_inc, ResultExt, TryFutureExt as _};
+use util::{debug_panic, defer, merge_json_value_into, post_inc, ResultExt, TryFutureExt as _};

 pub use fs::*;
 pub use worktree::*;
@@ -95,7 +94,6 @@ pub struct Project {
    language_servers: HashMap<usize, LanguageServerState>,
    language_server_ids: HashMap<(WorktreeId, LanguageServerName), usize>,
    language_server_statuses: BTreeMap<usize, LanguageServerStatus>,
-    language_server_settings: Arc<Mutex<serde_json::Value>>,
    last_workspace_edits_by_language_server: HashMap<usize, ProjectTransaction>,
    next_language_server_id: usize,
    client: Arc<client::Client>,
@@ -125,6 +123,7 @@ pub struct Project {
    buffers_being_formatted: HashSet<usize>,
    nonce: u128,
    _maintain_buffer_languages: Task<()>,
+    _maintain_workspace_config: Task<()>,
    terminals: Terminals,
 }

@@ -428,6 +427,7 @@ impl Project {
            client_subscriptions: Vec::new(),
            _subscriptions: vec![cx.observe_global::<Settings, _>(Self::on_settings_changed)],
            _maintain_buffer_languages: Self::maintain_buffer_languages(&languages, cx),
+            _maintain_workspace_config: Self::maintain_workspace_config(languages.clone(), cx),
            active_entry: None,
            languages,
            client,
@@ -439,7 +439,6 @@ impl Project {
            language_server_ids: Default::default(),
            language_server_statuses: Default::default(),
            last_workspace_edits_by_language_server: Default::default(),
-            language_server_settings: Default::default(),
            buffers_being_formatted: Default::default(),
            next_language_server_id: 0,
            nonce: StdRng::from_entropy().gen(),
@@ -486,6 +485,7 @@ impl Project {
                active_entry: None,
                collaborators: Default::default(),
                _maintain_buffer_languages: Self::maintain_buffer_languages(&languages, cx),
+                _maintain_workspace_config: Self::maintain_workspace_config(languages.clone(), cx),
                languages,
                user_store: user_store.clone(),
                fs,
@@ -501,7 +501,6 @@ impl Project {
                }),
                language_servers: Default::default(),
                language_server_ids: Default::default(),
-                language_server_settings: Default::default(),
                language_server_statuses: response
                    .language_servers
                    .into_iter()
@@ -1836,6 +1835,42 @@ impl Project {
        })
    }

+    fn maintain_workspace_config(
+        languages: Arc<LanguageRegistry>,
+        cx: &mut ModelContext<Project>,
+    ) -> Task<()> {
+        let (mut settings_changed_tx, mut settings_changed_rx) = watch::channel();
+        let _ = postage::stream::Stream::try_recv(&mut settings_changed_rx);
+
+        let settings_observation = cx.observe_global::<Settings, _>(move |_, _| {
+            *settings_changed_tx.borrow_mut() = ();
+        });
+        cx.spawn_weak(|this, mut cx| async move {
+            while let Some(_) = settings_changed_rx.next().await {
+                let workspace_config = cx.update(|cx| languages.workspace_configuration(cx)).await;
+                if let Some(this) = this.upgrade(&cx) {
+                    this.read_with(&cx, |this, _| {
+                        for server_state in this.language_servers.values() {
+                            if let LanguageServerState::Running { server, .. } = server_state {
+                                server
+                                    .notify::<lsp::notification::DidChangeConfiguration>(
+                                        lsp::DidChangeConfigurationParams {
+                                            settings: workspace_config.clone(),
+                                        },
+                                    )
+                                    .ok();
+                            }
+                        }
+                    })
+                } else {
+                    break;
+                }
+            }
+
+            drop(settings_observation);
+        })
+    }
+
    fn detect_language_for_buffer(
        &mut self,
        buffer: &ModelHandle<Buffer>,
@@ -1875,24 +1910,6 @@ impl Project {
        }
    }

-    fn merge_json_value_into(source: serde_json::Value, target: &mut serde_json::Value) {
-        use serde_json::Value;
-
-        match (source, target) {
-            (Value::Object(source), Value::Object(target)) => {
-                for (key, value) in source {
-                    if let Some(target) = target.get_mut(&key) {
-                        Self::merge_json_value_into(value, target);
-                    } else {
-                        target.insert(key.clone(), value);
-                    }
-                }
-            }
-
-            (source, target) => *target = source,
-        }
-    }
-
    fn start_language_server(
        &mut self,
        worktree_id: WorktreeId,
@@ -1920,17 +1937,16 @@ impl Project {
        let override_options = lsp.map(|s| s.initialization_options.clone()).flatten();
        match (&mut initialization_options, override_options) {
            (Some(initialization_options), Some(override_options)) => {
-                Self::merge_json_value_into(override_options, initialization_options);
+                merge_json_value_into(override_options, initialization_options);
            }
-
            (None, override_options) => initialization_options = override_options,
-
            _ => {}
        }

        self.language_server_ids
            .entry(key.clone())
            .or_insert_with(|| {
+                let languages = self.languages.clone();
                let server_id = post_inc(&mut self.next_language_server_id);
                let language_server = self.languages.start_language_server(
                    server_id,
@@ -1942,6 +1958,8 @@ impl Project {
                self.language_servers.insert(
                    server_id,
                    LanguageServerState::Starting(cx.spawn_weak(|this, mut cx| async move {
+                        let workspace_config =
+                            cx.update(|cx| languages.workspace_configuration(cx)).await;
                        let language_server = language_server?.await.log_err()?;
                        let language_server = language_server
                            .initialize(initialization_options)
@@ -1977,23 +1995,24 @@ impl Project {

                        language_server
                            .on_request::<lsp::request::WorkspaceConfiguration, _, _>({
-                                let settings = this.read_with(&cx, |this, _| {
-                                    this.language_server_settings.clone()
-                                });
-                                move |params, _| {
-                                    let settings = settings.lock().clone();
+                                let languages = languages.clone();
+                                move |params, mut cx| {
+                                    let languages = languages.clone();
                                    async move {
+                                        let workspace_config = cx
+                                            .update(|cx| languages.workspace_configuration(cx))
+                                            .await;
                                        Ok(params
                                            .items
                                            .into_iter()
                                            .map(|item| {
                                                if let Some(section) = &item.section {
-                                                    settings
+                                                    workspace_config
                                                        .get(section)
                                                        .cloned()
                                                        .unwrap_or(serde_json::Value::Null)
                                                } else {
-                                                    settings.clone()
+                                                    workspace_config.clone()
                                                }
                                            })
                                            .collect())
@@ -2071,6 +2090,14 @@ impl Project {
                            })
                            .detach();

+                        language_server
+                            .notify::<lsp::notification::DidChangeConfiguration>(
+                                lsp::DidChangeConfigurationParams {
+                                    settings: workspace_config,
+                                },
+                            )
+                            .ok();
+
                        this.update(&mut cx, |this, cx| {
                            // If the language server for this key doesn't match the server id, don't store the
                            // server. Which will cause it to be dropped, killing the process
@@ -2103,13 +2130,6 @@ impl Project {
                                    progress_tokens: Default::default(),
                                },
                            );
-                            language_server
-                                .notify::<lsp::notification::DidChangeConfiguration>(
-                                    lsp::DidChangeConfigurationParams {
-                                        settings: this.language_server_settings.lock().clone(),
-                                    },
-                                )
-                                .ok();

                            if let Some(project_id) = this.remote_id() {
                                this.client
@@ -2539,21 +2559,6 @@ impl Project {
        }
    }

-    pub fn set_language_server_settings(&mut self, settings: serde_json::Value) {
-        for server_state in self.language_servers.values() {
-            if let LanguageServerState::Running { server, .. } = server_state {
-                server
-                    .notify::<lsp::notification::DidChangeConfiguration>(
-                        lsp::DidChangeConfigurationParams {
-                            settings: settings.clone(),
-                        },
-                    )
-                    .ok();
-            }
-        }
-        *self.language_server_settings.lock() = settings;
-    }
-
    pub fn language_server_statuses(
        &self,
    ) -> impl DoubleEndedIterator<Item = &LanguageServerStatus> {
@@ -9,7 +9,7 @@ path = "src/util.rs"
 doctest = false

 [features]
-test-support = ["serde_json", "tempdir", "git2"]
+test-support = ["tempdir", "git2"]

 [dependencies]
 anyhow = "1.0.38"
@@ -19,11 +19,10 @@ log = { version = "0.4.16", features = ["kv_unstable_serde"] }
 lazy_static = "1.4.0"
 rand = { workspace = true }
 tempdir = { version = "0.3.7", optional = true }
-serde_json = { version = "1.0", features = ["preserve_order"], optional = true }
+serde_json = { version = "1.0", features = ["preserve_order"] }
 git2 = { version = "0.15", default-features = false, optional = true }
 dirs = "3.0"

 [dev-dependencies]
 tempdir = { version = "0.3.7" }
-serde_json = { version = "1.0", features = ["preserve_order"] }
 git2 = { version = "0.15", default-features = false }
@@ -83,6 +83,24 @@ where
    }
 }

+pub fn merge_json_value_into(source: serde_json::Value, target: &mut serde_json::Value) {
+    use serde_json::Value;
+
+    match (source, target) {
+        (Value::Object(source), Value::Object(target)) => {
+            for (key, value) in source {
+                if let Some(target) = target.get_mut(&key) {
+                    merge_json_value_into(value, target);
+                } else {
+                    target.insert(key.clone(), value);
+                }
+            }
+        }
+
+        (source, target) => *target = source,
+    }
+}
+
 pub trait ResultExt {
    type Ok;

@@ -2,6 +2,7 @@ use anyhow::Context;
 pub use language::*;
 use rust_embed::RustEmbed;
 use std::{borrow::Cow, str, sync::Arc};
+use theme::ThemeRegistry;

 mod c;
 mod elixir;
@@ -31,17 +32,17 @@ mod yaml;
 #[exclude = "*.rs"]
 struct LanguageDir;

-pub fn init(languages: Arc<LanguageRegistry>) {
+pub fn init(languages: Arc<LanguageRegistry>, themes: Arc<ThemeRegistry>) {
    for (name, grammar, lsp_adapter) in [
        (
            "c",
            tree_sitter_c::language(),
-            Some(Box::new(c::CLspAdapter) as Box<dyn LspAdapter>),
+            Some(Arc::new(c::CLspAdapter) as Arc<dyn LspAdapter>),
        ),
        (
            "cpp",
            tree_sitter_cpp::language(),
-            Some(Box::new(c::CLspAdapter)),
+            Some(Arc::new(c::CLspAdapter)),
        ),
        (
            "css",
@@ -51,17 +52,20 @@ pub fn init(languages: Arc<LanguageRegistry>) {
        (
            "elixir",
            tree_sitter_elixir::language(),
-            Some(Box::new(elixir::ElixirLspAdapter)),
+            Some(Arc::new(elixir::ElixirLspAdapter)),
        ),
        (
            "go",
            tree_sitter_go::language(),
-            Some(Box::new(go::GoLspAdapter)),
+            Some(Arc::new(go::GoLspAdapter)),
        ),
        (
            "json",
            tree_sitter_json::language(),
-            Some(Box::new(json::JsonLspAdapter)),
+            Some(Arc::new(json::JsonLspAdapter::new(
+                languages.clone(),
+                themes.clone(),
+            ))),
        ),
        (
            "markdown",
@@ -71,12 +75,12 @@ pub fn init(languages: Arc<LanguageRegistry>) {
        (
            "python",
            tree_sitter_python::language(),
-            Some(Box::new(python::PythonLspAdapter)),
+            Some(Arc::new(python::PythonLspAdapter)),
        ),
        (
            "rust",
            tree_sitter_rust::language(),
-            Some(Box::new(rust::RustLspAdapter)),
+            Some(Arc::new(rust::RustLspAdapter)),
        ),
        (
            "toml",
@@ -86,32 +90,32 @@ pub fn init(languages: Arc<LanguageRegistry>) {
        (
            "tsx",
            tree_sitter_typescript::language_tsx(),
-            Some(Box::new(typescript::TypeScriptLspAdapter)),
+            Some(Arc::new(typescript::TypeScriptLspAdapter)),
        ),
        (
            "typescript",
            tree_sitter_typescript::language_typescript(),
-            Some(Box::new(typescript::TypeScriptLspAdapter)),
+            Some(Arc::new(typescript::TypeScriptLspAdapter)),
        ),
        (
            "javascript",
            tree_sitter_typescript::language_tsx(),
-            Some(Box::new(typescript::TypeScriptLspAdapter)),
+            Some(Arc::new(typescript::TypeScriptLspAdapter)),
        ),
        (
            "html",
            tree_sitter_html::language(),
-            Some(Box::new(html::HtmlLspAdapter)),
+            Some(Arc::new(html::HtmlLspAdapter)),
        ),
        (
            "ruby",
            tree_sitter_ruby::language(),
-            Some(Box::new(ruby::RubyLanguageServer)),
+            Some(Arc::new(ruby::RubyLanguageServer)),
        ),
        (
            "erb",
            tree_sitter_embedded_template::language(),
-            Some(Box::new(ruby::RubyLanguageServer)),
+            Some(Arc::new(ruby::RubyLanguageServer)),
        ),
        (
            "scheme",
@@ -126,12 +130,12 @@ pub fn init(languages: Arc<LanguageRegistry>) {
        (
            "lua",
            tree_sitter_lua::language(),
-            Some(Box::new(lua::LuaLspAdapter)),
+            Some(Arc::new(lua::LuaLspAdapter)),
        ),
        (
            "yaml",
            tree_sitter_yaml::language(),
-            Some(Box::new(yaml::YamlLspAdapter)),
+            Some(Arc::new(yaml::YamlLspAdapter)),
        ),
    ] {
        languages.register(name, load_config(name), grammar, lsp_adapter, load_queries);
@@ -142,7 +146,7 @@ pub fn init(languages: Arc<LanguageRegistry>) {
 pub async fn language(
    name: &str,
    grammar: tree_sitter::Language,
-    lsp_adapter: Option<Box<dyn LspAdapter>>,
+    lsp_adapter: Option<Arc<dyn LspAdapter>>,
 ) -> Arc<Language> {
    Arc::new(
        Language::new(load_config(name), Some(grammar))
@@ -314,7 +314,7 @@ mod tests {
        let language = language(
            "go",
            tree_sitter_go::language(),
-            Some(Box::new(GoLspAdapter)),
+            Some(Arc::new(GoLspAdapter)),
        )
        .await;

@@ -4,14 +4,32 @@ use async_compression::futures::bufread::GzipDecoder;
 use async_trait::async_trait;
 use client::http::HttpClient;
 use collections::HashMap;
-use futures::{io::BufReader, StreamExt};
-use language::{LanguageServerName, LspAdapter};
+use futures::{future::BoxFuture, io::BufReader, FutureExt, StreamExt};
+use gpui::MutableAppContext;
+use language::{LanguageRegistry, LanguageServerName, LspAdapter};
 use serde_json::json;
+use settings::{keymap_file_json_schema, settings_file_json_schema};
 use smol::fs::{self, File};
-use std::{any::Any, env::consts, path::PathBuf, sync::Arc};
-use util::ResultExt;
+use std::{
+    any::Any,
+    env::consts,
+    future,
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+use theme::ThemeRegistry;
+use util::{paths, ResultExt, StaffMode};

-pub struct JsonLspAdapter;
+pub struct JsonLspAdapter {
+    languages: Arc<LanguageRegistry>,
+    themes: Arc<ThemeRegistry>,
+}
+
+impl JsonLspAdapter {
+    pub fn new(languages: Arc<LanguageRegistry>, themes: Arc<ThemeRegistry>) -> Self {
+        Self { languages, themes }
+    }
+}

 #[async_trait]
 impl LspAdapter for JsonLspAdapter {
@@ -102,7 +120,45 @@ impl LspAdapter for JsonLspAdapter {
        }))
    }

+    fn workspace_configuration(
+        &self,
+        cx: &mut MutableAppContext,
+    ) -> Option<BoxFuture<'static, serde_json::Value>> {
+        let action_names = cx.all_action_names().collect::<Vec<_>>();
+        let theme_names = self
+            .themes
+            .list(**cx.default_global::<StaffMode>())
+            .map(|meta| meta.name)
+            .collect();
+        let language_names = self.languages.language_names();
+        Some(
+            future::ready(serde_json::json!({
+                "json": {
+                    "format": {
+                        "enable": true,
+                    },
+                    "schemas": [
+                        {
+                            "fileMatch": [schema_file_match(&paths::SETTINGS)],
+                            "schema": settings_file_json_schema(theme_names, &language_names),
+                        },
+                        {
+                            "fileMatch": [schema_file_match(&paths::KEYMAP)],
+                            "schema": keymap_file_json_schema(&action_names),
+                        }
+                    ]
+                }
+            }))
+            .boxed(),
+        )
+    }
+
    async fn language_ids(&self) -> HashMap<String, String> {
        [("JSON".into(), "jsonc".into())].into_iter().collect()
    }
 }
+
+fn schema_file_match(path: &Path) -> &Path {
+    path.strip_prefix(path.parent().unwrap().parent().unwrap())
+        .unwrap()
+}
@@ -306,7 +306,7 @@ mod tests {
        let language = language(
            "rust",
            tree_sitter_rust::language(),
-            Some(Box::new(RustLspAdapter)),
+            Some(Arc::new(RustLspAdapter)),
        )
        .await;
        let grammar = language.grammar().unwrap();
@@ -392,7 +392,7 @@ mod tests {
        let language = language(
            "rust",
            tree_sitter_rust::language(),
-            Some(Box::new(RustLspAdapter)),
+            Some(Arc::new(RustLspAdapter)),
        )
        .await;
        let grammar = language.grammar().unwrap();
@@ -1,12 +1,13 @@
-use std::{any::Any, path::PathBuf, sync::Arc};
-
 use anyhow::{anyhow, Context, Result};
 use async_trait::async_trait;
 use client::http::HttpClient;
-use futures::StreamExt;
-use smol::fs;
-
+use futures::{future::BoxFuture, FutureExt, StreamExt};
+use gpui::MutableAppContext;
 use language::{LanguageServerName, LspAdapter};
+use serde_json::Value;
+use settings::Settings;
+use smol::fs;
+use std::{any::Any, future, path::PathBuf, sync::Arc};
 use util::ResultExt;

 use super::installation::{npm_install_packages, npm_package_latest_version};
@@ -90,4 +91,19 @@ impl LspAdapter for YamlLspAdapter {
        .await
        .log_err()
    }
+
+    fn workspace_configuration(
+        &self,
+        cx: &mut MutableAppContext,
+    ) -> Option<BoxFuture<'static, Value>> {
+        let settings = cx.global::<Settings>();
+        Some(
+            future::ready(serde_json::json!({
+                "[yaml]": {
+                    "editor.tabSize": settings.tab_size(Some("YAML"))
+                }
+            }))
+            .boxed(),
+        )
+    }
 }
@@ -139,7 +139,7 @@ fn main() {
        languages.set_executor(cx.background().clone());
        languages.set_language_server_download_dir(paths::LANGUAGES_DIR.clone());
        let languages = Arc::new(languages);
-        languages::init(languages.clone());
+        languages::init(languages.clone(), themes.clone());
        let user_store = cx.add_model(|cx| UserStore::new(client.clone(), http.clone(), cx));

        cx.set_global(client.clone());
@@ -29,10 +29,10 @@ use project_panel::ProjectPanel;
 use search::{BufferSearchBar, ProjectSearchBar};
 use serde::Deserialize;
 use serde_json::to_string_pretty;
-use settings::{keymap_file_json_schema, settings_file_json_schema, Settings};
+use settings::Settings;
 use std::{borrow::Cow, env, path::Path, str, sync::Arc};
 use terminal_view::terminal_button::{self, TerminalButton};
-use util::{channel::ReleaseChannel, paths, ResultExt, StaffMode};
+use util::{channel::ReleaseChannel, paths, ResultExt};
 use uuid::Uuid;
 pub use workspace;
 use workspace::{sidebar::SidebarSide, AppState, Restart, Workspace};
@@ -296,34 +296,6 @@ pub fn initialize_workspace(
    cx.emit(workspace::Event::PaneAdded(workspace.active_pane().clone()));
    cx.emit(workspace::Event::PaneAdded(workspace.dock_pane().clone()));

-    let theme_names = app_state
-        .themes
-        .list(**cx.default_global::<StaffMode>())
-        .map(|meta| meta.name)
-        .collect();
-    let language_names = app_state.languages.language_names();
-
-    workspace.project().update(cx, |project, cx| {
-        let action_names = cx.all_action_names().collect::<Vec<_>>();
-        project.set_language_server_settings(serde_json::json!({
-            "json": {
-                "format": {
-                    "enable": true,
-                },
-                "schemas": [
-                    {
-                        "fileMatch": [schema_file_match(&paths::SETTINGS)],
-                        "schema": settings_file_json_schema(theme_names, &language_names),
-                    },
-                    {
-                        "fileMatch": [schema_file_match(&paths::KEYMAP)],
-                        "schema": keymap_file_json_schema(&action_names),
-                    }
-                ]
-            }
-        }));
-    });
-
    let collab_titlebar_item =
        cx.add_view(|cx| CollabTitlebarItem::new(&workspace_handle, &app_state.user_store, cx));
    workspace.set_titlebar_item(collab_titlebar_item, cx);
@@ -676,11 +648,6 @@ fn open_bundled_file(
    .detach();
 }

-fn schema_file_match(path: &Path) -> &Path {
-    path.strip_prefix(path.parent().unwrap().parent().unwrap())
-        .unwrap()
-}
-
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -1882,7 +1849,8 @@ mod tests {
        let mut languages = LanguageRegistry::new(Task::ready(()));
        languages.set_executor(cx.background().clone());
        let languages = Arc::new(languages);
-        languages::init(languages.clone());
+        let themes = ThemeRegistry::new((), cx.font_cache().clone());
+        languages::init(languages.clone(), themes);
        for name in languages.language_names() {
            languages.language_for_name(&name);
        }