1use anyhow::{Context as _, Result, bail};
2use async_trait::async_trait;
3use futures::StreamExt;
4use gpui::{App, AsyncApp};
5use http_client::github::{AssetKind, GitHubLspBinaryVersion, latest_github_release};
6pub use language::*;
7use lsp::{InitializeParams, LanguageServerBinary, LanguageServerName};
8use project::lsp_store::clangd_ext;
9use serde_json::json;
10use smol::fs;
11use std::{any::Any, env::consts, path::PathBuf, sync::Arc};
12use util::{ResultExt, fs::remove_matching, maybe, merge_json_value_into};
13
14use crate::github_download::{GithubBinaryMetadata, download_server_binary};
15
16pub struct CLspAdapter;
17
18impl CLspAdapter {
19 const SERVER_NAME: LanguageServerName = LanguageServerName::new_static("clangd");
20}
21
22#[async_trait(?Send)]
23impl super::LspAdapter for CLspAdapter {
24 fn name(&self) -> LanguageServerName {
25 Self::SERVER_NAME.clone()
26 }
27
28 async fn check_if_user_installed(
29 &self,
30 delegate: &dyn LspAdapterDelegate,
31 _: Arc<dyn LanguageToolchainStore>,
32 _: &AsyncApp,
33 ) -> Option<LanguageServerBinary> {
34 let path = delegate.which(Self::SERVER_NAME.as_ref()).await?;
35 Some(LanguageServerBinary {
36 path,
37 arguments: Vec::new(),
38 env: None,
39 })
40 }
41
42 async fn fetch_latest_server_version(
43 &self,
44 delegate: &dyn LspAdapterDelegate,
45 ) -> Result<Box<dyn 'static + Send + Any>> {
46 let release =
47 latest_github_release("clangd/clangd", true, false, delegate.http_client()).await?;
48 let os_suffix = match consts::OS {
49 "macos" => "mac",
50 "linux" => "linux",
51 "windows" => "windows",
52 other => bail!("Running on unsupported os: {other}"),
53 };
54 let asset_name = format!("clangd-{}-{}.zip", os_suffix, release.tag_name);
55 let asset = release
56 .assets
57 .iter()
58 .find(|asset| asset.name == asset_name)
59 .with_context(|| format!("no asset found matching {asset_name:?}"))?;
60 let version = GitHubLspBinaryVersion {
61 name: release.tag_name,
62 url: asset.browser_download_url.clone(),
63 digest: asset.digest.clone(),
64 };
65 Ok(Box::new(version) as Box<_>)
66 }
67
68 async fn fetch_server_binary(
69 &self,
70 version: Box<dyn 'static + Send + Any>,
71 container_dir: PathBuf,
72 delegate: &dyn LspAdapterDelegate,
73 ) -> Result<LanguageServerBinary> {
74 let GitHubLspBinaryVersion {
75 name,
76 url,
77 digest: expected_digest,
78 } = *version.downcast::<GitHubLspBinaryVersion>().unwrap();
79 let version_dir = container_dir.join(format!("clangd_{name}"));
80 let binary_path = version_dir.join("bin/clangd");
81
82 let binary = LanguageServerBinary {
83 path: binary_path.clone(),
84 env: None,
85 arguments: Default::default(),
86 };
87
88 let metadata_path = version_dir.join("metadata");
89 let metadata = GithubBinaryMetadata::read_from_file(&metadata_path)
90 .await
91 .ok();
92 if let Some(metadata) = metadata {
93 let validity_check = async || {
94 delegate
95 .try_exec(LanguageServerBinary {
96 path: binary_path.clone(),
97 arguments: vec!["--version".into()],
98 env: None,
99 })
100 .await
101 .inspect_err(|err| {
102 log::warn!("Unable to run {binary_path:?} asset, redownloading: {err}",)
103 })
104 };
105 if let (Some(actual_digest), Some(expected_digest)) =
106 (&metadata.digest, &expected_digest)
107 {
108 if actual_digest == expected_digest {
109 if validity_check().await.is_ok() {
110 return Ok(binary);
111 }
112 } else {
113 log::info!(
114 "SHA-256 mismatch for {binary_path:?} asset, downloading new asset. Expected: {expected_digest}, Got: {actual_digest}"
115 );
116 }
117 } else if validity_check().await.is_ok() {
118 return Ok(binary);
119 }
120 }
121 download_server_binary(
122 delegate,
123 &url,
124 expected_digest.as_deref(),
125 &container_dir,
126 AssetKind::Zip,
127 )
128 .await?;
129 remove_matching(&container_dir, |entry| entry != version_dir).await;
130 GithubBinaryMetadata::write_to_file(
131 &GithubBinaryMetadata {
132 metadata_version: 1,
133 digest: expected_digest,
134 },
135 &metadata_path,
136 )
137 .await?;
138
139 Ok(binary)
140 }
141
142 async fn cached_server_binary(
143 &self,
144 container_dir: PathBuf,
145 _: &dyn LspAdapterDelegate,
146 ) -> Option<LanguageServerBinary> {
147 get_cached_server_binary(container_dir).await
148 }
149
150 async fn label_for_completion(
151 &self,
152 completion: &lsp::CompletionItem,
153 language: &Arc<Language>,
154 ) -> Option<CodeLabel> {
155 let label_detail = match &completion.label_details {
156 Some(label_detail) => match &label_detail.detail {
157 Some(detail) => detail.trim(),
158 None => "",
159 },
160 None => "",
161 };
162
163 let label = completion
164 .label
165 .strip_prefix('•')
166 .unwrap_or(&completion.label)
167 .trim()
168 .to_owned()
169 + label_detail;
170
171 match completion.kind {
172 Some(lsp::CompletionItemKind::FIELD) if completion.detail.is_some() => {
173 let detail = completion.detail.as_ref().unwrap();
174 let text = format!("{} {}", detail, label);
175 let source = Rope::from(format!("struct S {{ {} }}", text).as_str());
176 let runs = language.highlight_text(&source, 11..11 + text.len());
177 let filter_range = completion
178 .filter_text
179 .as_deref()
180 .and_then(|filter_text| {
181 text.find(filter_text)
182 .map(|start| start..start + filter_text.len())
183 })
184 .unwrap_or(detail.len() + 1..text.len());
185 return Some(CodeLabel {
186 filter_range,
187 text,
188 runs,
189 });
190 }
191 Some(lsp::CompletionItemKind::CONSTANT | lsp::CompletionItemKind::VARIABLE)
192 if completion.detail.is_some() =>
193 {
194 let detail = completion.detail.as_ref().unwrap();
195 let text = format!("{} {}", detail, label);
196 let runs = language.highlight_text(&Rope::from(text.as_str()), 0..text.len());
197 let filter_range = completion
198 .filter_text
199 .as_deref()
200 .and_then(|filter_text| {
201 text.find(filter_text)
202 .map(|start| start..start + filter_text.len())
203 })
204 .unwrap_or(detail.len() + 1..text.len());
205 return Some(CodeLabel {
206 filter_range,
207 text,
208 runs,
209 });
210 }
211 Some(lsp::CompletionItemKind::FUNCTION | lsp::CompletionItemKind::METHOD)
212 if completion.detail.is_some() =>
213 {
214 let detail = completion.detail.as_ref().unwrap();
215 let text = format!("{} {}", detail, label);
216 let runs = language.highlight_text(&Rope::from(text.as_str()), 0..text.len());
217 let filter_range = completion
218 .filter_text
219 .as_deref()
220 .and_then(|filter_text| {
221 text.find(filter_text)
222 .map(|start| start..start + filter_text.len())
223 })
224 .unwrap_or_else(|| {
225 let filter_start = detail.len() + 1;
226 let filter_end = text
227 .rfind('(')
228 .filter(|end| *end > filter_start)
229 .unwrap_or(text.len());
230 filter_start..filter_end
231 });
232
233 return Some(CodeLabel {
234 filter_range,
235 text,
236 runs,
237 });
238 }
239 Some(kind) => {
240 let highlight_name = match kind {
241 lsp::CompletionItemKind::STRUCT
242 | lsp::CompletionItemKind::INTERFACE
243 | lsp::CompletionItemKind::CLASS
244 | lsp::CompletionItemKind::ENUM => Some("type"),
245 lsp::CompletionItemKind::ENUM_MEMBER => Some("variant"),
246 lsp::CompletionItemKind::KEYWORD => Some("keyword"),
247 lsp::CompletionItemKind::VALUE | lsp::CompletionItemKind::CONSTANT => {
248 Some("constant")
249 }
250 _ => None,
251 };
252 if let Some(highlight_id) = language
253 .grammar()
254 .and_then(|g| g.highlight_id_for_name(highlight_name?))
255 {
256 let mut label =
257 CodeLabel::plain(label.to_string(), completion.filter_text.as_deref());
258 label.runs.push((
259 0..label.text.rfind('(').unwrap_or(label.text.len()),
260 highlight_id,
261 ));
262 return Some(label);
263 }
264 }
265 _ => {}
266 }
267 Some(CodeLabel::plain(
268 label.to_string(),
269 completion.filter_text.as_deref(),
270 ))
271 }
272
273 async fn label_for_symbol(
274 &self,
275 name: &str,
276 kind: lsp::SymbolKind,
277 language: &Arc<Language>,
278 ) -> Option<CodeLabel> {
279 let (text, filter_range, display_range) = match kind {
280 lsp::SymbolKind::METHOD | lsp::SymbolKind::FUNCTION => {
281 let text = format!("void {} () {{}}", name);
282 let filter_range = 0..name.len();
283 let display_range = 5..5 + name.len();
284 (text, filter_range, display_range)
285 }
286 lsp::SymbolKind::STRUCT => {
287 let text = format!("struct {} {{}}", name);
288 let filter_range = 7..7 + name.len();
289 let display_range = 0..filter_range.end;
290 (text, filter_range, display_range)
291 }
292 lsp::SymbolKind::ENUM => {
293 let text = format!("enum {} {{}}", name);
294 let filter_range = 5..5 + name.len();
295 let display_range = 0..filter_range.end;
296 (text, filter_range, display_range)
297 }
298 lsp::SymbolKind::INTERFACE | lsp::SymbolKind::CLASS => {
299 let text = format!("class {} {{}}", name);
300 let filter_range = 6..6 + name.len();
301 let display_range = 0..filter_range.end;
302 (text, filter_range, display_range)
303 }
304 lsp::SymbolKind::CONSTANT => {
305 let text = format!("const int {} = 0;", name);
306 let filter_range = 10..10 + name.len();
307 let display_range = 0..filter_range.end;
308 (text, filter_range, display_range)
309 }
310 lsp::SymbolKind::MODULE => {
311 let text = format!("namespace {} {{}}", name);
312 let filter_range = 10..10 + name.len();
313 let display_range = 0..filter_range.end;
314 (text, filter_range, display_range)
315 }
316 lsp::SymbolKind::TYPE_PARAMETER => {
317 let text = format!("typename {} {{}};", name);
318 let filter_range = 9..9 + name.len();
319 let display_range = 0..filter_range.end;
320 (text, filter_range, display_range)
321 }
322 _ => return None,
323 };
324
325 Some(CodeLabel {
326 runs: language.highlight_text(&text.as_str().into(), display_range.clone()),
327 text: text[display_range].to_string(),
328 filter_range,
329 })
330 }
331
332 fn prepare_initialize_params(
333 &self,
334 mut original: InitializeParams,
335 _: &App,
336 ) -> Result<InitializeParams> {
337 let experimental = json!({
338 "textDocument": {
339 "completion" : {
340 // enable clangd's dot-to-arrow feature.
341 "editsNearCursor": true
342 },
343 "inactiveRegionsCapabilities": {
344 "inactiveRegions": true,
345 }
346 }
347 });
348 if let Some(ref mut original_experimental) = original.capabilities.experimental {
349 merge_json_value_into(experimental, original_experimental);
350 } else {
351 original.capabilities.experimental = Some(experimental);
352 }
353 Ok(original)
354 }
355
356 fn retain_old_diagnostic(&self, previous_diagnostic: &Diagnostic, _: &App) -> bool {
357 clangd_ext::is_inactive_region(previous_diagnostic)
358 }
359
360 fn underline_diagnostic(&self, diagnostic: &lsp::Diagnostic) -> bool {
361 !clangd_ext::is_lsp_inactive_region(diagnostic)
362 }
363}
364
365async fn get_cached_server_binary(container_dir: PathBuf) -> Option<LanguageServerBinary> {
366 maybe!(async {
367 let mut last_clangd_dir = None;
368 let mut entries = fs::read_dir(&container_dir).await?;
369 while let Some(entry) = entries.next().await {
370 let entry = entry?;
371 if entry.file_type().await?.is_dir() {
372 last_clangd_dir = Some(entry.path());
373 }
374 }
375 let clangd_dir = last_clangd_dir.context("no cached binary")?;
376 let clangd_bin = clangd_dir.join("bin/clangd");
377 anyhow::ensure!(
378 clangd_bin.exists(),
379 "missing clangd binary in directory {clangd_dir:?}"
380 );
381 Ok(LanguageServerBinary {
382 path: clangd_bin,
383 env: None,
384 arguments: Vec::new(),
385 })
386 })
387 .await
388 .log_err()
389}
390
391#[cfg(test)]
392mod tests {
393 use gpui::{AppContext as _, BorrowAppContext, TestAppContext};
394 use language::{AutoindentMode, Buffer, language_settings::AllLanguageSettings};
395 use settings::SettingsStore;
396 use std::num::NonZeroU32;
397
398 #[gpui::test]
399 async fn test_c_autoindent(cx: &mut TestAppContext) {
400 // cx.executor().set_block_on_ticks(usize::MAX..=usize::MAX);
401 cx.update(|cx| {
402 let test_settings = SettingsStore::test(cx);
403 cx.set_global(test_settings);
404 language::init(cx);
405 cx.update_global::<SettingsStore, _>(|store, cx| {
406 store.update_user_settings::<AllLanguageSettings>(cx, |s| {
407 s.defaults.tab_size = NonZeroU32::new(2);
408 });
409 });
410 });
411 let language = crate::language("c", tree_sitter_c::LANGUAGE.into());
412
413 cx.new(|cx| {
414 let mut buffer = Buffer::local("", cx).with_language(language, cx);
415
416 // empty function
417 buffer.edit([(0..0, "int main() {}")], None, cx);
418
419 // indent inside braces
420 let ix = buffer.len() - 1;
421 buffer.edit([(ix..ix, "\n\n")], Some(AutoindentMode::EachLine), cx);
422 assert_eq!(buffer.text(), "int main() {\n \n}");
423
424 // indent body of single-statement if statement
425 let ix = buffer.len() - 2;
426 buffer.edit([(ix..ix, "if (a)\nb;")], Some(AutoindentMode::EachLine), cx);
427 assert_eq!(buffer.text(), "int main() {\n if (a)\n b;\n}");
428
429 // indent inside field expression
430 let ix = buffer.len() - 3;
431 buffer.edit([(ix..ix, "\n.c")], Some(AutoindentMode::EachLine), cx);
432 assert_eq!(buffer.text(), "int main() {\n if (a)\n b\n .c;\n}");
433
434 buffer
435 });
436 }
437}