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