1use anyhow::Context;
2use gpui::{AppContext, BorrowAppContext};
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 (
40 "embedded_template",
41 tree_sitter_embedded_template::language(),
42 ),
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)]);
111 language!("gomod");
112 language!("gowork");
113 language!(
114 "json",
115 vec![Arc::new(json::JsonLspAdapter::new(
116 node_runtime.clone(),
117 languages.clone(),
118 ))]
119 );
120 language!("markdown");
121 language!(
122 "python",
123 vec![Arc::new(python::PythonLspAdapter::new(
124 node_runtime.clone(),
125 ))],
126 python_task_context()
127 );
128 language!(
129 "rust",
130 vec![Arc::new(rust::RustLspAdapter)],
131 RustContextProvider
132 );
133 language!(
134 "tsx",
135 vec![Arc::new(typescript::TypeScriptLspAdapter::new(
136 node_runtime.clone()
137 ))]
138 );
139 language!(
140 "typescript",
141 vec![Arc::new(typescript::TypeScriptLspAdapter::new(
142 node_runtime.clone()
143 ))]
144 );
145 language!(
146 "javascript",
147 vec![Arc::new(typescript::TypeScriptLspAdapter::new(
148 node_runtime.clone()
149 ))]
150 );
151 language!(
152 "jsdoc",
153 vec![Arc::new(typescript::TypeScriptLspAdapter::new(
154 node_runtime.clone(),
155 ))]
156 );
157 language!("regex");
158 language!(
159 "yaml",
160 vec![Arc::new(yaml::YamlLspAdapter::new(node_runtime.clone()))]
161 );
162 language!("proto");
163
164 // Register globally available language servers.
165 //
166 // This will allow users to add support for a built-in language server (e.g., Tailwind)
167 // for a given language via the `language_servers` setting:
168 //
169 // ```json
170 // {
171 // "languages": {
172 // "My Language": {
173 // "language_servers": ["tailwindcss-language-server", "..."]
174 // }
175 // }
176 // }
177 // ```
178 languages.register_available_lsp_adapter(
179 LanguageServerName("tailwindcss-language-server".into()),
180 {
181 let node_runtime = node_runtime.clone();
182 move || Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone()))
183 },
184 );
185 languages.register_available_lsp_adapter(LanguageServerName("eslint".into()), {
186 let node_runtime = node_runtime.clone();
187 move || Arc::new(typescript::EsLintLspAdapter::new(node_runtime.clone()))
188 });
189
190 // Register Tailwind for the existing languages that should have it by default.
191 //
192 // This can be driven by the `language_servers` setting once we have a way for
193 // extensions to provide their own default value for that setting.
194 let tailwind_languages = [
195 "Astro",
196 "CSS",
197 "ERB",
198 "HEEX",
199 "HTML",
200 "JavaScript",
201 "PHP",
202 "Svelte",
203 "TSX",
204 "Vue.js",
205 ];
206
207 for language in tailwind_languages {
208 languages.register_secondary_lsp_adapter(
209 language.into(),
210 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
211 );
212 }
213
214 let eslint_languages = ["TSX", "TypeScript", "JavaScript", "Vue.js", "Svelte"];
215 for language in eslint_languages {
216 languages.register_secondary_lsp_adapter(
217 language.into(),
218 Arc::new(typescript::EsLintLspAdapter::new(node_runtime.clone())),
219 );
220 }
221
222 let mut subscription = languages.subscribe();
223 let mut prev_language_settings = languages.language_settings();
224
225 cx.spawn(|cx| async move {
226 while subscription.next().await.is_some() {
227 let language_settings = languages.language_settings();
228 if language_settings != prev_language_settings {
229 cx.update(|cx| {
230 cx.update_global(|settings: &mut SettingsStore, cx| {
231 settings
232 .set_extension_settings(language_settings.clone(), cx)
233 .log_err();
234 });
235 })?;
236 prev_language_settings = language_settings;
237 }
238 }
239 anyhow::Ok(())
240 })
241 .detach();
242}
243
244#[cfg(any(test, feature = "test-support"))]
245pub fn language(name: &str, grammar: tree_sitter::Language) -> Arc<Language> {
246 Arc::new(
247 Language::new(load_config(name), Some(grammar))
248 .with_queries(load_queries(name))
249 .unwrap(),
250 )
251}
252
253fn load_config(name: &str) -> LanguageConfig {
254 let config_toml = String::from_utf8(
255 LanguageDir::get(&format!("{}/config.toml", name))
256 .unwrap()
257 .data
258 .to_vec(),
259 )
260 .unwrap();
261
262 ::toml::from_str(&config_toml)
263 .with_context(|| format!("failed to load config.toml for language {name:?}"))
264 .unwrap()
265}
266
267fn load_queries(name: &str) -> LanguageQueries {
268 let mut result = LanguageQueries::default();
269 for path in LanguageDir::iter() {
270 if let Some(remainder) = path.strip_prefix(name).and_then(|p| p.strip_prefix('/')) {
271 if !remainder.ends_with(".scm") {
272 continue;
273 }
274 for (name, query) in QUERY_FILENAME_PREFIXES {
275 if remainder.starts_with(name) {
276 let contents = asset_str::<LanguageDir>(path.as_ref());
277 match query(&mut result) {
278 None => *query(&mut result) = Some(contents),
279 Some(r) => r.to_mut().push_str(contents.as_ref()),
280 }
281 }
282 }
283 }
284 }
285 result
286}