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