1use anyhow::Context;
2use gpui::{AppContext, UpdateGlobal};
3use json::json_task_context;
4pub use language::*;
5use node_runtime::NodeRuntime;
6use python::PythonContextProvider;
7use rust_embed::RustEmbed;
8use settings::SettingsStore;
9use smol::stream::StreamExt;
10use std::{str, sync::Arc};
11use typescript::typescript_task_context;
12use util::{asset_str, ResultExt};
13
14use crate::{bash::bash_task_context, go::GoContextProvider, rust::RustContextProvider};
15
16mod bash;
17mod c;
18mod css;
19mod go;
20mod json;
21mod python;
22mod rust;
23mod tailwind;
24mod typescript;
25mod vtsls;
26mod yaml;
27
28#[derive(RustEmbed)]
29#[folder = "src/"]
30#[exclude = "*.rs"]
31struct LanguageDir;
32
33pub fn init(languages: Arc<LanguageRegistry>, node_runtime: NodeRuntime, cx: &mut AppContext) {
34 #[cfg(feature = "load-grammars")]
35 languages.register_native_grammars([
36 ("bash", tree_sitter_bash::LANGUAGE),
37 ("c", tree_sitter_c::LANGUAGE),
38 ("cpp", tree_sitter_cpp::LANGUAGE),
39 ("css", tree_sitter_css::LANGUAGE),
40 ("go", tree_sitter_go::LANGUAGE),
41 ("gomod", tree_sitter_go_mod::LANGUAGE),
42 ("gowork", tree_sitter_gowork::LANGUAGE),
43 ("jsdoc", tree_sitter_jsdoc::LANGUAGE),
44 ("json", tree_sitter_json::LANGUAGE),
45 ("jsonc", tree_sitter_json::LANGUAGE),
46 ("markdown", tree_sitter_md::LANGUAGE),
47 ("markdown-inline", tree_sitter_md::INLINE_LANGUAGE),
48 ("proto", protols_tree_sitter_proto::LANGUAGE),
49 ("python", tree_sitter_python::LANGUAGE),
50 ("regex", tree_sitter_regex::LANGUAGE),
51 ("rust", tree_sitter_rust::LANGUAGE),
52 ("tsx", tree_sitter_typescript::LANGUAGE_TSX),
53 ("typescript", tree_sitter_typescript::LANGUAGE_TYPESCRIPT),
54 ("yaml", tree_sitter_yaml::LANGUAGE),
55 ]);
56
57 macro_rules! language {
58 ($name:literal) => {
59 let config = load_config($name);
60 languages.register_language(
61 config.name.clone(),
62 config.grammar.clone(),
63 config.matcher.clone(),
64 move || Ok((config.clone(), load_queries($name), None)),
65 );
66 };
67 ($name:literal, $adapters:expr) => {
68 let config = load_config($name);
69 // typeck helper
70 let adapters: Vec<Arc<dyn LspAdapter>> = $adapters;
71 for adapter in adapters {
72 languages.register_lsp_adapter(config.name.clone(), adapter);
73 }
74 languages.register_language(
75 config.name.clone(),
76 config.grammar.clone(),
77 config.matcher.clone(),
78 move || Ok((config.clone(), load_queries($name), None)),
79 );
80 };
81 ($name:literal, $adapters:expr, $context_provider:expr) => {
82 let config = load_config($name);
83 // typeck helper
84 let adapters: Vec<Arc<dyn LspAdapter>> = $adapters;
85 for adapter in adapters {
86 languages.register_lsp_adapter(config.name.clone(), adapter);
87 }
88 languages.register_language(
89 config.name.clone(),
90 config.grammar.clone(),
91 config.matcher.clone(),
92 move || {
93 Ok((
94 config.clone(),
95 load_queries($name),
96 Some(Arc::new($context_provider)),
97 ))
98 },
99 );
100 };
101 }
102 language!("bash", Vec::new(), bash_task_context());
103 language!("c", vec![Arc::new(c::CLspAdapter) as Arc<dyn LspAdapter>]);
104 language!("cpp", vec![Arc::new(c::CLspAdapter)]);
105 language!(
106 "css",
107 vec![Arc::new(css::CssLspAdapter::new(node_runtime.clone())),]
108 );
109 language!("go", vec![Arc::new(go::GoLspAdapter)], GoContextProvider);
110 language!("gomod", vec![Arc::new(go::GoLspAdapter)], GoContextProvider);
111 language!(
112 "gowork",
113 vec![Arc::new(go::GoLspAdapter)],
114 GoContextProvider
115 );
116
117 language!(
118 "json",
119 vec![
120 Arc::new(json::JsonLspAdapter::new(
121 node_runtime.clone(),
122 languages.clone(),
123 )),
124 Arc::new(json::NodeVersionAdapter)
125 ],
126 json_task_context()
127 );
128 language!(
129 "jsonc",
130 vec![Arc::new(json::JsonLspAdapter::new(
131 node_runtime.clone(),
132 languages.clone(),
133 ))],
134 json_task_context()
135 );
136 language!("markdown");
137 language!("markdown-inline");
138 language!(
139 "python",
140 vec![Arc::new(python::PythonLspAdapter::new(
141 node_runtime.clone(),
142 ))],
143 PythonContextProvider
144 );
145 language!(
146 "rust",
147 vec![Arc::new(rust::RustLspAdapter)],
148 RustContextProvider
149 );
150 language!(
151 "tsx",
152 vec![
153 Arc::new(typescript::TypeScriptLspAdapter::new(node_runtime.clone())),
154 Arc::new(vtsls::VtslsLspAdapter::new(node_runtime.clone()))
155 ],
156 typescript_task_context()
157 );
158 language!(
159 "typescript",
160 vec![
161 Arc::new(typescript::TypeScriptLspAdapter::new(node_runtime.clone())),
162 Arc::new(vtsls::VtslsLspAdapter::new(node_runtime.clone()))
163 ],
164 typescript_task_context()
165 );
166 language!(
167 "javascript",
168 vec![
169 Arc::new(typescript::TypeScriptLspAdapter::new(node_runtime.clone())),
170 Arc::new(vtsls::VtslsLspAdapter::new(node_runtime.clone()))
171 ],
172 typescript_task_context()
173 );
174 language!(
175 "jsdoc",
176 vec![
177 Arc::new(typescript::TypeScriptLspAdapter::new(node_runtime.clone(),)),
178 Arc::new(vtsls::VtslsLspAdapter::new(node_runtime.clone()))
179 ]
180 );
181 language!("regex");
182 language!(
183 "yaml",
184 vec![Arc::new(yaml::YamlLspAdapter::new(node_runtime.clone()))]
185 );
186 language!("proto");
187
188 // Register globally available language servers.
189 //
190 // This will allow users to add support for a built-in language server (e.g., Tailwind)
191 // for a given language via the `language_servers` setting:
192 //
193 // ```json
194 // {
195 // "languages": {
196 // "My Language": {
197 // "language_servers": ["tailwindcss-language-server", "..."]
198 // }
199 // }
200 // }
201 // ```
202 languages.register_available_lsp_adapter(
203 LanguageServerName("tailwindcss-language-server".into()),
204 {
205 let node_runtime = node_runtime.clone();
206 move || Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone()))
207 },
208 );
209 languages.register_available_lsp_adapter(LanguageServerName("eslint".into()), {
210 let node_runtime = node_runtime.clone();
211 move || Arc::new(typescript::EsLintLspAdapter::new(node_runtime.clone()))
212 });
213
214 // Register Tailwind for the existing languages that should have it by default.
215 //
216 // This can be driven by the `language_servers` setting once we have a way for
217 // extensions to provide their own default value for that setting.
218 let tailwind_languages = [
219 "Astro",
220 "CSS",
221 "ERB",
222 "HEEX",
223 "HTML",
224 "JavaScript",
225 "PHP",
226 "Svelte",
227 "TSX",
228 "Vue.js",
229 ];
230
231 for language in tailwind_languages {
232 languages.register_lsp_adapter(
233 language.into(),
234 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
235 );
236 }
237
238 let eslint_languages = ["TSX", "TypeScript", "JavaScript", "Vue.js", "Svelte"];
239 for language in eslint_languages {
240 languages.register_lsp_adapter(
241 language.into(),
242 Arc::new(typescript::EsLintLspAdapter::new(node_runtime.clone())),
243 );
244 }
245
246 let mut subscription = languages.subscribe();
247 let mut prev_language_settings = languages.language_settings();
248
249 cx.spawn(|cx| async move {
250 while subscription.next().await.is_some() {
251 let language_settings = languages.language_settings();
252 if language_settings != prev_language_settings {
253 cx.update(|cx| {
254 SettingsStore::update_global(cx, |settings, cx| {
255 settings
256 .set_extension_settings(language_settings.clone(), cx)
257 .log_err();
258 });
259 })?;
260 prev_language_settings = language_settings;
261 }
262 }
263 anyhow::Ok(())
264 })
265 .detach();
266}
267
268#[cfg(any(test, feature = "test-support"))]
269pub fn language(name: &str, grammar: tree_sitter::Language) -> Arc<Language> {
270 Arc::new(
271 Language::new(load_config(name), Some(grammar))
272 .with_queries(load_queries(name))
273 .unwrap(),
274 )
275}
276
277fn load_config(name: &str) -> LanguageConfig {
278 let config_toml = String::from_utf8(
279 LanguageDir::get(&format!("{}/config.toml", name))
280 .unwrap()
281 .data
282 .to_vec(),
283 )
284 .unwrap();
285
286 #[allow(unused_mut)]
287 let mut config: LanguageConfig = ::toml::from_str(&config_toml)
288 .with_context(|| format!("failed to load config.toml for language {name:?}"))
289 .unwrap();
290
291 #[cfg(not(feature = "load-grammars"))]
292 {
293 config = LanguageConfig {
294 name: config.name,
295 matcher: config.matcher,
296 ..Default::default()
297 }
298 }
299
300 config
301}
302
303fn load_queries(name: &str) -> LanguageQueries {
304 let mut result = LanguageQueries::default();
305 for path in LanguageDir::iter() {
306 if let Some(remainder) = path.strip_prefix(name).and_then(|p| p.strip_prefix('/')) {
307 if !remainder.ends_with(".scm") {
308 continue;
309 }
310 for (name, query) in QUERY_FILENAME_PREFIXES {
311 if remainder.starts_with(name) {
312 let contents = asset_str::<LanguageDir>(path.as_ref());
313 match query(&mut result) {
314 None => *query(&mut result) = Some(contents),
315 Some(r) => r.to_mut().push_str(contents.as_ref()),
316 }
317 }
318 }
319 }
320 }
321 result
322}