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