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::{
12 bash::bash_task_context, elixir::elixir_task_context, python::python_task_context,
13 rust::RustContextProvider,
14};
15
16use self::elixir::ElixirSettings;
17
18mod bash;
19mod c;
20mod css;
21mod elixir;
22mod go;
23mod json;
24mod python;
25mod ruby;
26mod rust;
27mod tailwind;
28mod typescript;
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
52 languages.register_native_grammars([
53 ("bash", tree_sitter_bash::language()),
54 ("c", tree_sitter_c::language()),
55 ("cpp", tree_sitter_cpp::language()),
56 ("css", tree_sitter_css::language()),
57 ("elixir", tree_sitter_elixir::language()),
58 (
59 "embedded_template",
60 tree_sitter_embedded_template::language(),
61 ),
62 ("go", tree_sitter_go::language()),
63 ("gomod", tree_sitter_gomod::language()),
64 ("gowork", tree_sitter_gowork::language()),
65 ("heex", tree_sitter_heex::language()),
66 ("jsdoc", tree_sitter_jsdoc::language()),
67 ("json", tree_sitter_json::language()),
68 ("markdown", tree_sitter_markdown::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 || Ok((config.clone(), load_queries($name), None)),
87 );
88 };
89 ($name:literal, $adapters:expr) => {
90 let config = load_config($name);
91 // typeck helper
92 let adapters: Vec<Arc<dyn LspAdapter>> = $adapters;
93 for adapter in adapters {
94 languages.register_lsp_adapter(config.name.clone(), adapter);
95 }
96 languages.register_language(
97 config.name.clone(),
98 config.grammar.clone(),
99 config.matcher.clone(),
100 move || Ok((config.clone(), load_queries($name), None)),
101 );
102 };
103 ($name:literal, $adapters:expr, $context_provider:expr) => {
104 let config = load_config($name);
105 // typeck helper
106 let adapters: Vec<Arc<dyn LspAdapter>> = $adapters;
107 for adapter in adapters {
108 languages.register_lsp_adapter(config.name.clone(), adapter);
109 }
110 languages.register_language(
111 config.name.clone(),
112 config.grammar.clone(),
113 config.matcher.clone(),
114 move || {
115 Ok((
116 config.clone(),
117 load_queries($name),
118 Some(Arc::new($context_provider)),
119 ))
120 },
121 );
122 };
123 }
124 language!("bash", Vec::new(), bash_task_context());
125 language!("c", vec![Arc::new(c::CLspAdapter) as Arc<dyn LspAdapter>]);
126 language!("cpp", vec![Arc::new(c::CLspAdapter)]);
127 language!(
128 "css",
129 vec![
130 Arc::new(css::CssLspAdapter::new(node_runtime.clone())),
131 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
132 ]
133 );
134
135 match &ElixirSettings::get(None, cx).lsp {
136 elixir::ElixirLspSetting::ElixirLs => {
137 language!(
138 "elixir",
139 vec![
140 Arc::new(elixir::ElixirLspAdapter),
141 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
142 ],
143 elixir_task_context()
144 );
145 }
146 elixir::ElixirLspSetting::NextLs => {
147 language!(
148 "elixir",
149 vec![Arc::new(elixir::NextLspAdapter)],
150 elixir_task_context()
151 );
152 }
153 elixir::ElixirLspSetting::Local { path, arguments } => {
154 language!(
155 "elixir",
156 vec![Arc::new(elixir::LocalLspAdapter {
157 path: path.clone(),
158 arguments: arguments.clone(),
159 })],
160 elixir_task_context()
161 );
162 }
163 }
164 language!("go", vec![Arc::new(go::GoLspAdapter)]);
165 language!("gomod");
166 language!("gowork");
167 language!(
168 "heex",
169 vec![
170 Arc::new(elixir::ElixirLspAdapter),
171 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
172 ]
173 );
174 language!(
175 "json",
176 vec![Arc::new(json::JsonLspAdapter::new(
177 node_runtime.clone(),
178 languages.clone(),
179 ))]
180 );
181 language!("markdown");
182 language!(
183 "python",
184 vec![Arc::new(python::PythonLspAdapter::new(
185 node_runtime.clone(),
186 ))],
187 python_task_context()
188 );
189 language!(
190 "rust",
191 vec![Arc::new(rust::RustLspAdapter)],
192 RustContextProvider
193 );
194 language!(
195 "tsx",
196 vec![
197 Arc::new(typescript::TypeScriptLspAdapter::new(node_runtime.clone())),
198 Arc::new(typescript::EsLintLspAdapter::new(node_runtime.clone())),
199 ]
200 );
201 language!(
202 "typescript",
203 vec![
204 Arc::new(typescript::TypeScriptLspAdapter::new(node_runtime.clone())),
205 Arc::new(typescript::EsLintLspAdapter::new(node_runtime.clone())),
206 ]
207 );
208 language!(
209 "javascript",
210 vec![
211 Arc::new(typescript::TypeScriptLspAdapter::new(node_runtime.clone())),
212 Arc::new(typescript::EsLintLspAdapter::new(node_runtime.clone())),
213 ]
214 );
215 language!(
216 "jsdoc",
217 vec![Arc::new(typescript::TypeScriptLspAdapter::new(
218 node_runtime.clone(),
219 ))]
220 );
221 language!("ruby", vec![Arc::new(ruby::RubyLanguageServer)]);
222 language!(
223 "erb",
224 vec![
225 Arc::new(ruby::RubyLanguageServer),
226 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
227 ]
228 );
229 language!("regex");
230 language!(
231 "yaml",
232 vec![Arc::new(yaml::YamlLspAdapter::new(node_runtime.clone()))]
233 );
234 language!("proto");
235
236 let tailwind_languages = [
237 "Astro",
238 "HTML",
239 "PHP",
240 "Svelte",
241 "TSX",
242 "JavaScript",
243 "Vue.js",
244 ];
245
246 for language in tailwind_languages {
247 languages.register_secondary_lsp_adapter(
248 language.into(),
249 Arc::new(tailwind::TailwindLspAdapter::new(node_runtime.clone())),
250 );
251 }
252
253 let mut subscription = languages.subscribe();
254 let mut prev_language_settings = languages.language_settings();
255
256 cx.spawn(|cx| async move {
257 while subscription.next().await.is_some() {
258 let language_settings = languages.language_settings();
259 if language_settings != prev_language_settings {
260 cx.update(|cx| {
261 cx.update_global(|settings: &mut SettingsStore, cx| {
262 settings
263 .set_extension_settings(language_settings.clone(), cx)
264 .log_err();
265 });
266 })?;
267 prev_language_settings = language_settings;
268 }
269 }
270 anyhow::Ok(())
271 })
272 .detach();
273}
274
275#[cfg(any(test, feature = "test-support"))]
276pub fn language(name: &str, grammar: tree_sitter::Language) -> Arc<Language> {
277 Arc::new(
278 Language::new(load_config(name), Some(grammar))
279 .with_queries(load_queries(name))
280 .unwrap(),
281 )
282}
283
284fn load_config(name: &str) -> LanguageConfig {
285 let config_toml = String::from_utf8(
286 LanguageDir::get(&format!("{}/config.toml", name))
287 .unwrap()
288 .data
289 .to_vec(),
290 )
291 .unwrap();
292
293 ::toml::from_str(&config_toml)
294 .with_context(|| format!("failed to load config.toml for language {name:?}"))
295 .unwrap()
296}
297
298fn load_queries(name: &str) -> LanguageQueries {
299 let mut result = LanguageQueries::default();
300 for path in LanguageDir::iter() {
301 if let Some(remainder) = path.strip_prefix(name).and_then(|p| p.strip_prefix('/')) {
302 if !remainder.ends_with(".scm") {
303 continue;
304 }
305 for (name, query) in QUERY_FILENAME_PREFIXES {
306 if remainder.starts_with(name) {
307 let contents = asset_str::<LanguageDir>(path.as_ref());
308 match query(&mut result) {
309 None => *query(&mut result) = Some(contents),
310 Some(r) => r.to_mut().push_str(contents.as_ref()),
311 }
312 }
313 }
314 }
315 }
316 result
317}