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