Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
Refactor `ExtensionLanguageProxy` to provide only `ExtensionLanguageProxy::update_languages` (#65381)
Finn Evers59dd60d4dd3b
diff --git a/crates/extension/src/extension_host_proxy.rs b/crates/extension/src/extension_host_proxy.rsindex 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<Arc<str>>,- matcher: Arc<LanguageMatcher>,- 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<str>],- );+ registrations: Vec<LanguageRegistration>,+ ) -> ExtensionLanguagesUpdateOutcome;}impl ExtensionLanguageProxy for ExtensionHostProxy {- #[ztracing::instrument(skip_all, fields(lang = language.0.as_str()))]- fn register_language(- &self,- language: LanguageName,- grammar: Option<Arc<str>>,- matcher: Arc<LanguageMatcher>,- 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<str>],- ) {+ registrations: Vec<LanguageRegistration>,+ ) -> 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.rsindex 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::<Vec<_>>();- 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::<Vec<_>>();- 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::<Vec<_>>();+ // 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.rsindex 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::<SettingsStore>()+ .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::<SettingsStore>()+ .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::<SettingsStore, _>(|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::<SettingsStore>()+ .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.rsindex 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.rsindex 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.rsindex 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<Arc<str>>,+ pub matcher: Arc<LanguageMatcher>,+ 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<LanguageName>,+ 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<Arc<Language>>,@@ -177,9 +231,7 @@ impl LanguageRegistry {languages_to_remove: &[LanguageName],grammars_to_remove: &[Arc<str>],) {- 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,71 +445,94 @@ impl LanguageRegistry {manifest_name: Option<ManifestName>,load: LanguageLoader,) {- self.register_language_with_origin(- name,- grammar_name,- matcher,- hidden,- manifest_name,- load,- LanguageOrigin::Native,- );- }-- pub fn register_extension_language(- &self,- name: LanguageName,- grammar_name: Option<Arc<str>>,- matcher: Arc<LanguageMatcher>,- hidden: bool,- manifest_name: Option<ManifestName>,- 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<Arc<str>>,- matcher: Arc<LanguageMatcher>,- hidden: bool,- manifest_name: Option<ManifestName>,- load: LanguageLoader,- origin: LanguageOrigin,- ) -> bool {let state = &mut *self.state.write();- let Some(was_loaded) = state.available_languages.register(+ // 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,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 {+ LanguageOrigin::Native,+ );+ 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<str>],+ registrations: Vec<LanguageRegistration>,+ ) -> 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::<SmallVec<[LanguageRegistrationStatus; 8]>>();++ 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<str>],- ) {- 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.rsindex 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<Arc<str>>,- matcher: Arc<LanguageMatcher>,- 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<str>],- ) {- self.language_registry- .remove_languages(languages_to_remove, grammars_to_remove);+ registrations: Vec<LanguageRegistration>,+ ) -> ExtensionLanguagesUpdateOutcome {+ self.language_registry.update_extension_languages(+ languages_to_remove,+ grammars_to_remove,+ registrations,+ )}}