1use anyhow::{anyhow, Result};
2
3use async_trait::async_trait;
4use collections::HashMap;
5
6use language2::{LanguageServerName, LspAdapter, LspAdapterDelegate};
7use lsp2::LanguageServerBinary;
8use node_runtime::NodeRuntime;
9
10use smol::{fs, stream::StreamExt};
11use std::{
12 any::Any,
13 ffi::OsString,
14 path::{Path, PathBuf},
15 sync::Arc,
16};
17use util::ResultExt;
18
19fn intelephense_server_binary_arguments(server_path: &Path) -> Vec<OsString> {
20 vec![server_path.into(), "--stdio".into()]
21}
22
23pub struct IntelephenseVersion(String);
24
25pub struct IntelephenseLspAdapter {
26 node: Arc<dyn NodeRuntime>,
27}
28
29impl IntelephenseLspAdapter {
30 const SERVER_PATH: &'static str = "node_modules/intelephense/lib/intelephense.js";
31
32 #[allow(unused)]
33 pub fn new(node: Arc<dyn NodeRuntime>) -> Self {
34 Self { node }
35 }
36}
37
38#[async_trait]
39impl LspAdapter for IntelephenseLspAdapter {
40 async fn name(&self) -> LanguageServerName {
41 LanguageServerName("intelephense".into())
42 }
43
44 fn short_name(&self) -> &'static str {
45 "php"
46 }
47
48 async fn fetch_latest_server_version(
49 &self,
50 _delegate: &dyn LspAdapterDelegate,
51 ) -> Result<Box<dyn 'static + Send + Any>> {
52 Ok(Box::new(IntelephenseVersion(
53 self.node.npm_package_latest_version("intelephense").await?,
54 )) as Box<_>)
55 }
56
57 async fn fetch_server_binary(
58 &self,
59 version: Box<dyn 'static + Send + Any>,
60 container_dir: PathBuf,
61 _delegate: &dyn LspAdapterDelegate,
62 ) -> Result<LanguageServerBinary> {
63 let version = version.downcast::<IntelephenseVersion>().unwrap();
64 let server_path = container_dir.join(Self::SERVER_PATH);
65
66 if fs::metadata(&server_path).await.is_err() {
67 self.node
68 .npm_install_packages(&container_dir, &[("intelephense", version.0.as_str())])
69 .await?;
70 }
71 Ok(LanguageServerBinary {
72 path: self.node.binary_path().await?,
73 arguments: intelephense_server_binary_arguments(&server_path),
74 })
75 }
76
77 async fn cached_server_binary(
78 &self,
79 container_dir: PathBuf,
80 _: &dyn LspAdapterDelegate,
81 ) -> Option<LanguageServerBinary> {
82 get_cached_server_binary(container_dir, &*self.node).await
83 }
84
85 async fn installation_test_binary(
86 &self,
87 container_dir: PathBuf,
88 ) -> Option<LanguageServerBinary> {
89 get_cached_server_binary(container_dir, &*self.node).await
90 }
91
92 async fn label_for_completion(
93 &self,
94 _item: &lsp2::CompletionItem,
95 _language: &Arc<language2::Language>,
96 ) -> Option<language2::CodeLabel> {
97 None
98 }
99
100 async fn initialization_options(&self) -> Option<serde_json::Value> {
101 None
102 }
103 async fn language_ids(&self) -> HashMap<String, String> {
104 HashMap::from_iter([("PHP".into(), "php".into())])
105 }
106}
107
108async fn get_cached_server_binary(
109 container_dir: PathBuf,
110 node: &dyn NodeRuntime,
111) -> Option<LanguageServerBinary> {
112 (|| async move {
113 let mut last_version_dir = None;
114 let mut entries = fs::read_dir(&container_dir).await?;
115 while let Some(entry) = entries.next().await {
116 let entry = entry?;
117 if entry.file_type().await?.is_dir() {
118 last_version_dir = Some(entry.path());
119 }
120 }
121 let last_version_dir = last_version_dir.ok_or_else(|| anyhow!("no cached binary"))?;
122 let server_path = last_version_dir.join(IntelephenseLspAdapter::SERVER_PATH);
123 if server_path.exists() {
124 Ok(LanguageServerBinary {
125 path: node.binary_path().await?,
126 arguments: intelephense_server_binary_arguments(&server_path),
127 })
128 } else {
129 Err(anyhow!(
130 "missing executable in directory {:?}",
131 last_version_dir
132 ))
133 }
134 })()
135 .await
136 .log_err()
137}