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