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