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>
This commit is contained in:
Finn Evers
2026-10-21 16:49:51 +00:00
committed by GitHub
parent cd1255fba1
commit 59dd60d4dd
7 changed files with 473 additions and 209 deletions
+14 -43
View File
@@ -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)
}
}
+66 -47
View File
@@ -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();
@@ -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,
+14 -12
View File
@@ -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()
}),
);
}
}
+2 -1
View File
@@ -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,
+255 -77
View File
@@ -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,8 +445,11 @@ impl LanguageRegistry {
manifest_name: Option<ManifestName>,
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<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(
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<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);
}
}
@@ -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,
)
}
}