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
26 }
27
28 async fn check_if_user_installed(
29 &self,
30 delegate: &dyn LspAdapterDelegate,
31 _: Option<Toolchain>,
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 = CodeLabel::plain(label, completion.filter_text.as_deref());
257 label.runs.push((
258 0..label.text.rfind('(').unwrap_or(label.text.len()),
259 highlight_id,
260 ));
261 return Some(label);
262 }
263 }
264 _ => {}
265 }
266 Some(CodeLabel::plain(label, completion.filter_text.as_deref()))
267 }
268
269 async fn label_for_symbol(
270 &self,
271 name: &str,
272 kind: lsp::SymbolKind,
273 language: &Arc<Language>,
274 ) -> Option<CodeLabel> {
275 let (text, filter_range, display_range) = match kind {
276 lsp::SymbolKind::METHOD | lsp::SymbolKind::FUNCTION => {
277 let text = format!("void {} () {{}}", name);
278 let filter_range = 0..name.len();
279 let display_range = 5..5 + name.len();
280 (text, filter_range, display_range)
281 }
282 lsp::SymbolKind::STRUCT => {
283 let text = format!("struct {} {{}}", name);
284 let filter_range = 7..7 + name.len();
285 let display_range = 0..filter_range.end;
286 (text, filter_range, display_range)
287 }
288 lsp::SymbolKind::ENUM => {
289 let text = format!("enum {} {{}}", name);
290 let filter_range = 5..5 + name.len();
291 let display_range = 0..filter_range.end;
292 (text, filter_range, display_range)
293 }
294 lsp::SymbolKind::INTERFACE | lsp::SymbolKind::CLASS => {
295 let text = format!("class {} {{}}", name);
296 let filter_range = 6..6 + name.len();
297 let display_range = 0..filter_range.end;
298 (text, filter_range, display_range)
299 }
300 lsp::SymbolKind::CONSTANT => {
301 let text = format!("const int {} = 0;", name);
302 let filter_range = 10..10 + name.len();
303 let display_range = 0..filter_range.end;
304 (text, filter_range, display_range)
305 }
306 lsp::SymbolKind::MODULE => {
307 let text = format!("namespace {} {{}}", name);
308 let filter_range = 10..10 + name.len();
309 let display_range = 0..filter_range.end;
310 (text, filter_range, display_range)
311 }
312 lsp::SymbolKind::TYPE_PARAMETER => {
313 let text = format!("typename {} {{}};", name);
314 let filter_range = 9..9 + name.len();
315 let display_range = 0..filter_range.end;
316 (text, filter_range, display_range)
317 }
318 _ => return None,
319 };
320
321 Some(CodeLabel {
322 runs: language.highlight_text(&text.as_str().into(), display_range.clone()),
323 text: text[display_range].to_string(),
324 filter_range,
325 })
326 }
327
328 fn prepare_initialize_params(
329 &self,
330 mut original: InitializeParams,
331 _: &App,
332 ) -> Result<InitializeParams> {
333 let experimental = json!({
334 "textDocument": {
335 "completion" : {
336 // enable clangd's dot-to-arrow feature.
337 "editsNearCursor": true
338 },
339 "inactiveRegionsCapabilities": {
340 "inactiveRegions": true,
341 }
342 }
343 });
344 if let Some(ref mut original_experimental) = original.capabilities.experimental {
345 merge_json_value_into(experimental, original_experimental);
346 } else {
347 original.capabilities.experimental = Some(experimental);
348 }
349 Ok(original)
350 }
351
352 fn retain_old_diagnostic(&self, previous_diagnostic: &Diagnostic, _: &App) -> bool {
353 clangd_ext::is_inactive_region(previous_diagnostic)
354 }
355
356 fn underline_diagnostic(&self, diagnostic: &lsp::Diagnostic) -> bool {
357 !clangd_ext::is_lsp_inactive_region(diagnostic)
358 }
359}
360
361async fn get_cached_server_binary(container_dir: PathBuf) -> Option<LanguageServerBinary> {
362 maybe!(async {
363 let mut last_clangd_dir = None;
364 let mut entries = fs::read_dir(&container_dir).await?;
365 while let Some(entry) = entries.next().await {
366 let entry = entry?;
367 if entry.file_type().await?.is_dir() {
368 last_clangd_dir = Some(entry.path());
369 }
370 }
371 let clangd_dir = last_clangd_dir.context("no cached binary")?;
372 let clangd_bin = clangd_dir.join("bin/clangd");
373 anyhow::ensure!(
374 clangd_bin.exists(),
375 "missing clangd binary in directory {clangd_dir:?}"
376 );
377 Ok(LanguageServerBinary {
378 path: clangd_bin,
379 env: None,
380 arguments: Vec::new(),
381 })
382 })
383 .await
384 .log_err()
385}
386
387#[cfg(test)]
388mod tests {
389 use gpui::{AppContext as _, BorrowAppContext, TestAppContext};
390 use language::{AutoindentMode, Buffer, language_settings::AllLanguageSettings};
391 use settings::SettingsStore;
392 use std::num::NonZeroU32;
393
394 #[gpui::test]
395 async fn test_c_autoindent(cx: &mut TestAppContext) {
396 // cx.executor().set_block_on_ticks(usize::MAX..=usize::MAX);
397 cx.update(|cx| {
398 let test_settings = SettingsStore::test(cx);
399 cx.set_global(test_settings);
400 language::init(cx);
401 cx.update_global::<SettingsStore, _>(|store, cx| {
402 store.update_user_settings::<AllLanguageSettings>(cx, |s| {
403 s.defaults.tab_size = NonZeroU32::new(2);
404 });
405 });
406 });
407 let language = crate::language("c", tree_sitter_c::LANGUAGE.into());
408
409 cx.new(|cx| {
410 let mut buffer = Buffer::local("", cx).with_language(language, cx);
411
412 // empty function
413 buffer.edit([(0..0, "int main() {}")], None, cx);
414
415 // indent inside braces
416 let ix = buffer.len() - 1;
417 buffer.edit([(ix..ix, "\n\n")], Some(AutoindentMode::EachLine), cx);
418 assert_eq!(buffer.text(), "int main() {\n \n}");
419
420 // indent body of single-statement if statement
421 let ix = buffer.len() - 2;
422 buffer.edit([(ix..ix, "if (a)\nb;")], Some(AutoindentMode::EachLine), cx);
423 assert_eq!(buffer.text(), "int main() {\n if (a)\n b;\n}");
424
425 // indent inside field expression
426 let ix = buffer.len() - 3;
427 buffer.edit([(ix..ix, "\n.c")], Some(AutoindentMode::EachLine), cx);
428 assert_eq!(buffer.text(), "int main() {\n if (a)\n b\n .c;\n}");
429
430 buffer
431 });
432 }
433}