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 ("nix", tree_sitter_nix::language()),
73 ("nu", tree_sitter_nu::language()),
74 ("ocaml", tree_sitter_ocaml::language_ocaml()),
75 (
76 "ocaml_interface",
77 tree_sitter_ocaml::language_ocaml_interface(),
78 ),
79 ("proto", tree_sitter_proto::language()),
80 ("python", tree_sitter_python::language()),
81 ("racket", tree_sitter_racket::language()),
82 ("regex", tree_sitter_regex::language()),
83 ("ruby", tree_sitter_ruby::language()),
84 ("rust", tree_sitter_rust::language()),
85 ("scheme", tree_sitter_scheme::language()),
86 ("tsx", tree_sitter_typescript::language_tsx()),
87 ("typescript", tree_sitter_typescript::language_typescript()),
88 ("vue", tree_sitter_vue::language()),
89 ("yaml", tree_sitter_yaml::language()),
90 ]);
91
92 macro_rules! language {
93 ($name:literal) => {
94 let config = load_config($name);
95 languages.register_language(
96 config.name.clone(),
97 config.grammar.clone(),
98 config.matcher.clone(),
99 move || {
100 Ok((
101 config.clone(),
102 load_queries($name),
103 Some(Arc::new(language::SymbolContextProvider)),
104 ))
105 },
106 );
107 };
108 ($name:literal, $adapters:expr) => {
109 let config = load_config($name);
110 // typeck helper
111 let adapters: Vec<Arc<dyn LspAdapter>> = $adapters;
112 for adapter in adapters {
113 languages.register_lsp_adapter(config.name.clone(), adapter);
114 }
115 languages.register_language(
116 config.name.clone(),
117 config.grammar.clone(),
118 config.matcher.clone(),
119 move || {
120 Ok((
121 config.clone(),
122 load_queries($name),
123 Some(Arc::new(language::SymbolContextProvider)),
124 ))
125 },
126 );
127 };
128 ($name:literal, $adapters:expr, $context_provider:expr) => {
129 let config = load_config($name);
130 // typeck helper
131 let adapters: Vec<Arc<dyn LspAdapter>> = $adapters;
132 for adapter in adapters {
133 languages.register_lsp_adapter(config.name.clone(), adapter);
134 }
135 languages.register_language(
136 config.name.clone(),
137 config.grammar.clone(),
138 config.matcher.clone(),
139 move || {
140 Ok((
141 config.clone(),
142 load_queries($name),
143 Some(Arc::new($context_provider)),
144 ))
145 },
146 );
147 };
148 }
149 language!("bash");
150 language!("c", vec![Arc::new(c::CLspAdapter) as Arc<dyn LspAdapter>]);
151 language!("cpp", vec![Arc::new(c::CLspAdapter)]);
152 language!(
153 "css",
154 vec![
155 Arc::new(css::CssLspAdapter::new(node_runtime.clone())),
156 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
157 ]
158 );
159
160 match &ElixirSettings::get(None, cx).lsp {
161 elixir::ElixirLspSetting::ElixirLs => {
162 language!(
163 "elixir",
164 vec![
165 Arc::new(elixir::ElixirLspAdapter),
166 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
167 ],
168 elixir_task_context()
169 );
170 }
171 elixir::ElixirLspSetting::NextLs => {
172 language!(
173 "elixir",
174 vec![Arc::new(elixir::NextLspAdapter)],
175 elixir_task_context()
176 );
177 }
178 elixir::ElixirLspSetting::Local { path, arguments } => {
179 language!(
180 "elixir",
181 vec![Arc::new(elixir::LocalLspAdapter {
182 path: path.clone(),
183 arguments: arguments.clone(),
184 })],
185 elixir_task_context()
186 );
187 }
188 }
189 language!("go", vec![Arc::new(go::GoLspAdapter)]);
190 language!("gomod");
191 language!("gowork");
192 language!(
193 "heex",
194 vec![
195 Arc::new(elixir::ElixirLspAdapter),
196 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
197 ]
198 );
199 language!(
200 "json",
201 vec![Arc::new(json::JsonLspAdapter::new(
202 node_runtime.clone(),
203 languages.clone(),
204 ))]
205 );
206 language!("markdown");
207 language!(
208 "python",
209 vec![Arc::new(python::PythonLspAdapter::new(
210 node_runtime.clone(),
211 ))]
212 );
213 language!(
214 "rust",
215 vec![Arc::new(rust::RustLspAdapter)],
216 RustContextProvider
217 );
218 match &DenoSettings::get(None, cx).enable {
219 true => {
220 language!(
221 "tsx",
222 vec![
223 Arc::new(deno::DenoLspAdapter::new()),
224 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
225 ]
226 );
227 language!("typescript", vec![Arc::new(deno::DenoLspAdapter::new())]);
228 language!(
229 "javascript",
230 vec![
231 Arc::new(deno::DenoLspAdapter::new()),
232 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
233 ]
234 );
235 language!("jsdoc", vec![Arc::new(deno::DenoLspAdapter::new())]);
236 }
237 false => {
238 language!(
239 "tsx",
240 vec![
241 Arc::new(typescript::TypeScriptLspAdapter::new(node_runtime.clone())),
242 Arc::new(typescript::EsLintLspAdapter::new(node_runtime.clone())),
243 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
244 ]
245 );
246 language!(
247 "typescript",
248 vec![
249 Arc::new(typescript::TypeScriptLspAdapter::new(node_runtime.clone())),
250 Arc::new(typescript::EsLintLspAdapter::new(node_runtime.clone())),
251 ]
252 );
253 language!(
254 "javascript",
255 vec![
256 Arc::new(typescript::TypeScriptLspAdapter::new(node_runtime.clone())),
257 Arc::new(typescript::EsLintLspAdapter::new(node_runtime.clone())),
258 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
259 ]
260 );
261 language!(
262 "jsdoc",
263 vec![Arc::new(typescript::TypeScriptLspAdapter::new(
264 node_runtime.clone(),
265 ))]
266 );
267 }
268 }
269
270 language!("ruby", vec![Arc::new(ruby::RubyLanguageServer)]);
271 language!(
272 "erb",
273 vec![
274 Arc::new(ruby::RubyLanguageServer),
275 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
276 ]
277 );
278 language!("scheme");
279 language!("racket");
280 language!("regex");
281 language!(
282 "yaml",
283 vec![Arc::new(yaml::YamlLspAdapter::new(node_runtime.clone()))]
284 );
285 language!("nix");
286 language!("nu", vec![Arc::new(nu::NuLanguageServer {})]);
287 language!("ocaml", vec![Arc::new(ocaml::OCamlLspAdapter)]);
288 language!("ocaml-interface", vec![Arc::new(ocaml::OCamlLspAdapter)]);
289 language!(
290 "vue",
291 vec![
292 Arc::new(vue::VueLspAdapter::new(node_runtime.clone())),
293 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
294 ]
295 );
296 language!("proto");
297 language!("terraform", vec![Arc::new(terraform::TerraformLspAdapter)]);
298 language!(
299 "terraform-vars",
300 vec![Arc::new(terraform::TerraformLspAdapter)]
301 );
302 language!("hcl", vec![]);
303
304 languages.register_secondary_lsp_adapter(
305 "Astro".into(),
306 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
307 );
308 languages.register_secondary_lsp_adapter(
309 "HTML".into(),
310 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
311 );
312 languages.register_secondary_lsp_adapter(
313 "PHP".into(),
314 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
315 );
316 languages.register_secondary_lsp_adapter(
317 "Svelte".into(),
318 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
319 );
320
321 let mut subscription = languages.subscribe();
322 let mut prev_language_settings = languages.language_settings();
323
324 cx.spawn(|cx| async move {
325 while subscription.next().await.is_some() {
326 let language_settings = languages.language_settings();
327 if language_settings != prev_language_settings {
328 cx.update(|cx| {
329 cx.update_global(|settings: &mut SettingsStore, cx| {
330 settings
331 .set_extension_settings(language_settings.clone(), cx)
332 .log_err();
333 });
334 })?;
335 prev_language_settings = language_settings;
336 }
337 }
338 anyhow::Ok(())
339 })
340 .detach();
341}
342
343#[cfg(any(test, feature = "test-support"))]
344pub fn language(name: &str, grammar: tree_sitter::Language) -> Arc<Language> {
345 Arc::new(
346 Language::new(load_config(name), Some(grammar))
347 .with_queries(load_queries(name))
348 .unwrap(),
349 )
350}
351
352fn load_config(name: &str) -> LanguageConfig {
353 let config_toml = String::from_utf8(
354 LanguageDir::get(&format!("{}/config.toml", name))
355 .unwrap()
356 .data
357 .to_vec(),
358 )
359 .unwrap();
360
361 ::toml::from_str(&config_toml)
362 .with_context(|| format!("failed to load config.toml for language {name:?}"))
363 .unwrap()
364}
365
366fn load_queries(name: &str) -> LanguageQueries {
367 let mut result = LanguageQueries::default();
368 for path in LanguageDir::iter() {
369 if let Some(remainder) = path.strip_prefix(name).and_then(|p| p.strip_prefix('/')) {
370 if !remainder.ends_with(".scm") {
371 continue;
372 }
373 for (name, query) in QUERY_FILENAME_PREFIXES {
374 if remainder.starts_with(name) {
375 let contents = asset_str::<LanguageDir>(path.as_ref());
376 match query(&mut result) {
377 None => *query(&mut result) = Some(contents),
378 Some(r) => r.to_mut().push_str(contents.as_ref()),
379 }
380 }
381 }
382 }
383 }
384 result
385}