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