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(?Send)]
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 latest_version: Box<dyn 'static + Send + Any>,
55 container_dir: PathBuf,
56 _delegate: &dyn LspAdapterDelegate,
57 ) -> Result<LanguageServerBinary> {
58 let latest_version = latest_version.downcast::<IntelephenseVersion>().unwrap();
59 let server_path = container_dir.join(Self::SERVER_PATH);
60 let package_name = "intelephense";
61
62 let should_install_language_server = self
63 .node
64 .should_install_npm_package(
65 package_name,
66 &server_path,
67 &container_dir,
68 latest_version.0.as_str(),
69 )
70 .await;
71
72 if should_install_language_server {
73 self.node
74 .npm_install_packages(&container_dir, &[(package_name, latest_version.0.as_str())])
75 .await?;
76 }
77
78 Ok(LanguageServerBinary {
79 path: self.node.binary_path().await?,
80 env: None,
81 arguments: intelephense_server_binary_arguments(&server_path),
82 })
83 }
84
85 async fn cached_server_binary(
86 &self,
87 container_dir: PathBuf,
88 _: &dyn LspAdapterDelegate,
89 ) -> Option<LanguageServerBinary> {
90 get_cached_server_binary(container_dir, &*self.node).await
91 }
92
93 async fn installation_test_binary(
94 &self,
95 container_dir: PathBuf,
96 ) -> Option<LanguageServerBinary> {
97 get_cached_server_binary(container_dir, &*self.node).await
98 }
99
100 async fn label_for_completion(
101 &self,
102 _item: &lsp::CompletionItem,
103 _language: &Arc<language::Language>,
104 ) -> Option<language::CodeLabel> {
105 None
106 }
107
108 fn initialization_options(&self) -> Option<serde_json::Value> {
109 None
110 }
111 fn language_ids(&self) -> HashMap<String, String> {
112 HashMap::from_iter([("PHP".into(), "php".into())])
113 }
114
115 fn prettier_plugins(&self) -> &[&'static str] {
116 &["@prettier/plugin-php"]
117 }
118}
119
120async fn get_cached_server_binary(
121 container_dir: PathBuf,
122 node: &dyn NodeRuntime,
123) -> Option<LanguageServerBinary> {
124 async_maybe!({
125 let mut last_version_dir = None;
126 let mut entries = fs::read_dir(&container_dir).await?;
127 while let Some(entry) = entries.next().await {
128 let entry = entry?;
129 if entry.file_type().await?.is_dir() {
130 last_version_dir = Some(entry.path());
131 }
132 }
133 let last_version_dir = last_version_dir.ok_or_else(|| anyhow!("no cached binary"))?;
134 let server_path = last_version_dir.join(IntelephenseLspAdapter::SERVER_PATH);
135 if server_path.exists() {
136 Ok(LanguageServerBinary {
137 path: node.binary_path().await?,
138 env: None,
139 arguments: intelephense_server_binary_arguments(&server_path),
140 })
141 } else {
142 Err(anyhow!(
143 "missing executable in directory {:?}",
144 last_version_dir
145 ))
146 }
147 })
148 .await
149 .log_err()
150}