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