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