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