mirror of
https://github.com/zed-industries/zed.git
synced 2026-11-19 06:59:22 +01:00
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:
@@ -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)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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()
|
||||
}),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user