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