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