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::{async_maybe, 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 fn name(&self) -> LanguageServerName {
40 LanguageServerName("intelephense".into())
41 }
42
43 async fn fetch_latest_server_version(
44 &self,
45 _delegate: &dyn LspAdapterDelegate,
46 ) -> Result<Box<dyn 'static + Send + Any>> {
47 Ok(Box::new(IntelephenseVersion(
48 self.node.npm_package_latest_version("intelephense").await?,
49 )) as Box<_>)
50 }
51
52 async fn fetch_server_binary(
53 &self,
54 version: Box<dyn 'static + Send + Any>,
55 container_dir: PathBuf,
56 _delegate: &dyn LspAdapterDelegate,
57 ) -> Result<LanguageServerBinary> {
58 let version = version.downcast::<IntelephenseVersion>().unwrap();
59 let server_path = container_dir.join(Self::SERVER_PATH);
60
61 if fs::metadata(&server_path).await.is_err() {
62 self.node
63 .npm_install_packages(&container_dir, &[("intelephense", version.0.as_str())])
64 .await?;
65 }
66 Ok(LanguageServerBinary {
67 path: self.node.binary_path().await?,
68 env: None,
69 arguments: intelephense_server_binary_arguments(&server_path),
70 })
71 }
72
73 async fn cached_server_binary(
74 &self,
75 container_dir: PathBuf,
76 _: &dyn LspAdapterDelegate,
77 ) -> Option<LanguageServerBinary> {
78 get_cached_server_binary(container_dir, &*self.node).await
79 }
80
81 async fn installation_test_binary(
82 &self,
83 container_dir: PathBuf,
84 ) -> Option<LanguageServerBinary> {
85 get_cached_server_binary(container_dir, &*self.node).await
86 }
87
88 async fn label_for_completion(
89 &self,
90 _item: &lsp::CompletionItem,
91 _language: &Arc<language::Language>,
92 ) -> Option<language::CodeLabel> {
93 None
94 }
95
96 fn initialization_options(&self) -> Option<serde_json::Value> {
97 None
98 }
99 fn language_ids(&self) -> HashMap<String, String> {
100 HashMap::from_iter([("PHP".into(), "php".into())])
101 }
102
103 fn prettier_plugins(&self) -> &[&'static str] {
104 &["@prettier/plugin-php"]
105 }
106}
107
108async fn get_cached_server_binary(
109 container_dir: PathBuf,
110 node: &dyn NodeRuntime,
111) -> Option<LanguageServerBinary> {
112 async_maybe!({
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 env: None,
127 arguments: intelephense_server_binary_arguments(&server_path),
128 })
129 } else {
130 Err(anyhow!(
131 "missing executable in directory {:?}",
132 last_version_dir
133 ))
134 }
135 })
136 .await
137 .log_err()
138}