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