Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
use crate::available_languages::{AvailableLanguage, LanguageOrigin};
use crate::{
CachedLspAdapter, File, Language, LanguageConfig, LanguageId, LanguageMatcher,
LanguageServerName, LspAdapter, ManifestName, PLAIN_TEXT, ToolchainLister,
available_languages::AvailableLanguages, language_settings::all_language_settings,
task_context::ContextProvider, with_parser,
};
use anyhow::{Context as _, Result, anyhow};
use collections::{FxHashMap, HashMap, HashSet, hash_map};
pub use language_core::{
BinaryStatus, LanguageName, LanguageQueries, LanguageServerStatusUpdate, QueryFile,
QueryFileContents, QueryFiles, ServerHealth,
};
use settings::{AllLanguageSettingsContent, LanguageSettingsContent};
use futures::{
Future,
channel::{mpsc, oneshot},
future::{BoxFuture, FutureExt as _},
};
use globset::GlobSet;
use gpui::{App, BackgroundExecutor, EntityId, Subscription};
use lsp::LanguageServerId;
use parking_lot::{Mutex, RwLock};
use postage::watch;
use smallvec::SmallVec;
use std::{
ffi::OsStr,
path::{Path, PathBuf},
sync::Arc,
};
use text::Rope;
use theme::Theme;
use util::{maybe, post_inc};
pub struct LanguageRegistry {
state: RwLock<LanguageRegistryState>,
language_server_download_dir: Option<Arc<Path>>,
executor: BackgroundExecutor,
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>>,
language_settings: AllLanguageSettingsContent,
available_languages: AvailableLanguages,
grammars: HashMap<Arc<str>, AvailableGrammar>,
lsp_adapters: HashMap<LanguageName, Vec<Arc<CachedLspAdapter>>>,
all_lsp_adapters: HashMap<LanguageServerName, Arc<CachedLspAdapter>>,
available_lsp_adapters:
HashMap<LanguageServerName, Arc<dyn Fn() -> Arc<CachedLspAdapter> + 'static + Send + Sync>>,
loading_languages: HashMap<LanguageId, Vec<oneshot::Sender<Result<Arc<Language>>>>>,
subscription: (watch::Sender<()>, watch::Receiver<()>),
theme: Option<Arc<Theme>>,
version: usize,
reload_count: usize,
#[cfg(any(test, feature = "test-support"))]
fake_server_entries: HashMap<LanguageServerName, FakeLanguageServerEntry>,
}
#[cfg(any(test, feature = "test-support"))]
pub struct FakeLanguageServerEntry {
pub capabilities: lsp::ServerCapabilities,
pub initializer: Option<Box<dyn 'static + Send + Sync + Fn(&mut lsp::FakeLanguageServer)>>,
pub tx: futures::channel::mpsc::UnboundedSender<lsp::FakeLanguageServer>,
pub _server: Option<lsp::FakeLanguageServer>,
}
enum AvailableGrammar {
Native(tree_sitter::Language),
Loaded(#[allow(unused)] PathBuf, tree_sitter::Language),
Loading(
#[allow(unused)] PathBuf,
Vec<oneshot::Sender<Result<tree_sitter::Language, Arc<anyhow::Error>>>>,
),
Unloaded(PathBuf),
LoadFailed(Arc<anyhow::Error>),
}
#[derive(Debug)]
pub struct LanguageNotFound;
impl std::fmt::Display for LanguageNotFound {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "language not found")
}
}
type ServerStatus = (Option<EntityId>, LanguageServerName, BinaryStatus);
#[derive(Clone, Default)]
struct ServerStatusSender {
state: Arc<Mutex<ServerStatusSenderState>>,
}
#[derive(Default)]
struct ServerStatusSenderState {
next_subscription_id: usize,
txs: HashMap<usize, mpsc::UnboundedSender<ServerStatus>>,
}
pub struct LoadedLanguage {
pub config: LanguageConfig,
pub queries: LanguageQueries,
pub context_provider: Option<Arc<dyn ContextProvider>>,
pub toolchain_provider: Option<Arc<dyn ToolchainLister>>,
pub manifest_name: Option<ManifestName>,
}
pub type LanguageLoader =
Arc<dyn Fn() -> BoxFuture<'static, Result<LoadedLanguage>> + Send + Sync + 'static>;
impl LanguageRegistry {
pub fn new(executor: BackgroundExecutor) -> Self {
let this = Self {
state: RwLock::new(LanguageRegistryState {
next_language_server_id: 0,
languages: Vec::new(),
available_languages: AvailableLanguages::default(),
grammars: Default::default(),
language_settings: Default::default(),
loading_languages: Default::default(),
lsp_adapters: Default::default(),
all_lsp_adapters: Default::default(),
available_lsp_adapters: HashMap::default(),
subscription: watch::channel(),
theme: Default::default(),
version: 0,
reload_count: 0,
#[cfg(any(test, feature = "test-support"))]
fake_server_entries: Default::default(),
}),
language_server_download_dir: None,
lsp_binary_status_tx: Default::default(),
executor,
};
this.add(PLAIN_TEXT.clone());
this
}
#[cfg(any(test, feature = "test-support"))]
pub fn test(executor: BackgroundExecutor) -> Self {
let mut this = Self::new(executor);
this.language_server_download_dir = Some(Path::new("/the-download-dir").into());
this
}
/// Clears out all of the loaded languages and reload them from scratch.
pub fn reload(&self) {
self.state.write().reload();
}
/// Reorders the list of language servers for the given language.
///
/// Uses the provided list of ordered [`CachedLspAdapters`] as the desired order.
///
/// Any existing language servers not present in `ordered_lsp_adapters` will be
/// appended to the end.
pub fn reorder_language_servers(
&self,
language: &LanguageName,
ordered_lsp_adapters: Vec<Arc<CachedLspAdapter>>,
) {
self.state
.write()
.reorder_language_servers(language, ordered_lsp_adapters);
}
/// Removes the specified languages and grammars from the registry.
pub fn remove_languages(
&self,
languages_to_remove: &[LanguageName],
grammars_to_remove: &[Arc<str>],
) {
self.update_extension_languages(languages_to_remove, grammars_to_remove, Vec::new());
}
pub fn remove_lsp_adapter(&self, language_name: &LanguageName, name: &LanguageServerName) {
let mut state = self.state.write();
if let Some(adapters) = state.lsp_adapters.get_mut(language_name) {
adapters.retain(|adapter| &adapter.name != name)
}
state.all_lsp_adapters.remove(name);
state.available_lsp_adapters.remove(name);
state.version += 1;
state.reload_count += 1;
*state.subscription.0.borrow_mut() = ();
}
#[cfg(any(feature = "test-support", test))]
pub fn register_test_language(&self, config: LanguageConfig) {
self.register_language(
config.name.clone(),
config.grammar.clone(),
config.matcher.clone(),
config.hidden,
None,
Arc::new(move || {
let config = config.clone();
async move {
Ok(LoadedLanguage {
config,
queries: Default::default(),
toolchain_provider: None,
context_provider: None,
manifest_name: None,
})
}
.boxed()
}),
)
}
/// Registers an available language server adapter.
///
/// The language server is registered under the language server name, but
/// not bound to a particular language.
///
/// When a language wants to load this particular language server, it will
/// invoke the `load` function.
pub fn register_available_lsp_adapter(
&self,
name: LanguageServerName,
adapter: Arc<dyn LspAdapter>,
) {
let mut state = self.state.write();
if adapter.is_extension()
&& let Some(existing_adapter) = state.all_lsp_adapters.get(&name)
&& !existing_adapter.adapter.is_extension()
{
log::warn!(
"not registering extension-provided language server {name:?}, since a builtin language server exists with that name",
);
return;
}
state.available_lsp_adapters.insert(
name,
Arc::new(move || CachedLspAdapter::new(adapter.clone())),
);
}
/// Loads the language server adapter for the language server with the given name.
pub fn load_available_lsp_adapter(
&self,
name: &LanguageServerName,
) -> Option<Arc<CachedLspAdapter>> {
let state = self.state.read();
let load_lsp_adapter = state.available_lsp_adapters.get(name)?;
Some(load_lsp_adapter())
}
/// Checks if a language server adapter with the given name is available to be loaded.
pub fn is_lsp_adapter_available(&self, name: &LanguageServerName) -> bool {
let state = self.state.read();
state.available_lsp_adapters.contains_key(name)
}
/// Returns the names of all available LSP adapters (registered via `register_available_lsp_adapter`).
/// These are adapters that are not bound to a specific language but can be enabled via settings.
pub fn available_lsp_adapter_names(&self) -> Vec<LanguageServerName> {
self.state
.read()
.available_lsp_adapters
.keys()
.cloned()
.collect()
}
pub fn register_lsp_adapter(&self, language_name: LanguageName, adapter: Arc<dyn LspAdapter>) {
let mut state = self.state.write();
if adapter.is_extension()
&& let Some(existing_adapter) = state.all_lsp_adapters.get(&adapter.name())
&& !existing_adapter.adapter.is_extension()
{
log::warn!(
"not registering extension-provided language server {:?} for language {language_name:?}, since a builtin language server exists with that name",
adapter.name(),
);
return;
}
let cached = CachedLspAdapter::new(adapter);
state
.lsp_adapters
.entry(language_name)
.or_default()
.push(cached.clone());
state
.all_lsp_adapters
.insert(cached.name.clone(), cached.clone());
state.version += 1;
*state.subscription.0.borrow_mut() = ();
}
/// Register a fake language server and adapter
/// The returned channel receives a new instance of the language server every time it is started
#[cfg(any(feature = "test-support", test))]
pub fn register_fake_lsp(
&self,
language_name: impl Into<LanguageName>,
mut adapter: crate::FakeLspAdapter,
) -> futures::channel::mpsc::UnboundedReceiver<lsp::FakeLanguageServer> {
let adapter_name = LanguageServerName(adapter.name.into());
let capabilities = adapter.capabilities.clone();
let initializer = adapter.initializer.take();
self.register_fake_lsp_adapter(language_name, adapter);
self.register_fake_lsp_server(adapter_name, capabilities, initializer)
}
/// Register a fake lsp adapter (without the language server)
#[cfg(any(feature = "test-support", test))]
pub fn register_fake_lsp_adapter(
&self,
language_name: impl Into<LanguageName>,
adapter: crate::FakeLspAdapter,
) {
let language_name = language_name.into();
let mut state = self.state.write();
let cached_adapter = CachedLspAdapter::new(Arc::new(adapter));
state
.lsp_adapters
.entry(language_name)
.or_default()
.push(cached_adapter.clone());
state
.all_lsp_adapters
.insert(cached_adapter.name(), cached_adapter);
state.version += 1;
*state.subscription.0.borrow_mut() = ();
}
/// Register a fake language server (without the adapter)
/// The returned channel receives a new instance of the language server every time it is started
#[cfg(any(feature = "test-support", test))]
pub fn register_fake_lsp_server(
&self,
lsp_name: LanguageServerName,
capabilities: lsp::ServerCapabilities,
initializer: Option<Box<dyn Fn(&mut lsp::FakeLanguageServer) + Send + Sync>>,
) -> futures::channel::mpsc::UnboundedReceiver<lsp::FakeLanguageServer> {
let (servers_tx, servers_rx) = futures::channel::mpsc::unbounded();
self.state.write().fake_server_entries.insert(
lsp_name,
FakeLanguageServerEntry {
tx: servers_tx,
capabilities,
initializer,
_server: None,
},
);
servers_rx
}
#[cfg(any(feature = "test-support", test))]
pub fn register_fake_available_lsp_adapter(
&self,
name: impl Into<LanguageServerName>,
adapter: crate::FakeLspAdapter,
) {
let name = name.into();
let adapter = Arc::new(adapter);
let mut state = self.state.write();
state.available_lsp_adapters.insert(
name,
Arc::new(move || CachedLspAdapter::new(adapter.clone())),
);
}
#[cfg(any(feature = "test-support", test))]
pub fn has_fake_lsp_server(&self, lsp_name: &LanguageServerName) -> bool {
self.state.read().fake_server_entries.contains_key(lsp_name)
}
/// Adds a language to the registry, which can be loaded if needed.
pub fn register_language(
&self,
name: LanguageName,
grammar_name: Option<Arc<str>>,
matcher: Arc<LanguageMatcher>,
hidden: bool,
manifest_name: Option<ManifestName>,
load: LanguageLoader,
) {
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,
manifest_name,
load,
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() = ();
}
/// 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
/// grammar controls how the source code is parsed.
pub fn register_native_grammars(
&self,
grammars: impl IntoIterator<Item = (impl Into<Arc<str>>, impl Into<tree_sitter::Language>)>,
) {
self.state.write().grammars.extend(
grammars
.into_iter()
.map(|(name, grammar)| (name.into(), AvailableGrammar::Native(grammar.into()))),
);
}
/// Adds paths to WASM grammar files, which can be loaded if needed.
pub fn register_wasm_grammars(&self, grammars: Vec<(Arc<str>, PathBuf)>) {
if grammars.is_empty() {
return;
}
let mut state = self.state.write();
for (name, path) in grammars {
if let Some(AvailableGrammar::Native(_)) = state.grammars.get(&name) {
log::warn!(
"not registering extension grammar {name}: a native grammar with this name is already registered"
);
continue;
}
state
.grammars
.insert(name, AvailableGrammar::Unloaded(path));
}
state.version += 1;
state.reload_count += 1;
*state.subscription.0.borrow_mut() = ();
}
pub fn language_settings(&self) -> AllLanguageSettingsContent {
self.state.read().language_settings.clone()
}
pub fn language_names(&self) -> Vec<LanguageName> {
let state = self.state.read();
let mut result = state.available_languages.unloaded_language_names();
result.extend(
state
.languages
.iter()
.map(|language| language.config.name.clone()),
);
result.sort_unstable_by_key(|language_name| language_name.as_ref().to_lowercase());
result
}
pub fn grammar_names(&self) -> Vec<Arc<str>> {
let state = self.state.read();
let mut result = state.grammars.keys().cloned().collect::<Vec<_>>();
result.sort_unstable_by_key(|grammar_name| grammar_name.to_lowercase());
result
}
/// Add a pre-loaded language to the registry.
pub fn add(&self, language: Arc<Language>) {
let mut state = self.state.write();
state.available_languages.add(AvailableLanguage {
id: language.id,
name: language.name(),
grammar: language.config.grammar.clone(),
matcher: language.config.matcher.clone(),
hidden: language.config.hidden,
manifest_name: None,
load: Arc::new(|| async { Err(anyhow!("already loaded")) }.boxed()),
loaded: true,
origin: LanguageOrigin::Native,
});
state.add(language);
}
pub fn subscribe(&self) -> watch::Receiver<()> {
self.state.read().subscription.1.clone()
}
/// Returns the number of times that the registry has been changed,
/// by adding languages or reloading.
pub fn version(&self) -> usize {
self.state.read().version
}
/// Returns the number of times that the registry has been reloaded.
pub fn reload_count(&self) -> usize {
self.state.read().reload_count
}
pub fn set_theme(&self, theme: Arc<Theme>) {
let mut state = self.state.write();
state.theme = Some(theme.clone());
for language in &state.languages {
language.set_theme(theme.syntax());
}
}
pub fn set_language_server_download_dir(&mut self, path: impl Into<Arc<Path>>) {
self.language_server_download_dir = Some(path.into());
}
pub fn language_for_name(
self: &Arc<Self>,
name: &str,
) -> impl Future<Output = Result<Arc<Language>>> + use<> {
let language_id = self.state.read().available_languages.find_by_name(name);
let rx = self.get_or_load_language(language_id);
async move { rx.await? }
}
#[cfg(any(test, feature = "test-support"))]
pub fn language_name_for_id(&self, id: LanguageId) -> Option<LanguageName> {
self.state.read().available_languages.name_for_id(id)
}
pub fn language_name_for_extension(self: &Arc<Self>, extension: &str) -> Option<LanguageName> {
self.state
.try_read()
.and_then(|state| state.available_languages.find_name_by_extension(extension))
}
pub fn language_for_name_or_extension(
self: &Arc<Self>,
string: &str,
) -> impl Future<Output = Result<Arc<Language>>> {
let language_id = self
.state
.read()
.available_languages
.find_by_name_or_extension(string);
let rx = self.get_or_load_language(language_id);
async move { rx.await? }
}
pub fn available_language_for_name(self: &Arc<Self>, name: &str) -> Option<AvailableLanguage> {
let state = self.state.read();
state.available_languages.find_by_exact_name(name)
}
/// Look up a language by its modeline name (vim filetype or emacs mode).
///
/// This performs a case-insensitive match against:
/// 1. Explicit modeline aliases defined in the language config
/// 2. The language's grammar name
/// 3. The language name itself
pub fn available_language_for_modeline_name(
self: &Arc<Self>,
modeline_name: &str,
) -> Option<AvailableLanguage> {
self.state
.read()
.available_languages
.find_by_modeline_name(modeline_name)
}
pub fn language_for_file(
self: &Arc<Self>,
file: &Arc<dyn File>,
content: Option<&Rope>,
cx: &App,
) -> Option<LanguageId> {
let user_file_types = all_language_settings(Some(file), cx);
let filename = file
.path()
.file_name()
.unwrap_or_else(|| file.file_name(cx));
let paths = [Some(file.full_path(cx)), file.file_system_abs_path(cx)];
let path_style = file.path_style(cx);
let normalized_paths = paths.each_ref().map(|path| {
if path_style.is_windows()
&& let Some(path) = path.as_deref().and_then(Path::to_str)
&& path.contains('\\')
{
Some(PathBuf::from(path.replace('\\', "/")))
} else {
None
}
});
let paths = paths
.iter()
.filter_map(Option::as_deref)
.chain(normalized_paths.iter().filter_map(Option::as_deref))
.collect::<SmallVec<[_; 4]>>();
self.language_for_file_internal(
Some(filename),
&paths,
content,
Some(&user_file_types.file_types),
)
}
pub fn language_for_file_path(self: &Arc<Self>, path: &Path) -> Option<LanguageId> {
self.language_for_file_internal(
path.file_name().and_then(|filename| filename.to_str()),
&[path],
None,
None,
)
}
#[ztracing::instrument(skip_all)]
pub fn load_language_for_file_path<'a>(
self: &Arc<Self>,
path: &'a Path,
) -> impl Future<Output = Result<Arc<Language>>> + 'a {
let language = self.language_for_file_path(path);
let this = self.clone();
async move {
if let Some(language_id) = language {
this.load_language(language_id).await?
} else {
Err(anyhow!(LanguageNotFound))
}
}
}
fn language_for_file_internal(
self: &Arc<Self>,
filename: Option<&str>,
paths: &[&Path],
content: Option<&Rope>,
user_file_types: Option<&FxHashMap<Arc<str>, (GlobSet, Vec<String>)>>,
) -> Option<LanguageId> {
self.state.read().available_languages.find_for_file(
filename,
paths,
content,
user_file_types,
)
}
#[ztracing::instrument(skip_all)]
pub fn load_language(
self: &Arc<Self>,
language_id: LanguageId,
) -> oneshot::Receiver<Result<Arc<Language>>> {
let (tx, rx) = oneshot::channel();
let mut state = self.state.write();
// If the language is already loaded, resolve with it immediately.
for loaded_language in state.languages.iter() {
if loaded_language.id == language_id {
tx.send(Ok(loaded_language.clone())).unwrap();
return rx;
}
}
let Some(available_language) = state.available_languages.get_language(language_id) else {
tx.send(Err(anyhow!(LanguageNotFound))).ok();
return rx;
};
let (language_name, language_load) = (
available_language.name.clone(),
available_language.load.clone(),
);
match state.loading_languages.entry(language_id) {
// If the language is already being loaded, then add this
// channel to a list that will be sent to when the load completes.
hash_map::Entry::Occupied(mut entry) => entry.get_mut().push(tx),
// Otherwise, start loading the language.
hash_map::Entry::Vacant(entry) => {
let this = self.clone();
self.executor
.spawn(async move {
let language = async {
let loaded_language = (language_load)().await?;
if let Some(grammar) = loaded_language.config.grammar.clone() {
let grammar = Some(this.get_or_load_grammar(grammar).await?);
Language::new_with_id(language_id, loaded_language.config, grammar)
.with_context_provider(loaded_language.context_provider)
.with_toolchain_lister(loaded_language.toolchain_provider)
.with_manifest(loaded_language.manifest_name)
.with_queries(loaded_language.queries)
} else {
Ok(
Language::new_with_id(
language_id,
loaded_language.config,
None,
)
.with_context_provider(loaded_language.context_provider)
.with_manifest(loaded_language.manifest_name)
.with_toolchain_lister(loaded_language.toolchain_provider),
)
}
}
.await;
let language = language.map(Arc::new);
if let Err(error) = &language {
log::error!("failed to load language {language_name}:\n{error:?}");
}
let stale_txs = {
let mut state = this.state.write();
let is_current = state
.available_languages
.get_language(language_id)
.is_some();
if is_current {
if let Ok(language) = &language {
state.add(language.clone());
}
state.mark_language_loaded(language_id);
if let Some(txs) = state.loading_languages.remove(&language_id) {
for tx in txs {
let _ = tx.send(match &language {
Ok(language) => Ok(language.clone()),
Err(error) => Err(anyhow!(
"failed to load language {language_name}: {error}"
)),
});
}
}
None
} else {
let txs = state
.loading_languages
.remove(&language_id)
.unwrap_or_default();
let replacement_id = state
.available_languages
.find_by_exact_name(language_name.0.as_ref())
.map(|language| language.id());
Some((txs, replacement_id))
}
};
if let Some((txs, replacement_id)) = stale_txs
&& !txs.is_empty()
{
match replacement_id {
Some(replacement_id) => {
let result = match this.load_language(replacement_id).await {
Ok(result) => result,
Err(_) => Err(anyhow!(LanguageNotFound)),
};
match result {
Ok(replacement_language) => {
for tx in txs {
let _ = tx.send(Ok(replacement_language.clone()));
}
}
Err(error) => {
let message = format!("{error:#}");
for tx in txs {
let _ = tx.send(Err(anyhow!(
"failed to load language {language_name}: {message}"
)));
}
}
}
}
None => {
for tx in txs {
let _ = tx.send(Err(anyhow!(LanguageNotFound)));
}
}
}
}
})
.detach();
entry.insert(vec![tx]);
}
}
drop(state);
rx
}
#[ztracing::instrument(skip_all)]
fn get_or_load_language(
self: &Arc<Self>,
language_id: Option<LanguageId>,
) -> oneshot::Receiver<Result<Arc<Language>>> {
let Some(language_id) = language_id else {
let (tx, rx) = oneshot::channel();
let _ = tx.send(Err(anyhow!(LanguageNotFound)));
return rx;
};
self.load_language(language_id)
}
fn get_or_load_grammar(
self: &Arc<Self>,
name: Arc<str>,
) -> impl Future<Output = Result<tree_sitter::Language>> {
let span = ztracing::debug_span!("get_or_load_grammar", name = &*name.clone());
let _enter = span.enter();
let (tx, rx) = oneshot::channel();
let mut state = self.state.write();
if let Some(grammar) = state.grammars.get_mut(name.as_ref()) {
match grammar {
AvailableGrammar::LoadFailed(error) => {
tx.send(Err(error.clone())).ok();
}
AvailableGrammar::Native(grammar) | AvailableGrammar::Loaded(_, grammar) => {
tx.send(Ok(grammar.clone())).ok();
}
AvailableGrammar::Loading(_, txs) => {
txs.push(tx);
}
AvailableGrammar::Unloaded(wasm_path) => {
log::trace!("start loading grammar {name:?}");
let this = self.clone();
let wasm_path = wasm_path.clone();
*grammar = AvailableGrammar::Loading(wasm_path.clone(), vec![tx]);
self.executor
.spawn(async move {
let grammar_result = maybe!({
let wasm_bytes = std::fs::read(&wasm_path)?;
let grammar_name = wasm_path
.file_stem()
.and_then(OsStr::to_str)
.context("invalid grammar filename")?;
anyhow::Ok(with_parser(|parser| {
let mut store = parser.take_wasm_store().unwrap();
let grammar = store.load_language(grammar_name, &wasm_bytes);
parser.set_wasm_store(store).unwrap();
grammar
})?)
})
.map_err(Arc::new);
let value = match &grammar_result {
Ok(grammar) => AvailableGrammar::Loaded(wasm_path, grammar.clone()),
Err(error) => AvailableGrammar::LoadFailed(error.clone()),
};
log::trace!("finish loading grammar {name:?}");
let old_value = this.state.write().grammars.insert(name, value);
if let Some(AvailableGrammar::Loading(_, txs)) = old_value {
for tx in txs {
tx.send(grammar_result.clone()).ok();
}
}
})
.detach();
}
}
} else {
tx.send(Err(Arc::new(anyhow!("no such grammar {name}"))))
.ok();
}
async move { rx.await?.map_err(|e| anyhow!(e)) }
}
pub fn to_vec(&self) -> Vec<Arc<Language>> {
self.state.read().languages.to_vec()
}
pub fn lsp_adapters(&self, language_name: &LanguageName) -> Vec<Arc<CachedLspAdapter>> {
self.state
.read()
.lsp_adapters
.get(language_name)
.cloned()
.unwrap_or_default()
}
pub fn lsp_adapter(
&self,
language_name: &LanguageName,
server_name: &LanguageServerName,
) -> Option<Arc<CachedLspAdapter>> {
self.state
.read()
.lsp_adapters
.get(language_name)?
.iter()
.find(|adapter| adapter.name() == *server_name)
.cloned()
}
pub fn all_lsp_adapters(&self) -> Vec<Arc<CachedLspAdapter>> {
self.state
.read()
.all_lsp_adapters
.values()
.cloned()
.collect()
}
pub fn adapter_for_name(&self, name: &LanguageServerName) -> Option<Arc<CachedLspAdapter>> {
self.state.read().all_lsp_adapters.get(name).cloned()
}
pub fn update_lsp_binary_status(&self, server_name: LanguageServerName, status: BinaryStatus) {
self.lsp_binary_status_tx.send(None, server_name, status);
}
pub fn update_lsp_binary_status_for_entity(
&self,
source: EntityId,
server_name: LanguageServerName,
status: BinaryStatus,
) {
self.lsp_binary_status_tx
.send(Some(source), server_name, status);
}
pub fn next_language_server_id(&self) -> LanguageServerId {
self.state.write().next_language_server_id()
}
pub fn language_server_download_dir(&self, name: &LanguageServerName) -> Option<Arc<Path>> {
self.language_server_download_dir
.as_ref()
.map(|dir| Arc::from(dir.join(name.0.as_ref())))
}
#[cfg(any(test, feature = "test-support"))]
pub fn create_fake_language_server(
&self,
server_id: LanguageServerId,
name: &LanguageServerName,
binary: lsp::LanguageServerBinary,
cx: &mut gpui::AsyncApp,
) -> Option<lsp::LanguageServer> {
let mut state = self.state.write();
let fake_entry = state.fake_server_entries.get_mut(name)?;
let (server, mut fake_server) = lsp::FakeLanguageServer::new(
server_id,
binary,
name.0.to_string(),
fake_entry.capabilities.clone(),
cx,
);
fake_entry._server = Some(fake_server.clone());
if let Some(initializer) = &fake_entry.initializer {
initializer(&mut fake_server);
}
// Emit synchronously so tests can reliably observe server creation even if the LSP startup
// task hasn't progressed to initialization yet.
fake_entry.tx.unbounded_send(fake_server).ok();
Some(server)
}
pub fn language_server_binary_statuses(
&self,
) -> (
mpsc::UnboundedReceiver<(Option<EntityId>, LanguageServerName, BinaryStatus)>,
Subscription,
) {
self.lsp_binary_status_tx.subscribe()
}
}
impl LanguageRegistryState {
fn next_language_server_id(&mut self) -> LanguageServerId {
LanguageServerId(post_inc(&mut self.next_language_server_id))
}
fn add(&mut self, language: Arc<Language>) {
if let Some(theme) = self.theme.as_ref() {
language.set_theme(theme.syntax());
}
self.language_settings.languages.0.insert(
language.name().0.to_string(),
LanguageSettingsContent {
tab_size: language.config.tab_size,
hard_tabs: language.config.hard_tabs,
soft_wrap: language.config.soft_wrap.map(crate::to_settings_soft_wrap),
auto_indent_on_paste: language.config.auto_indent_on_paste,
..Default::default()
},
);
self.languages.push(language);
self.version += 1;
*self.subscription.0.borrow_mut() = ();
}
fn reload(&mut self) {
self.languages.clear();
self.version += 1;
self.reload_count += 1;
self.available_languages.mark_all_unloaded();
*self.subscription.0.borrow_mut() = ();
}
/// Reorders the list of language servers for the given language.
///
/// Uses the provided list of ordered [`CachedLspAdapters`] as the desired order.
///
/// Any existing language servers not present in `ordered_lsp_adapters` will be
/// appended to the end.
fn reorder_language_servers(
&mut self,
language_name: &LanguageName,
ordered_lsp_adapters: Vec<Arc<CachedLspAdapter>>,
) {
let Some(lsp_adapters) = self.lsp_adapters.get_mut(language_name) else {
return;
};
let ordered_lsp_adapter_ids = ordered_lsp_adapters
.iter()
.map(|lsp_adapter| lsp_adapter.name.clone())
.collect::<HashSet<_>>();
let mut new_lsp_adapters = ordered_lsp_adapters;
for adapter in lsp_adapters.iter() {
if !ordered_lsp_adapter_ids.contains(&adapter.name) {
new_lsp_adapters.push(adapter.clone());
}
}
*lsp_adapters = new_lsp_adapters;
}
/// 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) {
self.available_languages.mark_loaded(id);
}
}
impl ServerStatusSender {
fn subscribe(&self) -> (mpsc::UnboundedReceiver<ServerStatus>, Subscription) {
let (tx, rx) = mpsc::unbounded();
let subscription_id = {
let mut state = self.state.lock();
let subscription_id = post_inc(&mut state.next_subscription_id);
state.txs.insert(subscription_id, tx);
subscription_id
};
let state = self.state.clone();
let subscription = Subscription::new(move || {
state.lock().txs.remove(&subscription_id);
});
(rx, subscription)
}
fn send(&self, source: Option<EntityId>, name: LanguageServerName, status: BinaryStatus) {
let mut state = self.state.lock();
state.txs.retain(|_, tx| {
tx.unbounded_send((source, name.clone(), status.clone()))
.is_ok()
});
}
}
#[cfg(test)]
mod tests {
use super::*;
use gpui::TestAppContext;
#[test]
fn dropping_server_status_subscription_unregisters_sender() {
let sender = ServerStatusSender::default();
let (_receiver, subscription) = sender.subscribe();
assert_eq!(sender.state.lock().txs.len(), 1);
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);
}
}