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