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