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