1use anyhow::{anyhow, Result};
2use async_trait::async_trait;
3use collections::HashMap;
4use gpui::AsyncAppContext;
5use language::{LanguageToolchainStore, LspAdapter, LspAdapterDelegate};
6use lsp::{CodeActionKind, LanguageServerBinary, LanguageServerName};
7use node_runtime::NodeRuntime;
8use project::lsp_store::language_server_settings;
9use serde_json::Value;
10use std::{
11 any::Any,
12 ffi::OsString,
13 path::{Path, PathBuf},
14 sync::Arc,
15};
16use util::{maybe, merge_json_value_into, ResultExt};
17
18fn typescript_server_binary_arguments(server_path: &Path) -> Vec<OsString> {
19 vec![server_path.into(), "--stdio".into()]
20}
21
22pub struct VtslsLspAdapter {
23 node: NodeRuntime,
24}
25
26impl VtslsLspAdapter {
27 const PACKAGE_NAME: &'static str = "@vtsls/language-server";
28 const SERVER_PATH: &'static str = "node_modules/@vtsls/language-server/bin/vtsls.js";
29
30 const TYPESCRIPT_PACKAGE_NAME: &'static str = "typescript";
31 const TYPESCRIPT_TSDK_PATH: &'static str = "node_modules/typescript/lib";
32
33 pub fn new(node: NodeRuntime) -> Self {
34 VtslsLspAdapter { node }
35 }
36
37 async fn tsdk_path(adapter: &Arc<dyn LspAdapterDelegate>) -> &'static str {
38 let is_yarn = adapter
39 .read_text_file(PathBuf::from(".yarn/sdks/typescript/lib/typescript.js"))
40 .await
41 .is_ok();
42
43 if is_yarn {
44 ".yarn/sdks/typescript/lib"
45 } else {
46 Self::TYPESCRIPT_TSDK_PATH
47 }
48 }
49}
50
51struct TypeScriptVersions {
52 typescript_version: String,
53 server_version: String,
54}
55
56const SERVER_NAME: LanguageServerName = LanguageServerName::new_static("vtsls");
57
58#[async_trait(?Send)]
59impl LspAdapter for VtslsLspAdapter {
60 fn name(&self) -> LanguageServerName {
61 SERVER_NAME.clone()
62 }
63
64 async fn fetch_latest_server_version(
65 &self,
66 _: &dyn LspAdapterDelegate,
67 ) -> Result<Box<dyn 'static + Send + Any>> {
68 Ok(Box::new(TypeScriptVersions {
69 typescript_version: self.node.npm_package_latest_version("typescript").await?,
70 server_version: self
71 .node
72 .npm_package_latest_version("@vtsls/language-server")
73 .await?,
74 }) as Box<_>)
75 }
76
77 async fn check_if_user_installed(
78 &self,
79 delegate: &dyn LspAdapterDelegate,
80 _: Arc<dyn LanguageToolchainStore>,
81 _: &AsyncAppContext,
82 ) -> Option<LanguageServerBinary> {
83 let env = delegate.shell_env().await;
84 let path = delegate.which(SERVER_NAME.as_ref()).await?;
85 Some(LanguageServerBinary {
86 path: path.clone(),
87 arguments: typescript_server_binary_arguments(&path),
88 env: Some(env),
89 })
90 }
91
92 async fn fetch_server_binary(
93 &self,
94 latest_version: Box<dyn 'static + Send + Any>,
95 container_dir: PathBuf,
96 _: &dyn LspAdapterDelegate,
97 ) -> Result<LanguageServerBinary> {
98 let latest_version = latest_version.downcast::<TypeScriptVersions>().unwrap();
99 let server_path = container_dir.join(Self::SERVER_PATH);
100
101 let mut packages_to_install = Vec::new();
102
103 if self
104 .node
105 .should_install_npm_package(
106 Self::PACKAGE_NAME,
107 &server_path,
108 &container_dir,
109 &latest_version.server_version,
110 )
111 .await
112 {
113 packages_to_install.push((Self::PACKAGE_NAME, latest_version.server_version.as_str()));
114 }
115
116 if self
117 .node
118 .should_install_npm_package(
119 Self::TYPESCRIPT_PACKAGE_NAME,
120 &container_dir.join(Self::TYPESCRIPT_TSDK_PATH),
121 &container_dir,
122 &latest_version.typescript_version,
123 )
124 .await
125 {
126 packages_to_install.push((
127 Self::TYPESCRIPT_PACKAGE_NAME,
128 latest_version.typescript_version.as_str(),
129 ));
130 }
131
132 self.node
133 .npm_install_packages(&container_dir, &packages_to_install)
134 .await?;
135
136 Ok(LanguageServerBinary {
137 path: self.node.binary_path().await?,
138 env: None,
139 arguments: typescript_server_binary_arguments(&server_path),
140 })
141 }
142
143 async fn cached_server_binary(
144 &self,
145 container_dir: PathBuf,
146 _: &dyn LspAdapterDelegate,
147 ) -> Option<LanguageServerBinary> {
148 get_cached_ts_server_binary(container_dir, &self.node).await
149 }
150
151 fn code_action_kinds(&self) -> Option<Vec<CodeActionKind>> {
152 Some(vec![
153 CodeActionKind::QUICKFIX,
154 CodeActionKind::REFACTOR,
155 CodeActionKind::REFACTOR_EXTRACT,
156 CodeActionKind::SOURCE,
157 ])
158 }
159
160 async fn label_for_completion(
161 &self,
162 item: &lsp::CompletionItem,
163 language: &Arc<language::Language>,
164 ) -> Option<language::CodeLabel> {
165 use lsp::CompletionItemKind as Kind;
166 let len = item.label.len();
167 let grammar = language.grammar()?;
168 let highlight_id = match item.kind? {
169 Kind::CLASS | Kind::INTERFACE | Kind::ENUM => grammar.highlight_id_for_name("type"),
170 Kind::CONSTRUCTOR => grammar.highlight_id_for_name("type"),
171 Kind::CONSTANT => grammar.highlight_id_for_name("constant"),
172 Kind::FUNCTION | Kind::METHOD => grammar.highlight_id_for_name("function"),
173 Kind::PROPERTY | Kind::FIELD => grammar.highlight_id_for_name("property"),
174 Kind::VARIABLE => grammar.highlight_id_for_name("variable"),
175 _ => None,
176 }?;
177
178 let one_line = |s: &str| s.replace(" ", "").replace('\n', " ");
179
180 let text = if let Some(description) = item
181 .label_details
182 .as_ref()
183 .and_then(|label_details| label_details.description.as_ref())
184 {
185 format!("{} {}", item.label, one_line(description))
186 } else if let Some(detail) = &item.detail {
187 format!("{} {}", item.label, one_line(detail))
188 } else {
189 item.label.clone()
190 };
191
192 Some(language::CodeLabel {
193 text,
194 runs: vec![(0..len, highlight_id)],
195 filter_range: 0..len,
196 })
197 }
198
199 async fn workspace_configuration(
200 self: Arc<Self>,
201 delegate: &Arc<dyn LspAdapterDelegate>,
202 _: Arc<dyn LanguageToolchainStore>,
203 cx: &mut AsyncAppContext,
204 ) -> Result<Value> {
205 let tsdk_path = Self::tsdk_path(delegate).await;
206 let config = serde_json::json!({
207 "tsdk": tsdk_path,
208 "suggest": {
209 "completeFunctionCalls": true
210 },
211 "inlayHints": {
212 "parameterNames": {
213 "enabled": "all",
214 "suppressWhenArgumentMatchesName": false
215 },
216 "parameterTypes": {
217 "enabled": true
218 },
219 "variableTypes": {
220 "enabled": true,
221 "suppressWhenTypeMatchesName": false
222 },
223 "propertyDeclarationTypes": {
224 "enabled": true
225 },
226 "functionLikeReturnTypes": {
227 "enabled": true
228 },
229 "enumMemberValues": {
230 "enabled": true
231 }
232 },
233 "tsserver": {
234 "maxTsServerMemory": 8092
235 },
236 });
237
238 let mut default_workspace_configuration = serde_json::json!({
239 "typescript": config,
240 "javascript": config,
241 "vtsls": {
242 "experimental": {
243 "completion": {
244 "enableServerSideFuzzyMatch": true,
245 "entriesLimit": 5000,
246 }
247 },
248 "autoUseWorkspaceTsdk": true
249 }
250 });
251
252 let override_options = cx.update(|cx| {
253 language_server_settings(delegate.as_ref(), &SERVER_NAME, cx)
254 .and_then(|s| s.settings.clone())
255 })?;
256
257 if let Some(override_options) = override_options {
258 merge_json_value_into(override_options, &mut default_workspace_configuration)
259 }
260
261 Ok(default_workspace_configuration)
262 }
263
264 fn language_ids(&self) -> HashMap<String, String> {
265 HashMap::from_iter([
266 ("TypeScript".into(), "typescript".into()),
267 ("JavaScript".into(), "javascript".into()),
268 ("TSX".into(), "typescriptreact".into()),
269 ])
270 }
271}
272
273async fn get_cached_ts_server_binary(
274 container_dir: PathBuf,
275 node: &NodeRuntime,
276) -> Option<LanguageServerBinary> {
277 maybe!(async {
278 let server_path = container_dir.join(VtslsLspAdapter::SERVER_PATH);
279 if server_path.exists() {
280 Ok(LanguageServerBinary {
281 path: node.binary_path().await?,
282 env: None,
283 arguments: typescript_server_binary_arguments(&server_path),
284 })
285 } else {
286 Err(anyhow!(
287 "missing executable in directory {:?}",
288 container_dir
289 ))
290 }
291 })
292 .await
293 .log_err()
294}