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 c;
15mod clojure;
16mod csharp;
17mod css;
18mod dart;
19mod deno;
20mod elixir;
21mod elm;
22mod erlang;
23mod go;
24mod html;
25mod json;
26mod lua;
27mod nu;
28mod ocaml;
29mod python;
30mod ruby;
31mod rust;
32mod tailwind;
33mod terraform;
34mod typescript;
35mod vue;
36mod yaml;
37
38// 1. Add tree-sitter-{language} parser to zed crate
39// 2. Create a language directory in zed/crates/zed/src/languages and add the language to init function below
40// 3. Add config.toml to the newly created language directory using existing languages as a template
41// 4. Copy highlights from tree sitter repo for the language into a highlights.scm file.
42// Note: github highlights take the last match while zed takes the first
43// 5. Add indents.scm, outline.scm, and brackets.scm to implement indent on newline, outline/breadcrumbs,
44// and autoclosing brackets respectively
45// 6. If the language has injections add an injections.scm query file
46
47#[derive(RustEmbed)]
48#[folder = "src/"]
49#[exclude = "*.rs"]
50struct LanguageDir;
51
52pub fn init(
53 languages: Arc<LanguageRegistry>,
54 node_runtime: Arc<dyn NodeRuntime>,
55 cx: &mut AppContext,
56) {
57 ElixirSettings::register(cx);
58 DenoSettings::register(cx);
59
60 languages.register_native_grammars([
61 ("bash", tree_sitter_bash::language()),
62 ("c", tree_sitter_c::language()),
63 ("c_sharp", tree_sitter_c_sharp::language()),
64 ("clojure", tree_sitter_clojure::language()),
65 ("cpp", tree_sitter_cpp::language()),
66 ("css", tree_sitter_css::language()),
67 ("elixir", tree_sitter_elixir::language()),
68 ("elm", tree_sitter_elm::language()),
69 (
70 "embedded_template",
71 tree_sitter_embedded_template::language(),
72 ),
73 ("erlang", tree_sitter_erlang::language()),
74 ("glsl", tree_sitter_glsl::language()),
75 ("go", tree_sitter_go::language()),
76 ("gomod", tree_sitter_gomod::language()),
77 ("gowork", tree_sitter_gowork::language()),
78 ("hcl", tree_sitter_hcl::language()),
79 ("heex", tree_sitter_heex::language()),
80 ("html", tree_sitter_html::language()),
81 ("jsdoc", tree_sitter_jsdoc::language()),
82 ("json", tree_sitter_json::language()),
83 ("lua", tree_sitter_lua::language()),
84 ("markdown", tree_sitter_markdown::language()),
85 ("nix", tree_sitter_nix::language()),
86 ("nu", tree_sitter_nu::language()),
87 ("ocaml", tree_sitter_ocaml::language_ocaml()),
88 (
89 "ocaml_interface",
90 tree_sitter_ocaml::language_ocaml_interface(),
91 ),
92 ("proto", tree_sitter_proto::language()),
93 ("python", tree_sitter_python::language()),
94 ("racket", tree_sitter_racket::language()),
95 ("regex", tree_sitter_regex::language()),
96 ("ruby", tree_sitter_ruby::language()),
97 ("rust", tree_sitter_rust::language()),
98 ("scheme", tree_sitter_scheme::language()),
99 ("tsx", tree_sitter_typescript::language_tsx()),
100 ("typescript", tree_sitter_typescript::language_typescript()),
101 ("vue", tree_sitter_vue::language()),
102 ("yaml", tree_sitter_yaml::language()),
103 ("dart", tree_sitter_dart::language()),
104 ]);
105
106 macro_rules! language {
107 ($name:literal) => {
108 let config = load_config($name);
109 languages.register_language(
110 config.name.clone(),
111 config.grammar.clone(),
112 config.matcher.clone(),
113 move || {
114 Ok((
115 config.clone(),
116 load_queries($name),
117 Some(Arc::new(language::SymbolContextProvider)),
118 ))
119 },
120 );
121 };
122 ($name:literal, $adapters:expr) => {
123 let config = load_config($name);
124 // typeck helper
125 let adapters: Vec<Arc<dyn LspAdapter>> = $adapters;
126 for adapter in adapters {
127 languages.register_lsp_adapter(config.name.clone(), adapter);
128 }
129 languages.register_language(
130 config.name.clone(),
131 config.grammar.clone(),
132 config.matcher.clone(),
133 move || {
134 Ok((
135 config.clone(),
136 load_queries($name),
137 Some(Arc::new(language::SymbolContextProvider)),
138 ))
139 },
140 );
141 };
142 ($name:literal, $adapters:expr, $context_provider:expr) => {
143 let config = load_config($name);
144 // typeck helper
145 let adapters: Vec<Arc<dyn LspAdapter>> = $adapters;
146 for adapter in adapters {
147 languages.register_lsp_adapter(config.name.clone(), adapter);
148 }
149 languages.register_language(
150 config.name.clone(),
151 config.grammar.clone(),
152 config.matcher.clone(),
153 move || {
154 Ok((
155 config.clone(),
156 load_queries($name),
157 Some(Arc::new($context_provider)),
158 ))
159 },
160 );
161 };
162 }
163 language!("bash");
164 language!("c", vec![Arc::new(c::CLspAdapter) as Arc<dyn LspAdapter>]);
165 language!("clojure", vec![Arc::new(clojure::ClojureLspAdapter)]);
166 language!("cpp", vec![Arc::new(c::CLspAdapter)]);
167 language!("csharp", vec![Arc::new(csharp::OmniSharpAdapter {})]);
168 language!(
169 "css",
170 vec![
171 Arc::new(css::CssLspAdapter::new(node_runtime.clone())),
172 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
173 ]
174 );
175
176 match &ElixirSettings::get(None, cx).lsp {
177 elixir::ElixirLspSetting::ElixirLs => {
178 language!(
179 "elixir",
180 vec![
181 Arc::new(elixir::ElixirLspAdapter),
182 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
183 ],
184 elixir_task_context()
185 );
186 }
187 elixir::ElixirLspSetting::NextLs => {
188 language!(
189 "elixir",
190 vec![Arc::new(elixir::NextLspAdapter)],
191 elixir_task_context()
192 );
193 }
194 elixir::ElixirLspSetting::Local { path, arguments } => {
195 language!(
196 "elixir",
197 vec![Arc::new(elixir::LocalLspAdapter {
198 path: path.clone(),
199 arguments: arguments.clone(),
200 })],
201 elixir_task_context()
202 );
203 }
204 }
205 language!("erlang", vec![Arc::new(erlang::ErlangLspAdapter)]);
206 language!("go", vec![Arc::new(go::GoLspAdapter)]);
207 language!("gomod");
208 language!("gowork");
209 language!(
210 "heex",
211 vec![
212 Arc::new(elixir::ElixirLspAdapter),
213 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
214 ]
215 );
216 language!(
217 "json",
218 vec![Arc::new(json::JsonLspAdapter::new(
219 node_runtime.clone(),
220 languages.clone(),
221 ))]
222 );
223 language!("markdown");
224 language!(
225 "python",
226 vec![Arc::new(python::PythonLspAdapter::new(
227 node_runtime.clone(),
228 ))]
229 );
230 language!(
231 "rust",
232 vec![Arc::new(rust::RustLspAdapter)],
233 RustContextProvider
234 );
235 match &DenoSettings::get(None, cx).enable {
236 true => {
237 language!(
238 "tsx",
239 vec![
240 Arc::new(deno::DenoLspAdapter::new()),
241 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
242 ]
243 );
244 language!("typescript", vec![Arc::new(deno::DenoLspAdapter::new())]);
245 language!(
246 "javascript",
247 vec![
248 Arc::new(deno::DenoLspAdapter::new()),
249 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
250 ]
251 );
252 language!("jsdoc", vec![Arc::new(deno::DenoLspAdapter::new())]);
253 }
254 false => {
255 language!(
256 "tsx",
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 "typescript",
265 vec![
266 Arc::new(typescript::TypeScriptLspAdapter::new(node_runtime.clone())),
267 Arc::new(typescript::EsLintLspAdapter::new(node_runtime.clone())),
268 ]
269 );
270 language!(
271 "javascript",
272 vec![
273 Arc::new(typescript::TypeScriptLspAdapter::new(node_runtime.clone())),
274 Arc::new(typescript::EsLintLspAdapter::new(node_runtime.clone())),
275 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
276 ]
277 );
278 language!(
279 "jsdoc",
280 vec![Arc::new(typescript::TypeScriptLspAdapter::new(
281 node_runtime.clone(),
282 ))]
283 );
284 }
285 }
286
287 language!(
288 "html",
289 vec![
290 Arc::new(html::HtmlLspAdapter::new(node_runtime.clone())),
291 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
292 ]
293 );
294 language!("ruby", vec![Arc::new(ruby::RubyLanguageServer)]);
295 language!(
296 "erb",
297 vec![
298 Arc::new(ruby::RubyLanguageServer),
299 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
300 ]
301 );
302 language!("scheme");
303 language!("racket");
304 language!("regex");
305 language!("lua", vec![Arc::new(lua::LuaLspAdapter)]);
306 language!(
307 "yaml",
308 vec![Arc::new(yaml::YamlLspAdapter::new(node_runtime.clone()))]
309 );
310 language!(
311 "elm",
312 vec![Arc::new(elm::ElmLspAdapter::new(node_runtime.clone()))]
313 );
314 language!("glsl");
315 language!("nix");
316 language!("nu", vec![Arc::new(nu::NuLanguageServer {})]);
317 language!("ocaml", vec![Arc::new(ocaml::OCamlLspAdapter)]);
318 language!("ocaml-interface", vec![Arc::new(ocaml::OCamlLspAdapter)]);
319 language!(
320 "vue",
321 vec![Arc::new(vue::VueLspAdapter::new(node_runtime.clone()))]
322 );
323 language!("proto");
324 language!("terraform", vec![Arc::new(terraform::TerraformLspAdapter)]);
325 language!(
326 "terraform-vars",
327 vec![Arc::new(terraform::TerraformLspAdapter)]
328 );
329 language!("hcl", vec![]);
330 language!("dart", vec![Arc::new(dart::DartLanguageServer {})]);
331
332 languages.register_secondary_lsp_adapter(
333 "Astro".into(),
334 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
335 );
336 languages.register_secondary_lsp_adapter(
337 "PHP".into(),
338 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
339 );
340 languages.register_secondary_lsp_adapter(
341 "Svelte".into(),
342 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
343 );
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}