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