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