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