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