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