1use anyhow::Context;
2use gpui::{AppContext, BorrowAppContext};
3pub use language::*;
4use node_runtime::NodeRuntime;
5use rust_embed::RustEmbed;
6use settings::{Settings, SettingsStore};
7use smol::stream::StreamExt;
8use std::{str, sync::Arc};
9use util::{asset_str, ResultExt};
10
11use crate::{elixir::elixir_task_context, rust::RustContextProvider};
12
13use self::{deno::DenoSettings, elixir::ElixirSettings};
14
15mod c;
16mod css;
17mod deno;
18mod elixir;
19mod go;
20mod json;
21mod nu;
22mod python;
23mod ruby;
24mod rust;
25mod tailwind;
26mod typescript;
27mod vue;
28mod yaml;
29
30// 1. Add tree-sitter-{language} parser to zed crate
31// 2. Create a language directory in zed/crates/zed/src/languages and add the language to init function below
32// 3. Add config.toml to the newly created language directory using existing languages as a template
33// 4. Copy highlights from tree sitter repo for the language into a highlights.scm file.
34// Note: github highlights take the last match while zed takes the first
35// 5. Add indents.scm, outline.scm, and brackets.scm to implement indent on newline, outline/breadcrumbs,
36// and autoclosing brackets respectively
37// 6. If the language has injections add an injections.scm query file
38
39#[derive(RustEmbed)]
40#[folder = "src/"]
41#[exclude = "*.rs"]
42struct LanguageDir;
43
44pub fn init(
45 languages: Arc<LanguageRegistry>,
46 node_runtime: Arc<dyn NodeRuntime>,
47 cx: &mut AppContext,
48) {
49 ElixirSettings::register(cx);
50 DenoSettings::register(cx);
51
52 languages.register_native_grammars([
53 ("bash", tree_sitter_bash::language()),
54 ("c", tree_sitter_c::language()),
55 ("cpp", tree_sitter_cpp::language()),
56 ("css", tree_sitter_css::language()),
57 ("elixir", tree_sitter_elixir::language()),
58 (
59 "embedded_template",
60 tree_sitter_embedded_template::language(),
61 ),
62 ("go", tree_sitter_go::language()),
63 ("gomod", tree_sitter_gomod::language()),
64 ("gowork", tree_sitter_gowork::language()),
65 ("heex", tree_sitter_heex::language()),
66 ("jsdoc", tree_sitter_jsdoc::language()),
67 ("json", tree_sitter_json::language()),
68 ("markdown", tree_sitter_markdown::language()),
69 ("nu", tree_sitter_nu::language()),
70 ("proto", tree_sitter_proto::language()),
71 ("python", tree_sitter_python::language()),
72 ("regex", tree_sitter_regex::language()),
73 ("ruby", tree_sitter_ruby::language()),
74 ("rust", tree_sitter_rust::language()),
75 ("tsx", tree_sitter_typescript::language_tsx()),
76 ("typescript", tree_sitter_typescript::language_typescript()),
77 ("vue", tree_sitter_vue::language()),
78 ("yaml", tree_sitter_yaml::language()),
79 ]);
80
81 macro_rules! language {
82 ($name:literal) => {
83 let config = load_config($name);
84 languages.register_language(
85 config.name.clone(),
86 config.grammar.clone(),
87 config.matcher.clone(),
88 move || {
89 Ok((
90 config.clone(),
91 load_queries($name),
92 Some(Arc::new(language::SymbolContextProvider)),
93 ))
94 },
95 );
96 };
97 ($name:literal, $adapters:expr) => {
98 let config = load_config($name);
99 // typeck helper
100 let adapters: Vec<Arc<dyn LspAdapter>> = $adapters;
101 for adapter in adapters {
102 languages.register_lsp_adapter(config.name.clone(), adapter);
103 }
104 languages.register_language(
105 config.name.clone(),
106 config.grammar.clone(),
107 config.matcher.clone(),
108 move || {
109 Ok((
110 config.clone(),
111 load_queries($name),
112 Some(Arc::new(language::SymbolContextProvider)),
113 ))
114 },
115 );
116 };
117 ($name:literal, $adapters:expr, $context_provider:expr) => {
118 let config = load_config($name);
119 // typeck helper
120 let adapters: Vec<Arc<dyn LspAdapter>> = $adapters;
121 for adapter in adapters {
122 languages.register_lsp_adapter(config.name.clone(), adapter);
123 }
124 languages.register_language(
125 config.name.clone(),
126 config.grammar.clone(),
127 config.matcher.clone(),
128 move || {
129 Ok((
130 config.clone(),
131 load_queries($name),
132 Some(Arc::new($context_provider)),
133 ))
134 },
135 );
136 };
137 }
138 language!("bash");
139 language!("c", vec![Arc::new(c::CLspAdapter) as Arc<dyn LspAdapter>]);
140 language!("cpp", vec![Arc::new(c::CLspAdapter)]);
141 language!(
142 "css",
143 vec![
144 Arc::new(css::CssLspAdapter::new(node_runtime.clone())),
145 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
146 ]
147 );
148
149 match &ElixirSettings::get(None, cx).lsp {
150 elixir::ElixirLspSetting::ElixirLs => {
151 language!(
152 "elixir",
153 vec![
154 Arc::new(elixir::ElixirLspAdapter),
155 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
156 ],
157 elixir_task_context()
158 );
159 }
160 elixir::ElixirLspSetting::NextLs => {
161 language!(
162 "elixir",
163 vec![Arc::new(elixir::NextLspAdapter)],
164 elixir_task_context()
165 );
166 }
167 elixir::ElixirLspSetting::Local { path, arguments } => {
168 language!(
169 "elixir",
170 vec![Arc::new(elixir::LocalLspAdapter {
171 path: path.clone(),
172 arguments: arguments.clone(),
173 })],
174 elixir_task_context()
175 );
176 }
177 }
178 language!("go", vec![Arc::new(go::GoLspAdapter)]);
179 language!("gomod");
180 language!("gowork");
181 language!(
182 "heex",
183 vec![
184 Arc::new(elixir::ElixirLspAdapter),
185 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
186 ]
187 );
188 language!(
189 "json",
190 vec![Arc::new(json::JsonLspAdapter::new(
191 node_runtime.clone(),
192 languages.clone(),
193 ))]
194 );
195 language!("markdown");
196 language!(
197 "python",
198 vec![Arc::new(python::PythonLspAdapter::new(
199 node_runtime.clone(),
200 ))]
201 );
202 language!(
203 "rust",
204 vec![Arc::new(rust::RustLspAdapter)],
205 RustContextProvider
206 );
207 match &DenoSettings::get(None, cx).enable {
208 true => {
209 language!(
210 "tsx",
211 vec![
212 Arc::new(deno::DenoLspAdapter::new()),
213 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
214 ]
215 );
216 language!("typescript", vec![Arc::new(deno::DenoLspAdapter::new())]);
217 language!(
218 "javascript",
219 vec![
220 Arc::new(deno::DenoLspAdapter::new()),
221 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
222 ]
223 );
224 language!("jsdoc", vec![Arc::new(deno::DenoLspAdapter::new())]);
225 }
226 false => {
227 language!(
228 "tsx",
229 vec![
230 Arc::new(typescript::TypeScriptLspAdapter::new(node_runtime.clone())),
231 Arc::new(typescript::EsLintLspAdapter::new(node_runtime.clone())),
232 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
233 ]
234 );
235 language!(
236 "typescript",
237 vec![
238 Arc::new(typescript::TypeScriptLspAdapter::new(node_runtime.clone())),
239 Arc::new(typescript::EsLintLspAdapter::new(node_runtime.clone())),
240 ]
241 );
242 language!(
243 "javascript",
244 vec![
245 Arc::new(typescript::TypeScriptLspAdapter::new(node_runtime.clone())),
246 Arc::new(typescript::EsLintLspAdapter::new(node_runtime.clone())),
247 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
248 ]
249 );
250 language!(
251 "jsdoc",
252 vec![Arc::new(typescript::TypeScriptLspAdapter::new(
253 node_runtime.clone(),
254 ))]
255 );
256 }
257 }
258
259 language!("ruby", vec![Arc::new(ruby::RubyLanguageServer)]);
260 language!(
261 "erb",
262 vec![
263 Arc::new(ruby::RubyLanguageServer),
264 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
265 ]
266 );
267 language!("regex");
268 language!(
269 "yaml",
270 vec![Arc::new(yaml::YamlLspAdapter::new(node_runtime.clone()))]
271 );
272 language!("nu", vec![Arc::new(nu::NuLanguageServer {})]);
273 language!(
274 "vue",
275 vec![
276 Arc::new(vue::VueLspAdapter::new(node_runtime.clone())),
277 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
278 ]
279 );
280 language!("proto");
281
282 languages.register_secondary_lsp_adapter(
283 "Astro".into(),
284 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
285 );
286 languages.register_secondary_lsp_adapter(
287 "HTML".into(),
288 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
289 );
290 languages.register_secondary_lsp_adapter(
291 "PHP".into(),
292 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
293 );
294 languages.register_secondary_lsp_adapter(
295 "Svelte".into(),
296 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
297 );
298
299 let mut subscription = languages.subscribe();
300 let mut prev_language_settings = languages.language_settings();
301
302 cx.spawn(|cx| async move {
303 while subscription.next().await.is_some() {
304 let language_settings = languages.language_settings();
305 if language_settings != prev_language_settings {
306 cx.update(|cx| {
307 cx.update_global(|settings: &mut SettingsStore, cx| {
308 settings
309 .set_extension_settings(language_settings.clone(), cx)
310 .log_err();
311 });
312 })?;
313 prev_language_settings = language_settings;
314 }
315 }
316 anyhow::Ok(())
317 })
318 .detach();
319}
320
321#[cfg(any(test, feature = "test-support"))]
322pub fn language(name: &str, grammar: tree_sitter::Language) -> Arc<Language> {
323 Arc::new(
324 Language::new(load_config(name), Some(grammar))
325 .with_queries(load_queries(name))
326 .unwrap(),
327 )
328}
329
330fn load_config(name: &str) -> LanguageConfig {
331 let config_toml = String::from_utf8(
332 LanguageDir::get(&format!("{}/config.toml", name))
333 .unwrap()
334 .data
335 .to_vec(),
336 )
337 .unwrap();
338
339 ::toml::from_str(&config_toml)
340 .with_context(|| format!("failed to load config.toml for language {name:?}"))
341 .unwrap()
342}
343
344fn load_queries(name: &str) -> LanguageQueries {
345 let mut result = LanguageQueries::default();
346 for path in LanguageDir::iter() {
347 if let Some(remainder) = path.strip_prefix(name).and_then(|p| p.strip_prefix('/')) {
348 if !remainder.ends_with(".scm") {
349 continue;
350 }
351 for (name, query) in QUERY_FILENAME_PREFIXES {
352 if remainder.starts_with(name) {
353 let contents = asset_str::<LanguageDir>(path.as_ref());
354 match query(&mut result) {
355 None => *query(&mut result) = Some(contents),
356 Some(r) => r.to_mut().push_str(contents.as_ref()),
357 }
358 }
359 }
360 }
361 }
362 result
363}