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