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