Skip to content

armgit / zed

Public Imported from GitHub
0

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.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<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.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::<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.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::<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.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) = &current {
for (_, config) in &current.languages {
- register_language_from_config(&self.proxy, config.clone());
+ registrations.push(language_registration_from_config(config.clone()));
}
if let Some(wasm_extension) = &current.wasm_extension {
for (server_name, language) in &current.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<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.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<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,
+ )
}
}