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