1use anyhow::Context as _;
2use gpui::{App, SharedString, UpdateGlobal};
3use node_runtime::NodeRuntime;
4use project::Fs;
5use python::PyprojectTomlManifestProvider;
6use rust::CargoManifestProvider;
7use rust_embed::RustEmbed;
8use settings::{SemanticTokenRules, SettingsStore};
9use smol::stream::StreamExt;
10use std::{str, sync::Arc};
11use util::{ResultExt, asset_str};
12
13pub use language::*;
14
15use crate::{
16 json::JsonTaskProvider,
17 python::{BasedPyrightLspAdapter, RuffLspAdapter},
18};
19
20mod bash;
21mod c;
22mod cpp;
23mod css;
24mod eslint;
25mod go;
26mod json;
27mod package_json;
28mod python;
29mod rust;
30mod tailwind;
31mod tailwindcss;
32mod typescript;
33mod vtsls;
34mod yaml;
35
36pub(crate) use package_json::{PackageJson, PackageJsonData};
37
38#[derive(RustEmbed)]
39#[folder = "src/"]
40#[exclude = "*.rs"]
41struct LanguageDir;
42
43/// A shared grammar for plain text, exposed for reuse by downstream crates.
44#[cfg(feature = "tree-sitter-gitcommit")]
45pub static LANGUAGE_GIT_COMMIT: std::sync::LazyLock<Arc<Language>> =
46 std::sync::LazyLock::new(|| {
47 Arc::new(Language::new(
48 LanguageConfig {
49 name: "Git Commit".into(),
50 soft_wrap: Some(language::language_settings::SoftWrap::EditorWidth),
51 matcher: LanguageMatcher {
52 path_suffixes: vec!["COMMIT_EDITMSG".to_owned()],
53 first_line_pattern: None,
54 ..LanguageMatcher::default()
55 },
56 line_comments: vec![Arc::from("#")],
57 ..LanguageConfig::default()
58 },
59 Some(tree_sitter_gitcommit::LANGUAGE.into()),
60 ))
61 });
62
63pub fn init(languages: Arc<LanguageRegistry>, fs: Arc<dyn Fs>, node: NodeRuntime, cx: &mut App) {
64 #[cfg(feature = "load-grammars")]
65 languages.register_native_grammars([
66 ("bash", tree_sitter_bash::LANGUAGE),
67 ("c", tree_sitter_c::LANGUAGE),
68 ("cpp", tree_sitter_cpp::LANGUAGE),
69 ("css", tree_sitter_css::LANGUAGE),
70 ("diff", tree_sitter_diff::LANGUAGE),
71 ("go", tree_sitter_go::LANGUAGE),
72 ("gomod", tree_sitter_go_mod::LANGUAGE),
73 ("gowork", tree_sitter_gowork::LANGUAGE),
74 ("jsdoc", tree_sitter_jsdoc::LANGUAGE),
75 ("json", tree_sitter_json::LANGUAGE),
76 ("jsonc", tree_sitter_json::LANGUAGE),
77 ("markdown", tree_sitter_md::LANGUAGE),
78 ("markdown-inline", tree_sitter_md::INLINE_LANGUAGE),
79 ("python", tree_sitter_python::LANGUAGE),
80 ("regex", tree_sitter_regex::LANGUAGE),
81 ("rust", tree_sitter_rust::LANGUAGE),
82 ("tsx", tree_sitter_typescript::LANGUAGE_TSX),
83 ("typescript", tree_sitter_typescript::LANGUAGE_TYPESCRIPT),
84 ("yaml", tree_sitter_yaml::LANGUAGE),
85 ("gitcommit", tree_sitter_gitcommit::LANGUAGE),
86 ]);
87
88 let c_lsp_adapter = Arc::new(c::CLspAdapter);
89 let css_lsp_adapter = Arc::new(css::CssLspAdapter::new(node.clone()));
90 let eslint_adapter = Arc::new(eslint::EsLintLspAdapter::new(node.clone()));
91 let go_context_provider = Arc::new(go::GoContextProvider);
92 let go_lsp_adapter = Arc::new(go::GoLspAdapter);
93 let json_context_provider = Arc::new(JsonTaskProvider);
94 let json_lsp_adapter = Arc::new(json::JsonLspAdapter::new(languages.clone(), node.clone()));
95 let node_version_lsp_adapter = Arc::new(json::NodeVersionAdapter);
96 let py_lsp_adapter = Arc::new(python::PyLspAdapter::new());
97 let ty_lsp_adapter = Arc::new(python::TyLspAdapter::new(fs.clone()));
98 let python_context_provider = Arc::new(python::PythonContextProvider);
99 let python_lsp_adapter = Arc::new(python::PyrightLspAdapter::new(node.clone()));
100 let basedpyright_lsp_adapter = Arc::new(BasedPyrightLspAdapter::new(node.clone()));
101 let ruff_lsp_adapter = Arc::new(RuffLspAdapter::new(fs.clone()));
102 let python_toolchain_provider = Arc::new(python::PythonToolchainProvider);
103 let rust_context_provider = Arc::new(rust::RustContextProvider);
104 let rust_lsp_adapter = Arc::new(rust::RustLspAdapter);
105 let tailwind_adapter = Arc::new(tailwind::TailwindLspAdapter::new(node.clone()));
106 let tailwindcss_adapter = Arc::new(tailwindcss::TailwindCssLspAdapter::new(node.clone()));
107 let typescript_context = Arc::new(typescript::TypeScriptContextProvider::new(fs.clone()));
108 let typescript_lsp_adapter = Arc::new(typescript::TypeScriptLspAdapter::new(
109 node.clone(),
110 fs.clone(),
111 ));
112 let vtsls_adapter = Arc::new(vtsls::VtslsLspAdapter::new(node.clone(), fs.clone()));
113 let yaml_lsp_adapter = Arc::new(yaml::YamlLspAdapter::new(node));
114
115 let built_in_languages = [
116 LanguageInfo {
117 name: "bash",
118 context: Some(Arc::new(bash::bash_task_context())),
119 ..Default::default()
120 },
121 LanguageInfo {
122 name: "c",
123 adapters: vec![c_lsp_adapter.clone()],
124 ..Default::default()
125 },
126 LanguageInfo {
127 name: "cpp",
128 adapters: vec![c_lsp_adapter],
129 semantic_token_rules: Some(cpp::semantic_token_rules()),
130 ..Default::default()
131 },
132 LanguageInfo {
133 name: "css",
134 adapters: vec![css_lsp_adapter],
135 ..Default::default()
136 },
137 LanguageInfo {
138 name: "diff",
139 adapters: vec![],
140 ..Default::default()
141 },
142 LanguageInfo {
143 name: "go",
144 adapters: vec![go_lsp_adapter.clone()],
145 context: Some(go_context_provider.clone()),
146 semantic_token_rules: Some(go::semantic_token_rules()),
147 ..Default::default()
148 },
149 LanguageInfo {
150 name: "gomod",
151 adapters: vec![go_lsp_adapter.clone()],
152 context: Some(go_context_provider.clone()),
153 ..Default::default()
154 },
155 LanguageInfo {
156 name: "gowork",
157 adapters: vec![go_lsp_adapter],
158 context: Some(go_context_provider),
159 ..Default::default()
160 },
161 LanguageInfo {
162 name: "json",
163 adapters: vec![json_lsp_adapter.clone(), node_version_lsp_adapter],
164 context: Some(json_context_provider.clone()),
165 ..Default::default()
166 },
167 LanguageInfo {
168 name: "jsonc",
169 adapters: vec![json_lsp_adapter],
170 context: Some(json_context_provider),
171 ..Default::default()
172 },
173 LanguageInfo {
174 name: "markdown",
175 adapters: vec![],
176 ..Default::default()
177 },
178 LanguageInfo {
179 name: "markdown-inline",
180 adapters: vec![],
181 ..Default::default()
182 },
183 LanguageInfo {
184 name: "python",
185 adapters: vec![
186 basedpyright_lsp_adapter,
187 ruff_lsp_adapter,
188 ty_lsp_adapter,
189 py_lsp_adapter,
190 python_lsp_adapter,
191 ],
192 context: Some(python_context_provider),
193 toolchain: Some(python_toolchain_provider),
194 manifest_name: Some(SharedString::new_static("pyproject.toml").into()),
195 semantic_token_rules: Some(python::semantic_token_rules()),
196 },
197 LanguageInfo {
198 name: "rust",
199 adapters: vec![rust_lsp_adapter],
200 context: Some(rust_context_provider),
201 manifest_name: Some(SharedString::new_static("Cargo.toml").into()),
202 semantic_token_rules: Some(rust::semantic_token_rules()),
203 ..Default::default()
204 },
205 LanguageInfo {
206 name: "tsx",
207 adapters: vec![typescript_lsp_adapter.clone(), vtsls_adapter.clone()],
208 context: Some(typescript_context.clone()),
209 ..Default::default()
210 },
211 LanguageInfo {
212 name: "typescript",
213 adapters: vec![typescript_lsp_adapter.clone(), vtsls_adapter.clone()],
214 context: Some(typescript_context.clone()),
215 ..Default::default()
216 },
217 LanguageInfo {
218 name: "javascript",
219 adapters: vec![typescript_lsp_adapter.clone(), vtsls_adapter.clone()],
220 context: Some(typescript_context),
221 ..Default::default()
222 },
223 LanguageInfo {
224 name: "jsdoc",
225 adapters: vec![typescript_lsp_adapter.clone(), vtsls_adapter.clone()],
226 ..Default::default()
227 },
228 LanguageInfo {
229 name: "regex",
230 adapters: vec![],
231 ..Default::default()
232 },
233 LanguageInfo {
234 name: "yaml",
235 adapters: vec![yaml_lsp_adapter],
236 ..Default::default()
237 },
238 LanguageInfo {
239 name: "gitcommit",
240 ..Default::default()
241 },
242 LanguageInfo {
243 name: "zed-keybind-context",
244 ..Default::default()
245 },
246 ];
247
248 for registration in built_in_languages {
249 register_language(
250 &languages,
251 registration.name,
252 registration.adapters,
253 registration.context,
254 registration.toolchain,
255 registration.manifest_name,
256 registration.semantic_token_rules,
257 cx,
258 );
259 }
260
261 // Register globally available language servers.
262 //
263 // This will allow users to add support for a built-in language server (e.g., Tailwind)
264 // for a given language via the `language_servers` setting:
265 //
266 // ```json
267 // {
268 // "languages": {
269 // "My Language": {
270 // "language_servers": ["tailwindcss-language-server", "..."]
271 // }
272 // }
273 // }
274 // ```
275 languages.register_available_lsp_adapter(
276 LanguageServerName("tailwindcss-language-server".into()),
277 tailwind_adapter.clone(),
278 );
279 languages.register_available_lsp_adapter(
280 LanguageServerName("tailwindcss-intellisense-css".into()),
281 tailwindcss_adapter,
282 );
283 languages.register_available_lsp_adapter(
284 LanguageServerName("eslint".into()),
285 eslint_adapter.clone(),
286 );
287 languages.register_available_lsp_adapter(LanguageServerName("vtsls".into()), vtsls_adapter);
288 languages.register_available_lsp_adapter(
289 LanguageServerName("typescript-language-server".into()),
290 typescript_lsp_adapter,
291 );
292
293 // Register Tailwind for the existing languages that should have it by default.
294 //
295 // This can be driven by the `language_servers` setting once we have a way for
296 // extensions to provide their own default value for that setting.
297 let tailwind_languages = [
298 "Astro",
299 "CSS",
300 "ERB",
301 "HTML+ERB",
302 "HEEx",
303 "HTML",
304 "JavaScript",
305 "TypeScript",
306 "PHP",
307 "Svelte",
308 "TSX",
309 "Vue.js",
310 ];
311
312 for language in tailwind_languages {
313 languages.register_lsp_adapter(language.into(), tailwind_adapter.clone());
314 }
315
316 let eslint_languages = ["TSX", "TypeScript", "JavaScript", "Vue.js", "Svelte"];
317 for language in eslint_languages {
318 languages.register_lsp_adapter(language.into(), eslint_adapter.clone());
319 }
320
321 let mut subscription = languages.subscribe();
322 let mut prev_language_settings = languages.language_settings();
323
324 cx.spawn(async move |cx| {
325 while subscription.next().await.is_some() {
326 let language_settings = languages.language_settings();
327 if language_settings != prev_language_settings {
328 cx.update(|cx| {
329 SettingsStore::update_global(cx, |settings, cx| {
330 settings
331 .set_extension_settings(
332 settings::ExtensionsSettingsContent {
333 all_languages: language_settings.clone(),
334 },
335 cx,
336 )
337 .log_err();
338 });
339 });
340 prev_language_settings = language_settings;
341 }
342 }
343 anyhow::Ok(())
344 })
345 .detach();
346 let manifest_providers: [Arc<dyn ManifestProvider>; 2] = [
347 Arc::from(CargoManifestProvider),
348 Arc::from(PyprojectTomlManifestProvider),
349 ];
350 for provider in manifest_providers {
351 project::ManifestProvidersStore::global(cx).register(provider);
352 }
353}
354
355#[derive(Default)]
356struct LanguageInfo {
357 name: &'static str,
358 adapters: Vec<Arc<dyn LspAdapter>>,
359 context: Option<Arc<dyn ContextProvider>>,
360 toolchain: Option<Arc<dyn ToolchainLister>>,
361 manifest_name: Option<ManifestName>,
362 semantic_token_rules: Option<SemanticTokenRules>,
363}
364
365fn register_language(
366 languages: &LanguageRegistry,
367 name: &'static str,
368 adapters: Vec<Arc<dyn LspAdapter>>,
369 context: Option<Arc<dyn ContextProvider>>,
370 toolchain: Option<Arc<dyn ToolchainLister>>,
371 manifest_name: Option<ManifestName>,
372 semantic_token_rules: Option<SemanticTokenRules>,
373 cx: &mut App,
374) {
375 let config = load_config(name);
376 if let Some(rules) = &semantic_token_rules {
377 SettingsStore::update_global(cx, |store, cx| {
378 store.set_language_semantic_token_rules(config.name.0.clone(), rules.clone(), cx);
379 });
380 }
381 for adapter in adapters {
382 languages.register_lsp_adapter(config.name.clone(), adapter);
383 }
384 languages.register_language(
385 config.name.clone(),
386 config.grammar.clone(),
387 config.matcher.clone(),
388 config.hidden,
389 manifest_name.clone(),
390 Arc::new(move || {
391 Ok(LoadedLanguage {
392 config: config.clone(),
393 queries: load_queries(name),
394 context_provider: context.clone(),
395 toolchain_provider: toolchain.clone(),
396 manifest_name: manifest_name.clone(),
397 })
398 }),
399 );
400}
401
402#[cfg(any(test, feature = "test-support"))]
403pub fn language(name: &str, grammar: tree_sitter::Language) -> Arc<Language> {
404 Arc::new(
405 Language::new(load_config(name), Some(grammar))
406 .with_queries(load_queries(name))
407 .unwrap(),
408 )
409}
410
411fn load_config(name: &str) -> LanguageConfig {
412 let config_toml = String::from_utf8(
413 LanguageDir::get(&format!("{}/config.toml", name))
414 .unwrap_or_else(|| panic!("missing config for language {:?}", name))
415 .data
416 .to_vec(),
417 )
418 .unwrap();
419
420 #[allow(unused_mut)]
421 let mut config: LanguageConfig = ::toml::from_str(&config_toml)
422 .with_context(|| format!("failed to load config.toml for language {name:?}"))
423 .unwrap();
424
425 #[cfg(not(any(feature = "load-grammars", test)))]
426 {
427 config = LanguageConfig {
428 name: config.name,
429 matcher: config.matcher,
430 jsx_tag_auto_close: config.jsx_tag_auto_close,
431 ..Default::default()
432 }
433 }
434
435 config
436}
437
438fn load_queries(name: &str) -> LanguageQueries {
439 let mut result = LanguageQueries::default();
440 for path in LanguageDir::iter() {
441 if let Some(remainder) = path.strip_prefix(name).and_then(|p| p.strip_prefix('/')) {
442 if !remainder.ends_with(".scm") {
443 continue;
444 }
445 for (name, query) in QUERY_FILENAME_PREFIXES {
446 if remainder.starts_with(name) {
447 let contents = asset_str::<LanguageDir>(path.as_ref());
448 match query(&mut result) {
449 None => *query(&mut result) = Some(contents),
450 Some(r) => r.to_mut().push_str(contents.as_ref()),
451 }
452 }
453 }
454 }
455 }
456 result
457}