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 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 env: None,
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: &lsp::CompletionItem,
95 _language: &Arc<language::Language>,
96 ) -> Option<language::CodeLabel> {
97 None
98 }
99
100 fn initialization_options(&self) -> Option<serde_json::Value> {
101 None
102 }
103 fn language_ids(&self) -> HashMap<String, String> {
104 HashMap::from_iter([("PHP".into(), "php".into())])
105 }
106
107 fn prettier_plugins(&self) -> &[&'static str] {
108 &["@prettier/plugin-php"]
109 }
110}
111
112async fn get_cached_server_binary(
113 container_dir: PathBuf,
114 node: &dyn NodeRuntime,
115) -> Option<LanguageServerBinary> {
116 async_maybe!({
117 let mut last_version_dir = None;
118 let mut entries = fs::read_dir(&container_dir).await?;
119 while let Some(entry) = entries.next().await {
120 let entry = entry?;
121 if entry.file_type().await?.is_dir() {
122 last_version_dir = Some(entry.path());
123 }
124 }
125 let last_version_dir = last_version_dir.ok_or_else(|| anyhow!("no cached binary"))?;
126 let server_path = last_version_dir.join(IntelephenseLspAdapter::SERVER_PATH);
127 if server_path.exists() {
128 Ok(LanguageServerBinary {
129 path: node.binary_path().await?,
130 env: None,
131 arguments: intelephense_server_binary_arguments(&server_path),
132 })
133 } else {
134 Err(anyhow!(
135 "missing executable in directory {:?}",
136 last_version_dir
137 ))
138 }
139 })
140 .await
141 .log_err()
142}