1use anyhow::Context as _;
2use gpui::{App, SharedString, UpdateGlobal};
3use node_runtime::NodeRuntime;
4use project::Fs;
5use python::PyprojectTomlManifestProvider;
6use rust::CargoManifestProvider;
7use rust_embed::RustEmbed;
8use settings::SettingsStore;
9use smol::stream::StreamExt;
10use std::{str, sync::Arc};
11use util::{ResultExt, asset_str};
12
13pub use language::*;
14
15use crate::{json::JsonTaskProvider, python::BasedPyrightLspAdapter};
16
17mod bash;
18mod c;
19mod css;
20mod github_download;
21mod go;
22mod json;
23mod package_json;
24mod python;
25mod rust;
26mod tailwind;
27mod typescript;
28mod vtsls;
29mod yaml;
30
31pub(crate) use package_json::{PackageJson, PackageJsonData};
32
33#[derive(RustEmbed)]
34#[folder = "src/"]
35#[exclude = "*.rs"]
36struct LanguageDir;
37
38/// A shared grammar for plain text, exposed for reuse by downstream crates.
39#[cfg(feature = "tree-sitter-gitcommit")]
40pub static LANGUAGE_GIT_COMMIT: std::sync::LazyLock<Arc<Language>> =
41 std::sync::LazyLock::new(|| {
42 Arc::new(Language::new(
43 LanguageConfig {
44 name: "Git Commit".into(),
45 soft_wrap: Some(language::language_settings::SoftWrap::EditorWidth),
46 matcher: LanguageMatcher {
47 path_suffixes: vec!["COMMIT_EDITMSG".to_owned()],
48 first_line_pattern: None,
49 },
50 line_comments: vec![Arc::from("#")],
51 ..LanguageConfig::default()
52 },
53 Some(tree_sitter_gitcommit::LANGUAGE.into()),
54 ))
55 });
56
57pub fn init(languages: Arc<LanguageRegistry>, fs: Arc<dyn Fs>, node: NodeRuntime, cx: &mut App) {
58 #[cfg(feature = "load-grammars")]
59 languages.register_native_grammars([
60 ("bash", tree_sitter_bash::LANGUAGE),
61 ("c", tree_sitter_c::LANGUAGE),
62 ("cpp", tree_sitter_cpp::LANGUAGE),
63 ("css", tree_sitter_css::LANGUAGE),
64 ("diff", tree_sitter_diff::LANGUAGE),
65 ("go", tree_sitter_go::LANGUAGE),
66 ("gomod", tree_sitter_go_mod::LANGUAGE),
67 ("gowork", tree_sitter_gowork::LANGUAGE),
68 ("jsdoc", tree_sitter_jsdoc::LANGUAGE),
69 ("json", tree_sitter_json::LANGUAGE),
70 ("jsonc", tree_sitter_json::LANGUAGE),
71 ("markdown", tree_sitter_md::LANGUAGE),
72 ("markdown-inline", tree_sitter_md::INLINE_LANGUAGE),
73 ("python", tree_sitter_python::LANGUAGE),
74 ("regex", tree_sitter_regex::LANGUAGE),
75 ("rust", tree_sitter_rust::LANGUAGE),
76 ("tsx", tree_sitter_typescript::LANGUAGE_TSX),
77 ("typescript", tree_sitter_typescript::LANGUAGE_TYPESCRIPT),
78 ("yaml", tree_sitter_yaml::LANGUAGE),
79 ("gitcommit", tree_sitter_gitcommit::LANGUAGE),
80 ]);
81
82 let c_lsp_adapter = Arc::new(c::CLspAdapter);
83 let css_lsp_adapter = Arc::new(css::CssLspAdapter::new(node.clone()));
84 let eslint_adapter = Arc::new(typescript::EsLintLspAdapter::new(node.clone()));
85 let go_context_provider = Arc::new(go::GoContextProvider);
86 let go_lsp_adapter = Arc::new(go::GoLspAdapter);
87 let json_context_provider = Arc::new(JsonTaskProvider);
88 let json_lsp_adapter = Arc::new(json::JsonLspAdapter::new(node.clone(), languages.clone()));
89 let node_version_lsp_adapter = Arc::new(json::NodeVersionAdapter);
90 let py_lsp_adapter = Arc::new(python::PyLspAdapter::new());
91 let python_context_provider = Arc::new(python::PythonContextProvider);
92 let python_lsp_adapter = Arc::new(python::PythonLspAdapter::new(node.clone()));
93 let basedpyright_lsp_adapter = Arc::new(BasedPyrightLspAdapter::new());
94 let python_toolchain_provider = Arc::new(python::PythonToolchainProvider);
95 let rust_context_provider = Arc::new(rust::RustContextProvider);
96 let rust_lsp_adapter = Arc::new(rust::RustLspAdapter);
97 let tailwind_adapter = Arc::new(tailwind::TailwindLspAdapter::new(node.clone()));
98 let typescript_context = Arc::new(typescript::TypeScriptContextProvider::new(fs.clone()));
99 let typescript_lsp_adapter = Arc::new(typescript::TypeScriptLspAdapter::new(
100 node.clone(),
101 fs.clone(),
102 ));
103 let vtsls_adapter = Arc::new(vtsls::VtslsLspAdapter::new(node.clone(), fs.clone()));
104 let yaml_lsp_adapter = Arc::new(yaml::YamlLspAdapter::new(node));
105
106 let built_in_languages = [
107 LanguageInfo {
108 name: "bash",
109 context: Some(Arc::new(bash::bash_task_context())),
110 ..Default::default()
111 },
112 LanguageInfo {
113 name: "c",
114 adapters: vec![c_lsp_adapter.clone()],
115 ..Default::default()
116 },
117 LanguageInfo {
118 name: "cpp",
119 adapters: vec![c_lsp_adapter],
120 ..Default::default()
121 },
122 LanguageInfo {
123 name: "css",
124 adapters: vec![css_lsp_adapter],
125 ..Default::default()
126 },
127 LanguageInfo {
128 name: "diff",
129 adapters: vec![],
130 ..Default::default()
131 },
132 LanguageInfo {
133 name: "go",
134 adapters: vec![go_lsp_adapter.clone()],
135 context: Some(go_context_provider.clone()),
136 ..Default::default()
137 },
138 LanguageInfo {
139 name: "gomod",
140 adapters: vec![go_lsp_adapter.clone()],
141 context: Some(go_context_provider.clone()),
142 ..Default::default()
143 },
144 LanguageInfo {
145 name: "gowork",
146 adapters: vec![go_lsp_adapter],
147 context: Some(go_context_provider),
148 ..Default::default()
149 },
150 LanguageInfo {
151 name: "json",
152 adapters: vec![json_lsp_adapter.clone(), node_version_lsp_adapter],
153 context: Some(json_context_provider.clone()),
154 ..Default::default()
155 },
156 LanguageInfo {
157 name: "jsonc",
158 adapters: vec![json_lsp_adapter],
159 context: Some(json_context_provider),
160 ..Default::default()
161 },
162 LanguageInfo {
163 name: "markdown",
164 adapters: vec![],
165 ..Default::default()
166 },
167 LanguageInfo {
168 name: "markdown-inline",
169 adapters: vec![],
170 ..Default::default()
171 },
172 LanguageInfo {
173 name: "python",
174 adapters: vec![basedpyright_lsp_adapter],
175 context: Some(python_context_provider),
176 toolchain: Some(python_toolchain_provider),
177 manifest_name: Some(SharedString::new_static("pyproject.toml").into()),
178 },
179 LanguageInfo {
180 name: "rust",
181 adapters: vec![rust_lsp_adapter],
182 context: Some(rust_context_provider),
183 manifest_name: Some(SharedString::new_static("Cargo.toml").into()),
184 ..Default::default()
185 },
186 LanguageInfo {
187 name: "tsx",
188 adapters: vec![typescript_lsp_adapter.clone(), vtsls_adapter.clone()],
189 context: Some(typescript_context.clone()),
190 ..Default::default()
191 },
192 LanguageInfo {
193 name: "typescript",
194 adapters: vec![typescript_lsp_adapter.clone(), vtsls_adapter.clone()],
195 context: Some(typescript_context.clone()),
196 ..Default::default()
197 },
198 LanguageInfo {
199 name: "javascript",
200 adapters: vec![typescript_lsp_adapter.clone(), vtsls_adapter.clone()],
201 context: Some(typescript_context),
202 ..Default::default()
203 },
204 LanguageInfo {
205 name: "jsdoc",
206 adapters: vec![typescript_lsp_adapter.clone(), vtsls_adapter.clone()],
207 ..Default::default()
208 },
209 LanguageInfo {
210 name: "regex",
211 adapters: vec![],
212 ..Default::default()
213 },
214 LanguageInfo {
215 name: "yaml",
216 adapters: vec![yaml_lsp_adapter],
217 ..Default::default()
218 },
219 LanguageInfo {
220 name: "gitcommit",
221 ..Default::default()
222 },
223 LanguageInfo {
224 name: "zed-keybind-context",
225 ..Default::default()
226 },
227 ];
228
229 for registration in built_in_languages {
230 register_language(
231 &languages,
232 registration.name,
233 registration.adapters,
234 registration.context,
235 registration.toolchain,
236 registration.manifest_name,
237 );
238 }
239
240 // Register globally available language servers.
241 //
242 // This will allow users to add support for a built-in language server (e.g., Tailwind)
243 // for a given language via the `language_servers` setting:
244 //
245 // ```json
246 // {
247 // "languages": {
248 // "My Language": {
249 // "language_servers": ["tailwindcss-language-server", "..."]
250 // }
251 // }
252 // }
253 // ```
254 languages.register_available_lsp_adapter(
255 LanguageServerName("tailwindcss-language-server".into()),
256 tailwind_adapter.clone(),
257 );
258 languages.register_available_lsp_adapter(
259 LanguageServerName("eslint".into()),
260 eslint_adapter.clone(),
261 );
262 languages.register_available_lsp_adapter(LanguageServerName("vtsls".into()), vtsls_adapter);
263 languages.register_available_lsp_adapter(
264 LanguageServerName("typescript-language-server".into()),
265 typescript_lsp_adapter,
266 );
267 languages.register_available_lsp_adapter(python_lsp_adapter.name(), python_lsp_adapter);
268 languages.register_available_lsp_adapter(py_lsp_adapter.name(), py_lsp_adapter);
269 // Register Tailwind for the existing languages that should have it by default.
270 //
271 // This can be driven by the `language_servers` setting once we have a way for
272 // extensions to provide their own default value for that setting.
273 let tailwind_languages = [
274 "Astro",
275 "CSS",
276 "ERB",
277 "HTML+ERB",
278 "HTML/ERB",
279 "HEEX",
280 "HTML",
281 "JavaScript",
282 "PHP",
283 "Svelte",
284 "TSX",
285 "Vue.js",
286 ];
287
288 for language in tailwind_languages {
289 languages.register_lsp_adapter(language.into(), tailwind_adapter.clone());
290 }
291
292 let eslint_languages = ["TSX", "TypeScript", "JavaScript", "Vue.js", "Svelte"];
293 for language in eslint_languages {
294 languages.register_lsp_adapter(language.into(), eslint_adapter.clone());
295 }
296
297 let mut subscription = languages.subscribe();
298 let mut prev_language_settings = languages.language_settings();
299
300 cx.spawn(async move |cx| {
301 while subscription.next().await.is_some() {
302 let language_settings = languages.language_settings();
303 if language_settings != prev_language_settings {
304 cx.update(|cx| {
305 SettingsStore::update_global(cx, |settings, cx| {
306 settings
307 .set_extension_settings(language_settings.clone(), cx)
308 .log_err();
309 });
310 })?;
311 prev_language_settings = language_settings;
312 }
313 }
314 anyhow::Ok(())
315 })
316 .detach();
317 let manifest_providers: [Arc<dyn ManifestProvider>; 2] = [
318 Arc::from(CargoManifestProvider),
319 Arc::from(PyprojectTomlManifestProvider),
320 ];
321 for provider in manifest_providers {
322 project::ManifestProvidersStore::global(cx).register(provider);
323 }
324}
325
326#[derive(Default)]
327struct LanguageInfo {
328 name: &'static str,
329 adapters: Vec<Arc<dyn LspAdapter>>,
330 context: Option<Arc<dyn ContextProvider>>,
331 toolchain: Option<Arc<dyn ToolchainLister>>,
332 manifest_name: Option<ManifestName>,
333}
334
335fn register_language(
336 languages: &LanguageRegistry,
337 name: &'static str,
338 adapters: Vec<Arc<dyn LspAdapter>>,
339 context: Option<Arc<dyn ContextProvider>>,
340 toolchain: Option<Arc<dyn ToolchainLister>>,
341 manifest_name: Option<ManifestName>,
342) {
343 let config = load_config(name);
344 for adapter in adapters {
345 languages.register_lsp_adapter(config.name.clone(), adapter);
346 }
347 languages.register_language(
348 config.name.clone(),
349 config.grammar.clone(),
350 config.matcher.clone(),
351 config.hidden,
352 manifest_name.clone(),
353 Arc::new(move || {
354 Ok(LoadedLanguage {
355 config: config.clone(),
356 queries: load_queries(name),
357 context_provider: context.clone(),
358 toolchain_provider: toolchain.clone(),
359 manifest_name: manifest_name.clone(),
360 })
361 }),
362 );
363}
364
365#[cfg(any(test, feature = "test-support"))]
366pub fn language(name: &str, grammar: tree_sitter::Language) -> Arc<Language> {
367 Arc::new(
368 Language::new(load_config(name), Some(grammar))
369 .with_queries(load_queries(name))
370 .unwrap(),
371 )
372}
373
374fn load_config(name: &str) -> LanguageConfig {
375 let config_toml = String::from_utf8(
376 LanguageDir::get(&format!("{}/config.toml", name))
377 .unwrap_or_else(|| panic!("missing config for language {:?}", name))
378 .data
379 .to_vec(),
380 )
381 .unwrap();
382
383 #[allow(unused_mut)]
384 let mut config: LanguageConfig = ::toml::from_str(&config_toml)
385 .with_context(|| format!("failed to load config.toml for language {name:?}"))
386 .unwrap();
387
388 #[cfg(not(any(feature = "load-grammars", test)))]
389 {
390 config = LanguageConfig {
391 name: config.name,
392 matcher: config.matcher,
393 jsx_tag_auto_close: config.jsx_tag_auto_close,
394 ..Default::default()
395 }
396 }
397
398 config
399}
400
401fn load_queries(name: &str) -> LanguageQueries {
402 let mut result = LanguageQueries::default();
403 for path in LanguageDir::iter() {
404 if let Some(remainder) = path.strip_prefix(name).and_then(|p| p.strip_prefix('/')) {
405 if !remainder.ends_with(".scm") {
406 continue;
407 }
408 for (name, query) in QUERY_FILENAME_PREFIXES {
409 if remainder.starts_with(name) {
410 let contents = asset_str::<LanguageDir>(path.as_ref());
411 match query(&mut result) {
412 None => *query(&mut result) = Some(contents),
413 Some(r) => r.to_mut().push_str(contents.as_ref()),
414 }
415 }
416 }
417 }
418 }
419 result
420}