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