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 ruby;
20mod rust;
21mod tailwind;
22mod typescript;
23mod yaml;
24
25#[derive(RustEmbed)]
26#[folder = "src/"]
27#[exclude = "*.rs"]
28struct LanguageDir;
29
30pub fn init(
31 languages: Arc<LanguageRegistry>,
32 node_runtime: Arc<dyn NodeRuntime>,
33 cx: &mut AppContext,
34) {
35 languages.register_native_grammars([
36 ("bash", tree_sitter_bash::language()),
37 ("c", tree_sitter_c::language()),
38 ("cpp", tree_sitter_cpp::language()),
39 ("css", tree_sitter_css::language()),
40 (
41 "embedded_template",
42 tree_sitter_embedded_template::language(),
43 ),
44 ("go", tree_sitter_go::language()),
45 ("gomod", tree_sitter_gomod::language()),
46 ("gowork", tree_sitter_gowork::language()),
47 ("jsdoc", tree_sitter_jsdoc::language()),
48 ("json", tree_sitter_json::language()),
49 ("markdown", tree_sitter_markdown::language()),
50 ("proto", tree_sitter_proto::language()),
51 ("python", tree_sitter_python::language()),
52 ("regex", tree_sitter_regex::language()),
53 ("ruby", tree_sitter_ruby::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![
111 Arc::new(css::CssLspAdapter::new(node_runtime.clone())),
112 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
113 ]
114 );
115 language!("go", vec![Arc::new(go::GoLspAdapter)]);
116 language!("gomod");
117 language!("gowork");
118 language!(
119 "json",
120 vec![Arc::new(json::JsonLspAdapter::new(
121 node_runtime.clone(),
122 languages.clone(),
123 ))]
124 );
125 language!("markdown");
126 language!(
127 "python",
128 vec![Arc::new(python::PythonLspAdapter::new(
129 node_runtime.clone(),
130 ))],
131 python_task_context()
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 );
150 language!(
151 "javascript",
152 vec![Arc::new(typescript::TypeScriptLspAdapter::new(
153 node_runtime.clone()
154 ))]
155 );
156 language!(
157 "jsdoc",
158 vec![Arc::new(typescript::TypeScriptLspAdapter::new(
159 node_runtime.clone(),
160 ))]
161 );
162 language!("ruby", vec![Arc::new(ruby::RubyLanguageServer)]);
163 language!(
164 "erb",
165 vec![
166 Arc::new(ruby::RubyLanguageServer),
167 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
168 ]
169 );
170 language!("regex");
171 language!(
172 "yaml",
173 vec![Arc::new(yaml::YamlLspAdapter::new(node_runtime.clone()))]
174 );
175 language!("proto");
176
177 let tailwind_languages = [
178 "Astro",
179 "HEEX",
180 "HTML",
181 "PHP",
182 "Svelte",
183 "TSX",
184 "JavaScript",
185 "Vue.js",
186 ];
187
188 for language in tailwind_languages {
189 languages.register_secondary_lsp_adapter(
190 language.into(),
191 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
192 );
193 }
194
195 let eslint_languages = ["TSX", "TypeScript", "JavaScript", "Vue.js"];
196 for language in eslint_languages {
197 languages.register_secondary_lsp_adapter(
198 language.into(),
199 Arc::new(typescript::EsLintLspAdapter::new(node_runtime.clone())),
200 );
201 }
202
203 let mut subscription = languages.subscribe();
204 let mut prev_language_settings = languages.language_settings();
205
206 cx.spawn(|cx| async move {
207 while subscription.next().await.is_some() {
208 let language_settings = languages.language_settings();
209 if language_settings != prev_language_settings {
210 cx.update(|cx| {
211 cx.update_global(|settings: &mut SettingsStore, cx| {
212 settings
213 .set_extension_settings(language_settings.clone(), cx)
214 .log_err();
215 });
216 })?;
217 prev_language_settings = language_settings;
218 }
219 }
220 anyhow::Ok(())
221 })
222 .detach();
223}
224
225#[cfg(any(test, feature = "test-support"))]
226pub fn language(name: &str, grammar: tree_sitter::Language) -> Arc<Language> {
227 Arc::new(
228 Language::new(load_config(name), Some(grammar))
229 .with_queries(load_queries(name))
230 .unwrap(),
231 )
232}
233
234fn load_config(name: &str) -> LanguageConfig {
235 let config_toml = String::from_utf8(
236 LanguageDir::get(&format!("{}/config.toml", name))
237 .unwrap()
238 .data
239 .to_vec(),
240 )
241 .unwrap();
242
243 ::toml::from_str(&config_toml)
244 .with_context(|| format!("failed to load config.toml for language {name:?}"))
245 .unwrap()
246}
247
248fn load_queries(name: &str) -> LanguageQueries {
249 let mut result = LanguageQueries::default();
250 for path in LanguageDir::iter() {
251 if let Some(remainder) = path.strip_prefix(name).and_then(|p| p.strip_prefix('/')) {
252 if !remainder.ends_with(".scm") {
253 continue;
254 }
255 for (name, query) in QUERY_FILENAME_PREFIXES {
256 if remainder.starts_with(name) {
257 let contents = asset_str::<LanguageDir>(path.as_ref());
258 match query(&mut result) {
259 None => *query(&mut result) = Some(contents),
260 Some(r) => r.to_mut().push_str(contents.as_ref()),
261 }
262 }
263 }
264 }
265 }
266 result
267}