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