From 59dd60d4dd3bd85cbdcf00328e689fa519b55f78 Mon Sep 17 00:00:00 2001 From: Finn Evers Date: Wed, 21 Oct 2026 16:49:51 +0000 Subject: [PATCH] Refactor `ExtensionLanguageProxy` to provide only `ExtensionLanguageProxy::update_languages` (#65381) ## Summary Further preparation for https://github.com/zed-industries/zed/pull/65047 - this PR changes the trait so thar we now register and unregister languages through a single call into the trait. This allows us to easier manage state depending on this - we previously always removed and readded everything, with this now in place, we instead get a diff that let's us know what changed and thus needs updating. That will be used in the linked PR as well. ## Testing Added some tests (actually most of the diff), other behavior is still the same, and also gave it a manual test run. Tests caugtht some edge cases with token rules previously unhandled which this PR now also takes care of. ## Self-review - [X] I've reviewed my diff for quality, security, reliability, and performance. - [N/A] UI changes follow the [checklist](https://zed.dev/docs/development/ui-checklist). - [X] Tests cover the new or changed behavior. Release Notes: - N/A --------- Co-authored-by: zed-zippy[bot] <234243425+zed-zippy[bot]@users.noreply.github.com> --- crates/extension/src/extension_host_proxy.rs | 57 +-- crates/extension_host/src/extension_host.rs | 113 +++--- .../src/extension_store_test.rs | 116 +++++- crates/extension_host/src/headless_host.rs | 26 +- crates/language/src/language.rs | 3 +- crates/language/src/language_registry.rs | 332 ++++++++++++++---- .../src/language_extension.rs | 35 +- 7 files changed, 473 insertions(+), 209 deletions(-) diff --git a/crates/extension/src/extension_host_proxy.rs b/crates/extension/src/extension_host_proxy.rs index 90500170913..de86412bf06 100644 --- a/crates/extension/src/extension_host_proxy.rs +++ b/crates/extension/src/extension_host_proxy.rs @@ -4,7 +4,7 @@ use std::sync::Arc; use anyhow::Result; use fs::Fs; use gpui::{App, EntityId, Global, ReadGlobal, SharedString, Task}; -use language::{BinaryStatus, LanguageLoader, LanguageMatcher, LanguageName}; +use language::{BinaryStatus, ExtensionLanguagesUpdateOutcome, LanguageName, LanguageRegistration}; use lsp::LanguageServerName; use parking_lot::RwLock; @@ -228,59 +228,30 @@ impl ExtensionGrammarProxy for ExtensionHostProxy { } pub trait ExtensionLanguageProxy: Send + Sync + 'static { - fn register_language( - &self, - language: LanguageName, - grammar: Option>, - matcher: Arc, - hidden: bool, - load: LanguageLoader, - ) -> bool; - - fn is_language_registered(&self, language: &LanguageName) -> bool; - - fn remove_languages( + /// Applies the removals before the registrations, as a single update. + /// + /// The returned outcome contains exactly one status per registration, in the + /// order the registrations were passed. + fn update_languages( &self, languages_to_remove: &[LanguageName], grammars_to_remove: &[Arc], - ); + registrations: Vec, + ) -> ExtensionLanguagesUpdateOutcome; } impl ExtensionLanguageProxy for ExtensionHostProxy { - #[ztracing::instrument(skip_all, fields(lang = language.0.as_str()))] - fn register_language( - &self, - language: LanguageName, - grammar: Option>, - matcher: Arc, - hidden: bool, - load: LanguageLoader, - ) -> bool { - let Some(proxy) = self.language_proxy.read().clone() else { - return false; - }; - - proxy.register_language(language, grammar, matcher, hidden, load) - } - - fn is_language_registered(&self, language: &LanguageName) -> bool { - let Some(proxy) = self.language_proxy.read().clone() else { - return false; - }; - - proxy.is_language_registered(language) - } - - fn remove_languages( + #[ztracing::instrument(skip_all)] + fn update_languages( &self, languages_to_remove: &[LanguageName], grammars_to_remove: &[Arc], - ) { + registrations: Vec, + ) -> ExtensionLanguagesUpdateOutcome { let Some(proxy) = self.language_proxy.read().clone() else { - return; + return ExtensionLanguagesUpdateOutcome::rejected(registrations.len()); }; - - proxy.remove_languages(languages_to_remove, grammars_to_remove) + proxy.update_languages(languages_to_remove, grammars_to_remove, registrations) } } diff --git a/crates/extension_host/src/extension_host.rs b/crates/extension_host/src/extension_host.rs index 7d22d2178ee..44d6e84d589 100644 --- a/crates/extension_host/src/extension_host.rs +++ b/crates/extension_host/src/extension_host.rs @@ -1427,21 +1427,7 @@ impl ExtensionStore { self.proxy.remove_user_themes(themes_to_remove); self.proxy.remove_icon_themes(icon_themes_to_remove); self.proxy - .remove_languages(&languages_to_remove, &grammars_to_remove); - - // Remove semantic token rules for languages being unloaded. - let semantic_token_rules_to_remove = languages_to_remove - .iter() - .filter(|language| !self.proxy.is_language_registered(language)) - .chain(languages_to_readd.iter().map(|(name, _)| name)) - .collect::>(); - if !semantic_token_rules_to_remove.is_empty() { - SettingsStore::update_global(cx, |store, _| { - for language in semantic_token_rules_to_remove { - store.remove_language_semantic_token_rules(language.as_ref()); - } - }); - } + .update_languages(&[], &grammars_to_remove, Vec::new()); let mut grammars_to_add = Vec::new(); let mut themes_to_add = Vec::new(); @@ -1522,41 +1508,74 @@ impl ExtensionStore { .languages .iter() .filter(|(_, entry)| extensions_to_load.contains(&entry.extension)) - .map(|(name, entry)| (name.clone(), entry.clone())) - .chain(languages_to_readd) + .chain(languages_to_readd.iter().map(|(name, entry)| (name, entry))) + .map(|(name, entry)| { + let mut language_path = self.installed_dir.clone(); + language_path.extend([Path::new(entry.extension.as_ref()), entry.path.as_path()]); + (name, entry, language_path) + }) .collect::>(); - let mut semantic_token_rules_paths: Vec<(LanguageName, PathBuf)> = Vec::new(); - for (language_name, language) in languages_to_add { - let mut language_path = self.installed_dir.clone(); - language_path.extend([ - Path::new(language.extension.as_ref()), - language.path.as_path(), - ]); - let rules_path = language_path.join(SemanticTokenRules::FILE_NAME); - - let registered = self.proxy.register_language( - language_name.clone(), - language.grammar.clone(), - language.matcher.clone(), - language.hidden, - Arc::new({ - let fs = self.fs.clone(); - let query_files = language.query_files; - move || { - let fs = fs.clone(); + let registrations = languages_to_add + .iter() + .map( + |(name, entry, language_path)| language::LanguageRegistration { + name: (*name).clone(), + grammar_name: entry.grammar.clone(), + matcher: entry.matcher.clone(), + hidden: entry.hidden, + load: Arc::new({ + let fs = self.fs.clone(); let language_path = language_path.clone(); - async move { load_plugin_language(fs, &language_path, query_files).await } - .boxed() - } - }), - ); - if !registered { - continue; - } - - semantic_token_rules_paths.push((language_name, rules_path)); + let query_files = entry.query_files; + move || { + let fs = fs.clone(); + let language_path = language_path.clone(); + async move { + load_plugin_language(fs, &language_path, query_files).await + } + .boxed() + } + }), + }, + ) + .collect(); + let update = self + .proxy + .update_languages(&languages_to_remove, &[], registrations); + debug_assert_eq!(update.registrations().len(), languages_to_add.len()); + let readded_statuses = update.registrations().iter().skip( + languages_to_add + .len() + .saturating_sub(languages_to_readd.len()), + ); + let semantic_token_rules_paths = languages_to_add + .into_iter() + .zip(update.registrations()) + .filter(|(_, status)| status.is_registered()) + .map(|((name, _, mut rules_path), _)| { + rules_path.push(SemanticTokenRules::FILE_NAME); + (name.clone(), rules_path) + }) + .collect::>(); + // Rejected re-additions are shadowed by a native language whose rules must survive. + let mut semantic_token_rules_to_remove = update + .removed() + .iter() + .chain( + languages_to_readd + .iter() + .zip(readded_statuses) + .filter(|(_, status)| status.is_registered()) + .map(|((name, _), _)| name), + ) + .peekable(); + if semantic_token_rules_to_remove.peek().is_some() { + SettingsStore::update_global(cx, |store, _cx| { + for language in semantic_token_rules_to_remove { + store.remove_language_semantic_token_rules(language.as_ref()); + } + }); } - let fs = self.fs.clone(); let wasm_host = self.wasm_host.clone(); let root_dir = self.installed_dir.clone(); diff --git a/crates/extension_host/src/extension_store_test.rs b/crates/extension_host/src/extension_store_test.rs index 4cffd2dd1d7..1c9dc8f76d4 100644 --- a/crates/extension_host/src/extension_store_test.rs +++ b/crates/extension_host/src/extension_store_test.rs @@ -22,7 +22,10 @@ use extension::{ }; use fs::{FakeFs, Fs, RealFs, RemoveOptions}; use futures::{AsyncReadExt, FutureExt, StreamExt, io::BufReader}; -use gpui::{AppContext as _, BackgroundExecutor, Entity, EntityId, TaskExt, TestAppContext}; +use gpui::{ + AppContext as _, BackgroundExecutor, BorrowAppContext as _, Entity, EntityId, TaskExt, + TestAppContext, +}; use http_client::{FakeHttpClient, Response}; use language::{ BinaryStatus, LanguageConfig, LanguageMatcher, LanguageName, LanguageRegistry, QueryFiles, @@ -793,11 +796,7 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) { } } - let root_dir = Path::new(env!("CARGO_MANIFEST_DIR")) - .parent() - .unwrap() - .parent() - .unwrap(); + let root_dir = util::dev_repo_root().expect("test extension requires a repository checkout"); let cache_dir = root_dir.join("target"); let test_extension_id = "test-extension"; let test_extension_dir = root_dir.join("extensions").join(test_extension_id); @@ -3549,6 +3548,111 @@ async fn test_uninstalling_extension_restores_surviving_extensions_language( ); } +#[gpui::test] +async fn test_extension_reload_removes_dropped_semantic_token_rules(cx: &mut TestAppContext) { + init_test(cx); + + let fs = FakeFs::new(cx.executor()); + let language_registry = Arc::new(LanguageRegistry::test(cx.executor())); + let proxy = Arc::new(ExtensionHostProxy::new()); + language_extension::init(LspAccess::Noop, proxy.clone(), language_registry.clone()); + insert_language_extension(&fs, "ext-a", "Shared", "shared").await; + fs.insert_tree( + "/extensions/installed/ext-a/languages/lang", + json!({ "semantic_token_rules.json": "[]" }), + ) + .await; + let store = create_extension_store_with(fs.clone(), proxy, cx); + cx.update(|cx| { + assert!( + cx.global::() + .language_semantic_token_rules("Shared") + .is_some() + ); + }); + + fs.remove_file( + Path::new("/extensions/installed/ext-a/languages/lang/semantic_token_rules.json"), + RemoveOptions { + recursive: false, + ignore_if_not_exists: false, + }, + ) + .await + .unwrap(); + store.update(cx, |store, cx| drop(store.reload(Some("ext-a".into()), cx))); + cx.executor().advance_clock(RELOAD_DEBOUNCE_DURATION); + cx.run_until_parked(); + + assert_eq!( + language_registry.language_name_for_extension("shared"), + Some(LanguageName::new("Shared")), + ); + cx.update(|cx| { + assert!( + cx.global::() + .language_semantic_token_rules("Shared") + .is_none() + ); + }); +} + +#[gpui::test] +async fn test_rejected_readded_language_keeps_native_semantic_token_rules(cx: &mut TestAppContext) { + init_test(cx); + + let fs = FakeFs::new(cx.executor()); + let language_registry = Arc::new(LanguageRegistry::test(cx.executor())); + let proxy = Arc::new(ExtensionHostProxy::new()); + language_extension::init(LspAccess::Noop, proxy.clone(), language_registry.clone()); + + language_registry.register_test_language(LanguageConfig { + name: LanguageName::new("Shared"), + matcher: Arc::new(LanguageMatcher { + path_suffixes: vec!["builtin".into()], + ..LanguageMatcher::default() + }), + ..LanguageConfig::default() + }); + cx.update(|cx| { + cx.update_global::(|store, _cx| { + store.set_language_semantic_token_rules( + "Shared".into(), + settings::SemanticTokenRules::default(), + ); + }); + }); + insert_language_extension(&fs, "ext-a", "Shared", "shadowed-a").await; + insert_language_extension(&fs, "ext-b", "Shared", "shadowed-b").await; + let store = create_extension_store_with(fs.clone(), proxy, cx); + + fs.remove_dir( + Path::new("/extensions/installed/ext-b"), + RemoveOptions { + recursive: true, + ignore_if_not_exists: false, + }, + ) + .await + .unwrap(); + store.update(cx, |store, cx| drop(store.reload(None, cx))); + cx.executor().advance_clock(RELOAD_DEBOUNCE_DURATION); + cx.run_until_parked(); + + assert_eq!( + language_registry.language_name_for_extension("builtin"), + Some(LanguageName::new("Shared")), + ); + cx.update(|cx| { + assert!( + cx.global::() + .language_semantic_token_rules("Shared") + .is_some(), + "re-adding a language that a native language shadows must keep the native rules" + ); + }); +} + #[gpui::test] async fn test_extension_cannot_shadow_language_registered_outside_extensions( cx: &mut TestAppContext, diff --git a/crates/extension_host/src/headless_host.rs b/crates/extension_host/src/headless_host.rs index 82fdc751016..46eac317176 100644 --- a/crates/extension_host/src/headless_host.rs +++ b/crates/extension_host/src/headless_host.rs @@ -324,8 +324,9 @@ impl HeadlessExtensionStore { let current = self.loaded_extensions.get(&extension_id).cloned(); let mut removal_tasks = Vec::new(); + let mut languages_to_remove = Vec::new(); + let mut registrations = Vec::new(); if let Some(previous) = previous { - let mut languages_to_remove = Vec::new(); for (language, _) in &previous.languages { if current.as_ref().is_some_and(|current| { current.languages.iter().any(|(name, _)| name == language) @@ -333,11 +334,10 @@ impl HeadlessExtensionStore { continue; } match self.surviving_language_config(language) { - Some(config) => register_language_from_config(&self.proxy, config), + Some(config) => registrations.push(language_registration_from_config(config)), None => languages_to_remove.push(language.clone()), } } - self.proxy.remove_languages(&languages_to_remove, &[]); for (server_name, language) in &previous.language_servers { removal_tasks.push(self.proxy.remove_language_server(language, server_name, cx)); @@ -403,7 +403,7 @@ impl HeadlessExtensionStore { if let Some(current) = ¤t { for (_, config) in ¤t.languages { - register_language_from_config(&self.proxy, config.clone()); + registrations.push(language_registration_from_config(config.clone())); } if let Some(wasm_extension) = ¤t.wasm_extension { for (server_name, language) in ¤t.language_servers { @@ -430,6 +430,8 @@ impl HeadlessExtensionStore { } } + self.proxy + .update_languages(&languages_to_remove, &[], registrations); removal_tasks } @@ -784,13 +786,13 @@ fn notify_extensions_changed(cx: &mut App) { } } -fn register_language_from_config(proxy: &ExtensionHostProxy, config: LanguageConfig) { - proxy.register_language( - config.name.clone(), - None, - config.matcher.clone(), - config.hidden, - Arc::new(move || { +fn language_registration_from_config(config: LanguageConfig) -> language::LanguageRegistration { + language::LanguageRegistration { + name: config.name.clone(), + grammar_name: None, + matcher: config.matcher.clone(), + hidden: config.hidden, + load: Arc::new(move || { let config = config.clone(); async move { Ok(LoadedLanguage { @@ -803,5 +805,5 @@ fn register_language_from_config(proxy: &ExtensionHostProxy, config: LanguageCon } .boxed() }), - ); + } } diff --git a/crates/language/src/language.rs b/crates/language/src/language.rs index 50068ea6f4e..1ceb096fa1a 100644 --- a/crates/language/src/language.rs +++ b/crates/language/src/language.rs @@ -62,7 +62,8 @@ pub use language_core::{ serialize_regex, }; pub use language_registry::{ - LanguageLoader, LanguageName, LanguageServerStatusUpdate, LoadedLanguage, ServerHealth, + ExtensionLanguagesUpdateOutcome, LanguageLoader, LanguageName, LanguageRegistration, + LanguageRegistrationStatus, LanguageServerStatusUpdate, LoadedLanguage, ServerHealth, }; use lsp::{ CodeActionKind, InitializeParams, LanguageServerBinary, LanguageServerBinaryOptions, Uri, diff --git a/crates/language/src/language_registry.rs b/crates/language/src/language_registry.rs index a68bb69df80..87deed13bf3 100644 --- a/crates/language/src/language_registry.rs +++ b/crates/language/src/language_registry.rs @@ -42,6 +42,60 @@ pub struct LanguageRegistry { lsp_binary_status_tx: ServerStatusSender, } +/// A language to register with [`LanguageRegistry::update_extension_languages`]. +pub struct LanguageRegistration { + pub name: LanguageName, + pub grammar_name: Option>, + pub matcher: Arc, + pub hidden: bool, + pub load: LanguageLoader, +} + +/// Whether a [`LanguageRegistration`] passed to +/// [`LanguageRegistry::update_extension_languages`] took effect. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum LanguageRegistrationStatus { + Registered, + /// A language with the same name is registered outside of extensions. + Rejected, +} + +impl LanguageRegistrationStatus { + pub fn is_registered(self) -> bool { + self == Self::Registered + } +} + +/// The outcome of [`LanguageRegistry::update_extension_languages`]. +#[derive(Debug, Default)] +pub struct ExtensionLanguagesUpdateOutcome { + removed: Vec, + registrations: SmallVec<[LanguageRegistrationStatus; 8]>, +} + +impl ExtensionLanguagesUpdateOutcome { + /// An outcome in which nothing was removed and every registration was rejected. + pub fn rejected(registration_count: usize) -> Self { + Self { + removed: Vec::new(), + registrations: SmallVec::from_elem( + LanguageRegistrationStatus::Rejected, + registration_count, + ), + } + } + + /// The extension languages that were removed from the registry. + pub fn removed(&self) -> &[LanguageName] { + &self.removed + } + + /// The status of each registration, in the order they were passed. + pub fn registrations(&self) -> &[LanguageRegistrationStatus] { + &self.registrations + } +} + struct LanguageRegistryState { next_language_server_id: usize, languages: Vec>, @@ -177,9 +231,7 @@ impl LanguageRegistry { languages_to_remove: &[LanguageName], grammars_to_remove: &[Arc], ) { - self.state - .write() - .remove_languages(languages_to_remove, grammars_to_remove) + self.update_extension_languages(languages_to_remove, grammars_to_remove, Vec::new()); } pub fn remove_lsp_adapter(&self, language_name: &LanguageName, name: &LanguageServerName) { @@ -393,8 +445,11 @@ impl LanguageRegistry { manifest_name: Option, load: LanguageLoader, ) { - self.register_language_with_origin( - name, + let state = &mut *self.state.write(); + + // Native registrations are never rejected, so this is only `None` for extensions. + let was_loaded = state.available_languages.register( + name.clone(), grammar_name, matcher, hidden, @@ -402,62 +457,82 @@ impl LanguageRegistry { load, LanguageOrigin::Native, ); - } - - pub fn register_extension_language( - &self, - name: LanguageName, - grammar_name: Option>, - matcher: Arc, - hidden: bool, - manifest_name: Option, - load: LanguageLoader, - ) -> bool { - self.register_language_with_origin( - name, - grammar_name, - matcher, - hidden, - manifest_name, - load, - LanguageOrigin::Extension, - ) - } - - fn register_language_with_origin( - &self, - name: LanguageName, - grammar_name: Option>, - matcher: Arc, - hidden: bool, - manifest_name: Option, - load: LanguageLoader, - origin: LanguageOrigin, - ) -> bool { - let state = &mut *self.state.write(); - - let Some(was_loaded) = state.available_languages.register( - name.clone(), - grammar_name, - matcher, - hidden, - manifest_name, - load, - origin, - ) else { - log::warn!( - "not registering extension language {name}: a language with this name is already registered outside of extensions" - ); - return false; - }; - if was_loaded { + if was_loaded == Some(true) { state.languages.retain(|language| language.name() != name); } state.version += 1; state.reload_count += 1; *state.subscription.0.borrow_mut() = (); - true + } + + /// Removes and registers extension languages and removes grammars as a single + /// update, so that observers are only notified once. + /// + /// A registration is rejected if a language with the same name is registered + /// outside of extensions. + pub fn update_extension_languages( + &self, + languages_to_remove: &[LanguageName], + grammars_to_remove: &[Arc], + registrations: Vec, + ) -> ExtensionLanguagesUpdateOutcome { + let state = &mut *self.state.write(); + + let removed = state + .available_languages + .remove_extension_languages(languages_to_remove); + let mut reloaded = SmallVec::<[LanguageName; 4]>::new(); + let registrations = registrations + .into_iter() + .map(|registration| { + let name = registration.name; + match state.available_languages.register( + name.clone(), + registration.grammar_name, + registration.matcher, + registration.hidden, + None, + registration.load, + LanguageOrigin::Extension, + ) { + Some(was_loaded) => { + if was_loaded { + reloaded.push(name); + } + LanguageRegistrationStatus::Registered + } + None => { + log::warn!( + "not registering extension language {name}: \ + a language with this name is already registered outside of extensions" + ); + LanguageRegistrationStatus::Rejected + } + } + }) + .collect::>(); + + state.languages.retain(|language| { + let name = language.name(); + !removed.contains(&name) && !reloaded.contains(&name) + }); + state.grammars.retain(|name, grammar| { + matches!(grammar, AvailableGrammar::Native(_)) || !grammars_to_remove.contains(name) + }); + + let changed = !languages_to_remove.is_empty() + || !grammars_to_remove.is_empty() + || registrations.iter().any(|status| status.is_registered()); + if changed { + state.version += 1; + state.reload_count += 1; + *state.subscription.0.borrow_mut() = (); + } + ExtensionLanguagesUpdateOutcome { + removed, + registrations, + } } /// Adds grammars to the registry. Language configurations reference a grammar by name. The @@ -1086,28 +1161,6 @@ impl LanguageRegistryState { *lsp_adapters = new_lsp_adapters; } - fn remove_languages( - &mut self, - languages_to_remove: &[LanguageName], - grammars_to_remove: &[Arc], - ) { - if languages_to_remove.is_empty() && grammars_to_remove.is_empty() { - return; - } - - let removed_languages = self - .available_languages - .remove_extension_languages(languages_to_remove); - self.languages - .retain(|language| !removed_languages.contains(&language.name())); - self.grammars.retain(|name, grammar| { - !grammars_to_remove.contains(name) || matches!(grammar, AvailableGrammar::Native(_)) - }); - self.version += 1; - self.reload_count += 1; - *self.subscription.0.borrow_mut() = (); - } - /// Mark the given language as having been loaded, so that the /// language registry won't try to load it again. fn mark_language_loaded(&mut self, id: LanguageId) { @@ -1143,6 +1196,7 @@ impl ServerStatusSender { #[cfg(test)] mod tests { use super::*; + use gpui::TestAppContext; #[test] fn dropping_server_status_subscription_unregisters_sender() { @@ -1153,4 +1207,128 @@ mod tests { drop(subscription); assert!(sender.state.lock().txs.is_empty()); } + + fn extension_language_registration( + name: &'static str, + path_suffix: &str, + ) -> LanguageRegistration { + let config = LanguageConfig { + name: LanguageName::new_static(name), + matcher: Arc::new(LanguageMatcher { + path_suffixes: vec![path_suffix.into()], + ..LanguageMatcher::default() + }), + ..LanguageConfig::default() + }; + LanguageRegistration { + name: config.name.clone(), + grammar_name: None, + matcher: config.matcher.clone(), + hidden: false, + load: Arc::new(move || { + let config = config.clone(); + async move { + Ok(LoadedLanguage { + config, + queries: LanguageQueries::default(), + context_provider: None, + toolchain_provider: None, + manifest_name: None, + }) + } + .boxed() + }), + } + } + + #[gpui::test] + async fn test_update_extension_languages_replaces_loaded_language(cx: &mut TestAppContext) { + let registry = Arc::new(LanguageRegistry::test(cx.executor())); + registry.update_extension_languages( + &[], + &[], + vec![extension_language_registration("TheLanguage", "old")], + ); + let old_language = registry.language_for_name("TheLanguage").await.unwrap(); + + let update = registry.update_extension_languages( + &[LanguageName::new_static("TheLanguage")], + &[], + vec![extension_language_registration("TheLanguage", "new")], + ); + assert_eq!(update.removed(), [LanguageName::new_static("TheLanguage")]); + assert_eq!( + update.registrations(), + [LanguageRegistrationStatus::Registered] + ); + + let new_language = registry.language_for_name("TheLanguage").await.unwrap(); + assert!(!Arc::ptr_eq(&old_language, &new_language)); + assert_eq!( + new_language.config.matcher.path_suffixes, + vec!["new".to_string()], + "removing and re-registering a loaded language in one update must evict the old one" + ); + } + + #[gpui::test] + async fn test_update_extension_languages_rejects_native_names(cx: &mut TestAppContext) { + let registry = Arc::new(LanguageRegistry::test(cx.executor())); + registry.register_test_language(LanguageConfig { + name: LanguageName::new_static("TheLanguage"), + matcher: Arc::new(LanguageMatcher { + path_suffixes: vec!["native".into()], + ..LanguageMatcher::default() + }), + ..LanguageConfig::default() + }); + let version = registry.version(); + let reload_count = registry.reload_count(); + + let update = registry.update_extension_languages( + &[], + &[], + vec![extension_language_registration("TheLanguage", "extension")], + ); + assert!(update.removed().is_empty()); + assert_eq!( + update.registrations(), + [LanguageRegistrationStatus::Rejected] + ); + assert_eq!(registry.version(), version); + assert_eq!(registry.reload_count(), reload_count); + + let language = registry.language_for_name("TheLanguage").await.unwrap(); + assert_eq!( + language.config.matcher.path_suffixes, + vec!["native".to_string()] + ); + } + + #[gpui::test] + fn test_update_extension_languages_notifies_once(cx: &mut TestAppContext) { + let registry = Arc::new(LanguageRegistry::test(cx.executor())); + let reload_count = registry.reload_count(); + + let update = registry.update_extension_languages( + &[], + &[], + vec![ + extension_language_registration("First", "first"), + extension_language_registration("Second", "second"), + extension_language_registration("Third", "third"), + ], + ); + assert_eq!( + update.registrations(), + [LanguageRegistrationStatus::Registered; 3] + ); + assert_eq!(registry.reload_count(), reload_count + 1); + + let version = registry.version(); + let update = registry.update_extension_languages(&[], &[], Vec::new()); + assert!(update.removed().is_empty() && update.registrations().is_empty()); + assert_eq!(registry.version(), version); + assert_eq!(registry.reload_count(), reload_count + 1); + } } diff --git a/crates/language_extension/src/language_extension.rs b/crates/language_extension/src/language_extension.rs index 7fa675164a2..552f67cbd81 100644 --- a/crates/language_extension/src/language_extension.rs +++ b/crates/language_extension/src/language_extension.rs @@ -6,7 +6,9 @@ use std::sync::Arc; use anyhow::Result; use extension::{ExtensionGrammarProxy, ExtensionHostProxy, ExtensionLanguageProxy}; use gpui::{App, Entity, WeakEntity}; -use language::{LanguageLoader, LanguageMatcher, LanguageName, LanguageRegistry}; +use language::{ + ExtensionLanguagesUpdateOutcome, LanguageName, LanguageRegistration, LanguageRegistry, +}; use project::LspStore; #[derive(Clone)] @@ -44,30 +46,17 @@ impl ExtensionGrammarProxy for LanguageServerRegistryProxy { } impl ExtensionLanguageProxy for LanguageServerRegistryProxy { - fn register_language( - &self, - language: LanguageName, - grammar: Option>, - matcher: Arc, - hidden: bool, - load: LanguageLoader, - ) -> bool { - self.language_registry - .register_extension_language(language, grammar, matcher, hidden, None, load) - } - - fn is_language_registered(&self, language: &LanguageName) -> bool { - self.language_registry - .available_language_for_name(language.0.as_ref()) - .is_some() - } - - fn remove_languages( + #[ztracing::instrument(skip_all)] + fn update_languages( &self, languages_to_remove: &[LanguageName], grammars_to_remove: &[Arc], - ) { - self.language_registry - .remove_languages(languages_to_remove, grammars_to_remove); + registrations: Vec, + ) -> ExtensionLanguagesUpdateOutcome { + self.language_registry.update_extension_languages( + languages_to_remove, + grammars_to_remove, + registrations, + ) } }