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