1use anyhow::Context as _;
2use feature_flags::{FeatureFlag, FeatureFlagAppExt as _};
3use gpui::{App, SharedString, UpdateGlobal};
4use node_runtime::NodeRuntime;
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::{json::JsonTaskProvider, python::BasedPyrightLspAdapter};
16
17mod bash;
18mod c;
19mod css;
20mod github_download;
21mod go;
22mod json;
23mod package_json;
24mod python;
25mod rust;
26mod tailwind;
27mod typescript;
28mod vtsls;
29mod yaml;
30
31pub(crate) use package_json::{PackageJson, PackageJsonData};
32
33#[derive(RustEmbed)]
34#[folder = "src/"]
35#[exclude = "*.rs"]
36struct LanguageDir;
37
38/// A shared grammar for plain text, exposed for reuse by downstream crates.
39#[cfg(feature = "tree-sitter-gitcommit")]
40pub static LANGUAGE_GIT_COMMIT: std::sync::LazyLock<Arc<Language>> =
41 std::sync::LazyLock::new(|| {
42 Arc::new(Language::new(
43 LanguageConfig {
44 name: "Git Commit".into(),
45 soft_wrap: Some(language::language_settings::SoftWrap::EditorWidth),
46 matcher: LanguageMatcher {
47 path_suffixes: vec!["COMMIT_EDITMSG".to_owned()],
48 first_line_pattern: None,
49 },
50 line_comments: vec![Arc::from("#")],
51 ..LanguageConfig::default()
52 },
53 Some(tree_sitter_gitcommit::LANGUAGE.into()),
54 ))
55 });
56
57struct BasedPyrightFeatureFlag;
58
59impl FeatureFlag for BasedPyrightFeatureFlag {
60 const NAME: &'static str = "basedpyright";
61}
62
63pub fn init(languages: Arc<LanguageRegistry>, 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(typescript::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(node.clone(), languages.clone()));
95 let node_version_lsp_adapter = Arc::new(json::NodeVersionAdapter);
96 let py_lsp_adapter = Arc::new(python::PyLspAdapter::new());
97 let python_context_provider = Arc::new(python::PythonContextProvider);
98 let python_lsp_adapter = Arc::new(python::PythonLspAdapter::new(node.clone()));
99 let basedpyright_lsp_adapter = Arc::new(BasedPyrightLspAdapter::new());
100 let python_toolchain_provider = Arc::new(python::PythonToolchainProvider::default());
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());
105 let typescript_lsp_adapter = Arc::new(typescript::TypeScriptLspAdapter::new(node.clone()));
106 let vtsls_adapter = Arc::new(vtsls::VtslsLspAdapter::new(node.clone()));
107 let yaml_lsp_adapter = Arc::new(yaml::YamlLspAdapter::new(node.clone()));
108
109 let built_in_languages = [
110 LanguageInfo {
111 name: "bash",
112 context: Some(Arc::new(bash::bash_task_context())),
113 ..Default::default()
114 },
115 LanguageInfo {
116 name: "c",
117 adapters: vec![c_lsp_adapter.clone()],
118 ..Default::default()
119 },
120 LanguageInfo {
121 name: "cpp",
122 adapters: vec![c_lsp_adapter.clone()],
123 ..Default::default()
124 },
125 LanguageInfo {
126 name: "css",
127 adapters: vec![css_lsp_adapter.clone()],
128 ..Default::default()
129 },
130 LanguageInfo {
131 name: "diff",
132 adapters: vec![],
133 ..Default::default()
134 },
135 LanguageInfo {
136 name: "go",
137 adapters: vec![go_lsp_adapter.clone()],
138 context: Some(go_context_provider.clone()),
139 ..Default::default()
140 },
141 LanguageInfo {
142 name: "gomod",
143 adapters: vec![go_lsp_adapter.clone()],
144 context: Some(go_context_provider.clone()),
145 ..Default::default()
146 },
147 LanguageInfo {
148 name: "gowork",
149 adapters: vec![go_lsp_adapter.clone()],
150 context: Some(go_context_provider.clone()),
151 ..Default::default()
152 },
153 LanguageInfo {
154 name: "json",
155 adapters: vec![json_lsp_adapter.clone(), node_version_lsp_adapter.clone()],
156 context: Some(json_context_provider.clone()),
157 ..Default::default()
158 },
159 LanguageInfo {
160 name: "jsonc",
161 adapters: vec![json_lsp_adapter.clone()],
162 context: Some(json_context_provider.clone()),
163 ..Default::default()
164 },
165 LanguageInfo {
166 name: "markdown",
167 adapters: vec![],
168 ..Default::default()
169 },
170 LanguageInfo {
171 name: "markdown-inline",
172 adapters: vec![],
173 ..Default::default()
174 },
175 LanguageInfo {
176 name: "python",
177 adapters: vec![python_lsp_adapter.clone(), py_lsp_adapter.clone()],
178 context: Some(python_context_provider),
179 toolchain: Some(python_toolchain_provider),
180 manifest_name: Some(SharedString::new_static("pyproject.toml").into()),
181 },
182 LanguageInfo {
183 name: "rust",
184 adapters: vec![rust_lsp_adapter],
185 context: Some(rust_context_provider),
186 manifest_name: Some(SharedString::new_static("Cargo.toml").into()),
187 ..Default::default()
188 },
189 LanguageInfo {
190 name: "tsx",
191 adapters: vec![typescript_lsp_adapter.clone(), vtsls_adapter.clone()],
192 context: Some(typescript_context.clone()),
193 ..Default::default()
194 },
195 LanguageInfo {
196 name: "typescript",
197 adapters: vec![typescript_lsp_adapter.clone(), vtsls_adapter.clone()],
198 context: Some(typescript_context.clone()),
199 ..Default::default()
200 },
201 LanguageInfo {
202 name: "javascript",
203 adapters: vec![typescript_lsp_adapter.clone(), vtsls_adapter.clone()],
204 context: Some(typescript_context.clone()),
205 ..Default::default()
206 },
207 LanguageInfo {
208 name: "jsdoc",
209 adapters: vec![typescript_lsp_adapter.clone(), vtsls_adapter.clone()],
210 ..Default::default()
211 },
212 LanguageInfo {
213 name: "regex",
214 adapters: vec![],
215 ..Default::default()
216 },
217 LanguageInfo {
218 name: "yaml",
219 adapters: vec![yaml_lsp_adapter],
220 ..Default::default()
221 },
222 LanguageInfo {
223 name: "gitcommit",
224 ..Default::default()
225 },
226 LanguageInfo {
227 name: "zed-keybind-context",
228 ..Default::default()
229 },
230 ];
231
232 for registration in built_in_languages {
233 register_language(
234 &languages,
235 registration.name,
236 registration.adapters,
237 registration.context,
238 registration.toolchain,
239 registration.manifest_name,
240 );
241 }
242
243 let mut basedpyright_lsp_adapter = Some(basedpyright_lsp_adapter);
244 cx.observe_flag::<BasedPyrightFeatureFlag, _>({
245 let languages = languages.clone();
246 move |enabled, _| {
247 if enabled
248 && let Some(adapter) = basedpyright_lsp_adapter.take() {
249 languages
250 .register_available_lsp_adapter(adapter.name(), move || adapter.clone());
251 }
252 }
253 })
254 .detach();
255
256 // Register globally available language servers.
257 //
258 // This will allow users to add support for a built-in language server (e.g., Tailwind)
259 // for a given language via the `language_servers` setting:
260 //
261 // ```json
262 // {
263 // "languages": {
264 // "My Language": {
265 // "language_servers": ["tailwindcss-language-server", "..."]
266 // }
267 // }
268 // }
269 // ```
270 languages.register_available_lsp_adapter(
271 LanguageServerName("tailwindcss-language-server".into()),
272 {
273 let adapter = tailwind_adapter.clone();
274 move || adapter.clone()
275 },
276 );
277 languages.register_available_lsp_adapter(LanguageServerName("eslint".into()), {
278 let adapter = eslint_adapter.clone();
279 move || adapter.clone()
280 });
281 languages.register_available_lsp_adapter(LanguageServerName("vtsls".into()), {
282 let adapter = vtsls_adapter.clone();
283 move || adapter.clone()
284 });
285 languages.register_available_lsp_adapter(
286 LanguageServerName("typescript-language-server".into()),
287 {
288 let adapter = typescript_lsp_adapter.clone();
289 move || adapter.clone()
290 },
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 "PHP",
306 "Svelte",
307 "TSX",
308 "Vue.js",
309 ];
310
311 for language in tailwind_languages {
312 languages.register_lsp_adapter(language.into(), tailwind_adapter.clone());
313 }
314
315 let eslint_languages = ["TSX", "TypeScript", "JavaScript", "Vue.js", "Svelte"];
316 for language in eslint_languages {
317 languages.register_lsp_adapter(language.into(), eslint_adapter.clone());
318 }
319
320 let mut subscription = languages.subscribe();
321 let mut prev_language_settings = languages.language_settings();
322
323 cx.spawn(async move |cx| {
324 while subscription.next().await.is_some() {
325 let language_settings = languages.language_settings();
326 if language_settings != prev_language_settings {
327 cx.update(|cx| {
328 SettingsStore::update_global(cx, |settings, cx| {
329 settings
330 .set_extension_settings(language_settings.clone(), cx)
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}
357
358fn register_language(
359 languages: &LanguageRegistry,
360 name: &'static str,
361 adapters: Vec<Arc<dyn LspAdapter>>,
362 context: Option<Arc<dyn ContextProvider>>,
363 toolchain: Option<Arc<dyn ToolchainLister>>,
364 manifest_name: Option<ManifestName>,
365) {
366 let config = load_config(name);
367 for adapter in adapters {
368 languages.register_lsp_adapter(config.name.clone(), adapter);
369 }
370 languages.register_language(
371 config.name.clone(),
372 config.grammar.clone(),
373 config.matcher.clone(),
374 config.hidden,
375 manifest_name.clone(),
376 Arc::new(move || {
377 Ok(LoadedLanguage {
378 config: config.clone(),
379 queries: load_queries(name),
380 context_provider: context.clone(),
381 toolchain_provider: toolchain.clone(),
382 manifest_name: manifest_name.clone(),
383 })
384 }),
385 );
386}
387
388#[cfg(any(test, feature = "test-support"))]
389pub fn language(name: &str, grammar: tree_sitter::Language) -> Arc<Language> {
390 Arc::new(
391 Language::new(load_config(name), Some(grammar))
392 .with_queries(load_queries(name))
393 .unwrap(),
394 )
395}
396
397fn load_config(name: &str) -> LanguageConfig {
398 let config_toml = String::from_utf8(
399 LanguageDir::get(&format!("{}/config.toml", name))
400 .unwrap_or_else(|| panic!("missing config for language {:?}", name))
401 .data
402 .to_vec(),
403 )
404 .unwrap();
405
406 #[allow(unused_mut)]
407 let mut config: LanguageConfig = ::toml::from_str(&config_toml)
408 .with_context(|| format!("failed to load config.toml for language {name:?}"))
409 .unwrap();
410
411 #[cfg(not(any(feature = "load-grammars", test)))]
412 {
413 config = LanguageConfig {
414 name: config.name,
415 matcher: config.matcher,
416 jsx_tag_auto_close: config.jsx_tag_auto_close,
417 ..Default::default()
418 }
419 }
420
421 config
422}
423
424fn load_queries(name: &str) -> LanguageQueries {
425 let mut result = LanguageQueries::default();
426 for path in LanguageDir::iter() {
427 if let Some(remainder) = path.strip_prefix(name).and_then(|p| p.strip_prefix('/')) {
428 if !remainder.ends_with(".scm") {
429 continue;
430 }
431 for (name, query) in QUERY_FILENAME_PREFIXES {
432 if remainder.starts_with(name) {
433 let contents = asset_str::<LanguageDir>(path.as_ref());
434 match query(&mut result) {
435 None => *query(&mut result) = Some(contents),
436 Some(r) => r.to_mut().push_str(contents.as_ref()),
437 }
438 }
439 }
440 }
441 }
442 result
443}