Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Load languages lazily in the background

Browse source
This commit is contained in:
Max Brunsfeld 2023-01-25 17:42:49 -08:00
parent 81ed961659
commit ddf4e1a316
12 changed files with 311 additions and 210 deletions
Download patch file Download diff file Expand all files Collapse all files

122
crates/zed/src/languages.rs
View file

@ -1,7 +1,5 @@
use anyhow::Context;
use gpui::executor::Background;
pub use language::*;
use lazy_static::lazy_static;
use rust_embed::RustEmbed;
use std::{borrow::Cow, str, sync::Arc};
@ -32,32 +30,17 @@ mod typescript;
#[exclude = "*.rs"]
struct LanguageDir;
// TODO - Remove this once the `init` function is synchronous again.
lazy_static! {
pub static ref LANGUAGE_NAMES: Vec<String> = LanguageDir::iter()
.filter_map(|path| {
if path.ends_with("config.toml") {
let config = LanguageDir::get(&path)?;
let config = toml::from_slice::<LanguageConfig>(&config.data).ok()?;
Some(config.name.to_string())
} else {
None
}
})
.collect();
}
pub async fn init(languages: Arc<LanguageRegistry>, _executor: Arc<Background>) {
pub fn init(languages: Arc<LanguageRegistry>) {
for (name, grammar, lsp_adapter) in [
(
"c",
tree_sitter_c::language(),
Some(CachedLspAdapter::new(c::CLspAdapter).await),
Some(Box::new(c::CLspAdapter) as Box<dyn LspAdapter>),
),
(
"cpp",
tree_sitter_cpp::language(),
Some(CachedLspAdapter::new(c::CLspAdapter).await),
Some(Box::new(c::CLspAdapter)),
),
(
"css",
@ -67,17 +50,17 @@ pub async fn init(languages: Arc<LanguageRegistry>, _executor: Arc<Background>)
(
"elixir",
tree_sitter_elixir::language(),
Some(CachedLspAdapter::new(elixir::ElixirLspAdapter).await),
Some(Box::new(elixir::ElixirLspAdapter)),
),
(
"go",
tree_sitter_go::language(),
Some(CachedLspAdapter::new(go::GoLspAdapter).await),
Some(Box::new(go::GoLspAdapter)),
),
(
"json",
tree_sitter_json::language(),
Some(CachedLspAdapter::new(json::JsonLspAdapter).await),
Some(Box::new(json::JsonLspAdapter)),
),
(
"markdown",
@ -87,12 +70,12 @@ pub async fn init(languages: Arc<LanguageRegistry>, _executor: Arc<Background>)
(
"python",
tree_sitter_python::language(),
Some(CachedLspAdapter::new(python::PythonLspAdapter).await),
Some(Box::new(python::PythonLspAdapter)),
),
(
"rust",
tree_sitter_rust::language(),
Some(CachedLspAdapter::new(rust::RustLspAdapter).await),
Some(Box::new(rust::RustLspAdapter)),
),
(
"toml",
@ -102,89 +85,82 @@ pub async fn init(languages: Arc<LanguageRegistry>, _executor: Arc<Background>)
(
"tsx",
tree_sitter_typescript::language_tsx(),
Some(CachedLspAdapter::new(typescript::TypeScriptLspAdapter).await),
Some(Box::new(typescript::TypeScriptLspAdapter)),
),
(
"typescript",
tree_sitter_typescript::language_typescript(),
Some(CachedLspAdapter::new(typescript::TypeScriptLspAdapter).await),
Some(Box::new(typescript::TypeScriptLspAdapter)),
),
(
"javascript",
tree_sitter_typescript::language_tsx(),
Some(CachedLspAdapter::new(typescript::TypeScriptLspAdapter).await),
Some(Box::new(typescript::TypeScriptLspAdapter)),
),
(
"html",
tree_sitter_html::language(),
Some(CachedLspAdapter::new(html::HtmlLspAdapter).await),
Some(Box::new(html::HtmlLspAdapter)),
),
(
"ruby",
tree_sitter_ruby::language(),
Some(CachedLspAdapter::new(ruby::RubyLanguageServer).await),
Some(Box::new(ruby::RubyLanguageServer)),
),
(
"erb",
tree_sitter_embedded_template::language(),
Some(CachedLspAdapter::new(ruby::RubyLanguageServer).await),
Some(Box::new(ruby::RubyLanguageServer)),
),
(
"scheme",
tree_sitter_scheme::language(),
None, //
),
(
"racket",
tree_sitter_racket::language(),
None, //
),
("scheme", tree_sitter_scheme::language(), None),
("racket", tree_sitter_racket::language(), None),
] {
languages.add(language(name, grammar, lsp_adapter));
languages.register(name, load_config(name), grammar, lsp_adapter, load_queries);
}
}
pub(crate) fn language(
#[cfg(any(test, feature = "test-support"))]
pub async fn language(
name: &str,
grammar: tree_sitter::Language,
lsp_adapter: Option<Arc<CachedLspAdapter>>,
lsp_adapter: Option<Box<dyn LspAdapter>>,
) -> Arc<Language> {
let config = toml::from_slice(
Arc::new(
Language::new(load_config(name), Some(grammar))
.with_lsp_adapter(lsp_adapter)
.await
.with_queries(load_queries(name))
.unwrap(),
)
}
fn load_config(name: &str) -> LanguageConfig {
toml::from_slice(
&LanguageDir::get(&format!("{}/config.toml", name))
.unwrap()
.data,
)
.with_context(|| format!("failed to load config.toml for language {name:?}"))
.unwrap();
.unwrap()
}
let mut language = Language::new(config, Some(grammar));
if let Some(query) = load_query(name, "/highlights") {
language = language
.with_highlights_query(query.as_ref())
.expect("failed to evaluate highlights query");
fn load_queries(name: &str) -> LanguageQueries {
LanguageQueries {
highlights: load_query(name, "/highlights"),
brackets: load_query(name, "/brackets"),
indents: load_query(name, "/indents"),
outline: load_query(name, "/outline"),
injections: load_query(name, "/injections"),
overrides: load_query(name, "/overrides"),
}
if let Some(query) = load_query(name, "/brackets") {
language = language
.with_brackets_query(query.as_ref())
.expect("failed to load brackets query");
}
if let Some(query) = load_query(name, "/indents") {
language = language
.with_indents_query(query.as_ref())
.expect("failed to load indents query");
}
if let Some(query) = load_query(name, "/outline") {
language = language
.with_outline_query(query.as_ref())
.expect("failed to load outline query");
}
if let Some(query) = load_query(name, "/injections") {
language = language
.with_injection_query(query.as_ref())
.expect("failed to load injection query");
}
if let Some(query) = load_query(name, "/overrides") {
language = language
.with_override_query(query.as_ref())
.expect("failed to load override query");
}
if let Some(lsp_adapter) = lsp_adapter {
language = language.with_lsp_adapter(lsp_adapter)
}
Arc::new(language)
}
fn load_query(name: &str, filename_prefix: &str) -> Option<Cow<'static, str>> {

14
crates/zed/src/languages/c.rs
View file

@ -248,17 +248,19 @@ impl super::LspAdapter for CLspAdapter {
#[cfg(test)]
mod tests {
use gpui::MutableAppContext;
use gpui::TestAppContext;
use language::{AutoindentMode, Buffer};
use settings::Settings;
#[gpui::test]
fn test_c_autoindent(cx: &mut MutableAppContext) {
async fn test_c_autoindent(cx: &mut TestAppContext) {
cx.foreground().set_block_on_ticks(usize::MAX..=usize::MAX);
let mut settings = Settings::test(cx);
settings.editor_overrides.tab_size = Some(2.try_into().unwrap());
cx.set_global(settings);
let language = crate::languages::language("c", tree_sitter_c::language(), None);
cx.update(|cx| {
let mut settings = Settings::test(cx);
settings.editor_overrides.tab_size = Some(2.try_into().unwrap());
cx.set_global(settings);
});
let language = crate::languages::language("c", tree_sitter_c::language(), None).await;
cx.add_model(|cx| {
let mut buffer = Buffer::new(0, "", cx).with_language(language, cx);

5
crates/zed/src/languages/go.rs
View file

@ -314,8 +314,9 @@ mod tests {
let language = language(
"go",
tree_sitter_go::language(),
Some(CachedLspAdapter::new(GoLspAdapter).await),
);
Some(Box::new(GoLspAdapter)),
)
.await;
let theme = SyntaxTheme::new(vec![
("type".into(), Color::green().into()),

15
crates/zed/src/languages/python.rs
View file

@ -165,17 +165,20 @@ impl LspAdapter for PythonLspAdapter {
#[cfg(test)]
mod tests {
use gpui::{ModelContext, MutableAppContext};
use gpui::{ModelContext, TestAppContext};
use language::{AutoindentMode, Buffer};
use settings::Settings;
#[gpui::test]
fn test_python_autoindent(cx: &mut MutableAppContext) {
async fn test_python_autoindent(cx: &mut TestAppContext) {
cx.foreground().set_block_on_ticks(usize::MAX..=usize::MAX);
let language = crate::languages::language("python", tree_sitter_python::language(), None);
let mut settings = Settings::test(cx);
settings.editor_overrides.tab_size = Some(2.try_into().unwrap());
cx.set_global(settings);
let language =
crate::languages::language("python", tree_sitter_python::language(), None).await;
cx.update(|cx| {
let mut settings = Settings::test(cx);
settings.editor_overrides.tab_size = Some(2.try_into().unwrap());
cx.set_global(settings);
});
cx.add_model(|cx| {
let mut buffer = Buffer::new(0, "", cx).with_language(language, cx);

27
crates/zed/src/languages/rust.rs
View file

@ -255,8 +255,8 @@ impl LspAdapter for RustLspAdapter {
#[cfg(test)]
mod tests {
use super::*;
use crate::languages::{language, CachedLspAdapter};
use gpui::{color::Color, MutableAppContext};
use crate::languages::language;
use gpui::{color::Color, TestAppContext};
use settings::Settings;
use theme::SyntaxTheme;
@ -306,8 +306,9 @@ mod tests {
let language = language(
"rust",
tree_sitter_rust::language(),
Some(CachedLspAdapter::new(RustLspAdapter).await),
);
Some(Box::new(RustLspAdapter)),
)
.await;
let grammar = language.grammar().unwrap();
let theme = SyntaxTheme::new(vec![
("type".into(), Color::green().into()),
@ -391,8 +392,9 @@ mod tests {
let language = language(
"rust",
tree_sitter_rust::language(),
Some(CachedLspAdapter::new(RustLspAdapter).await),
);
Some(Box::new(RustLspAdapter)),
)
.await;
let grammar = language.grammar().unwrap();
let theme = SyntaxTheme::new(vec![
("type".into(), Color::green().into()),
@ -431,12 +433,15 @@ mod tests {
}
#[gpui::test]
fn test_rust_autoindent(cx: &mut MutableAppContext) {
async fn test_rust_autoindent(cx: &mut TestAppContext) {
cx.foreground().set_block_on_ticks(usize::MAX..=usize::MAX);
let language = crate::languages::language("rust", tree_sitter_rust::language(), None);
let mut settings = Settings::test(cx);
settings.editor_overrides.tab_size = Some(2.try_into().unwrap());
cx.set_global(settings);
cx.update(|cx| {
let mut settings = Settings::test(cx);
settings.editor_overrides.tab_size = Some(2.try_into().unwrap());
cx.set_global(settings);
});
let language = crate::languages::language("rust", tree_sitter_rust::language(), None).await;
cx.add_model(|cx| {
let mut buffer = Buffer::new(0, "", cx).with_language(language, cx);

10
crates/zed/src/languages/typescript.rs
View file

@ -154,17 +154,17 @@ impl LspAdapter for TypeScriptLspAdapter {
#[cfg(test)]
mod tests {
use gpui::MutableAppContext;
use gpui::TestAppContext;
use unindent::Unindent;
#[gpui::test]
fn test_outline(cx: &mut MutableAppContext) {
async fn test_outline(cx: &mut TestAppContext) {
let language = crate::languages::language(
"typescript",
tree_sitter_typescript::language_typescript(),
None,
);
)
.await;
let text = r#"
function a() {
@ -183,7 +183,7 @@ mod tests {
let buffer =
cx.add_model(|cx| language::Buffer::new(0, text, cx).with_language(language, cx));
let outline = buffer.read(cx).snapshot().outline(None).unwrap();
let outline = buffer.read_with(cx, |buffer, _| buffer.snapshot().outline(None).unwrap());
assert_eq!(
outline
.items

14
crates/zed/src/main.rs
View file

@ -120,11 +120,10 @@ fn main() {
let client = client::Client::new(http.clone(), cx);
let mut languages = LanguageRegistry::new(login_shell_env_loaded);
languages.set_executor(cx.background().clone());
languages.set_language_server_download_dir(paths::LANGUAGES_DIR.clone());
let languages = Arc::new(languages);
let init_languages = cx
.background()
.spawn(languages::init(languages.clone(), cx.background().clone()));
languages::init(languages.clone());
let user_store = cx.add_model(|cx| UserStore::new(client.clone(), http.clone(), cx));
watch_keymap_file(keymap_file, cx);
@ -152,14 +151,7 @@ fn main() {
cx.spawn(|cx| watch_themes(fs.clone(), themes.clone(), cx))
.detach();
cx.spawn({
let languages = languages.clone();
|cx| async move {
cx.read(|cx| languages.set_theme(cx.global::<Settings>().theme.clone()));
init_languages.await;
}
})
.detach();
languages.set_theme(cx.global::<Settings>().theme.clone());
cx.observe_global::<Settings, _>({
let languages = languages.clone();
move |cx| languages.set_theme(cx.global::<Settings>().theme.clone())

4
crates/zed/src/zed.rs
View file

@ -306,7 +306,7 @@ pub fn initialize_workspace(
)
.map(|meta| meta.name)
.collect();
let language_names = &languages::LANGUAGE_NAMES;
let language_names = app_state.languages.language_names();
workspace.project().update(cx, |project, cx| {
let action_names = cx.all_action_names().collect::<Vec<_>>();
@ -318,7 +318,7 @@ pub fn initialize_workspace(
"schemas": [
{
"fileMatch": [schema_file_match(&paths::SETTINGS)],
"schema": settings_file_json_schema(theme_names, language_names),
"schema": settings_file_json_schema(theme_names, &language_names),
},
{
"fileMatch": [schema_file_match(&paths::KEYMAP)],