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