Skip to content

The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.

fix(vue): Run Vue Language Server 3 in hybrid mode with a usable TypeScript (#46)

l0ng-ai6dfd82de4ca6
diff --git a/crates/ide-lsp/src/handler.rs b/crates/ide-lsp/src/handler.rs
index 7dbf5a90a..3e79608d4 100644
--- a/crates/ide-lsp/src/handler.rs
+++ b/crates/ide-lsp/src/handler.rs
@@ -128,7 +128,8 @@ impl ClientHandler {
Value::Array(
items
.iter()
- .map(|item| match item.get("section").and_then(Value::as_str) {
+ // vtsls asks for the whole configuration as section `""`.
+ .map(|item| match item.get("section").and_then(Value::as_str).filter(|s| !s.is_empty()) {
Some(section) if section == self.server.name => options.clone(),
// Servers that take settings under `initializationOptions.settings`
// (jdtls) ask for the same sections later.
@@ -193,6 +194,7 @@ impl Handler for ClientHandler {
_ => tracing::debug!("[{}] {text}", self.server.name),
}
}
+ "tsserver/request" => mgr.forward_tsserver_requests(self.server.clone(), self.generation, params),
"telemetry/event" | "$/logTrace" | "$/cancelRequest" => {}
other => tracing::trace!("[{}] unhandled notification {other}", self.server.name),
}
diff --git a/crates/ide-lsp/src/lib.rs b/crates/ide-lsp/src/lib.rs
index ee171c363..bb46369d4 100644
--- a/crates/ide-lsp/src/lib.rs
+++ b/crates/ide-lsp/src/lib.rs
@@ -15,6 +15,7 @@ pub mod jdtls;
mod launch;
mod server;
mod text;
+mod tsserver_bridge;
pub mod types;
mod uri;
mod virtual_doc;
diff --git a/crates/ide-lsp/src/server.rs b/crates/ide-lsp/src/server.rs
index 4568ca442..43d5ba0b1 100644
--- a/crates/ide-lsp/src/server.rs
+++ b/crates/ide-lsp/src/server.rs
@@ -13,7 +13,8 @@ use std::sync::Arc;
use std::time::{Duration, Instant};
use tokio::sync::{Notify, watch};
-const CRASH_WINDOW: Duration = Duration::from_secs(180);
+/// An instance that stayed up this long ran fine: earlier crashes no longer count.
+const STABLE_UPTIME: Duration = Duration::from_secs(180);
const MAX_RESTARTS: usize = 3;
const STDERR_LINES: usize = 50;
@@ -66,7 +67,10 @@ pub struct Server {
state: Mutex<State>,
phase: watch::Sender<Phase>,
status: Mutex<(ServerStatus, Option<String>)>,
- crashes: Mutex<VecDeque<Instant>>,
+ /// Consecutive crashes of short-lived instances.
+ crashes: Mutex<usize>,
+ /// When the current instance was launched.
+ started: Mutex<Option<Instant>>,
stderr: Mutex<VecDeque<String>>,
pub progress: Mutex<HashMap<String, Progress>>,
diagnostics: Mutex<HashMap<PathBuf, Vec<lsp::Diagnostic>>>,
@@ -88,7 +92,8 @@ impl Server {
state: Mutex::new(State { generation: 0, conn: Conn::Idle }),
phase: watch::channel(Phase::Down).0,
status: Mutex::new((ServerStatus::Stopped, None)),
- crashes: Mutex::new(VecDeque::new()),
+ crashes: Mutex::new(0),
+ started: Mutex::new(None),
stderr: Mutex::new(VecDeque::new()),
progress: Mutex::new(HashMap::new()),
diagnostics: Mutex::new(HashMap::new()),
@@ -127,6 +132,7 @@ impl Server {
}
st.generation += 1;
st.conn = Conn::Starting;
+ *self.started.lock() = Some(Instant::now());
self.phase.send_replace(Phase::Starting);
Some(st.generation)
}
@@ -237,21 +243,22 @@ impl Server {
}
}
- /// Records a crash; returns the backoff before restarting, or `None` when
- /// the restart budget for the window is exhausted.
+ /// Records a crash; returns the backoff before restarting, or `None` once
+ /// [`MAX_RESTARTS`] instances in a row died before running [`STABLE_UPTIME`]
+ /// (a server that crashes on every start, however slowly, is not restarted forever).
pub fn record_crash(&self) -> Option<Duration> {
+ let uptime = self.started.lock().map(|t| t.elapsed()).unwrap_or_default();
let mut crashes = self.crashes.lock();
- let now = Instant::now();
- crashes.push_back(now);
- while crashes.front().is_some_and(|t| now.duration_since(*t) > CRASH_WINDOW) {
- crashes.pop_front();
+ if uptime >= STABLE_UPTIME {
+ *crashes = 0;
}
- let n = crashes.len();
+ *crashes += 1;
+ let n = *crashes;
(n <= MAX_RESTARTS).then(|| Duration::from_millis(500) * (1 << (n - 1)) as u32)
}
pub fn reset_for_restart(&self) {
- self.crashes.lock().clear();
+ *self.crashes.lock() = 0;
let mut st = self.state.lock();
if matches!(st.conn, Conn::Missing | Conn::Failed) {
st.conn = Conn::Idle;
@@ -300,8 +307,8 @@ impl Server {
pub fn stderr_tail(&self, n: usize) -> String {
let buf = self.stderr.lock();
- let skip = buf.len().saturating_sub(n);
- buf.iter().skip(skip).cloned().collect::<Vec<_>>().join("\n")
+ let lines: Vec<&str> = buf.iter().map(String::as_str).collect();
+ crash_excerpt(&lines, n)
}
pub fn take_progress(&self) -> Vec<(TaskId, String)> {
@@ -341,3 +348,97 @@ impl Server {
self.diagnostics.lock().drain().map(|(p, _)| p).collect()
}
}
+
+/// The last `n` stderr lines, led by the exception headline: Node.js / Python /
+/// JVM crashes print the error first and a stack after it, so a plain tail
+/// shows frames without saying what went wrong.
+pub(crate) fn crash_excerpt(lines: &[&str], n: usize) -> String {
+ const MAX_LINES: usize = 12;
+ let start = lines.len().saturating_sub(n);
+ let excerpt: Vec<&str> = match lines.iter().rposition(|l| is_error_headline(l)) {
+ Some(i) if i >= start => lines[start..].to_vec(),
+ Some(i) if lines.len() - i <= MAX_LINES => lines[i..].to_vec(),
+ Some(i) => [lines[i], "…"].into_iter().chain(lines[start..].iter().copied()).collect(),
+ None => lines[start..].to_vec(),
+ };
+ excerpt.join("\n")
+}
+
+fn is_error_headline(line: &str) -> bool {
+ let l = line.trim_start();
+ let head = l.split(':').next().unwrap_or_default();
+ let named = (head.ends_with("Error") || head.ends_with("Exception")) && !head.contains(' ') && head.len() < l.len();
+ named || l.starts_with("Exception in thread") || l.starts_with("thread '") && l.contains("panicked")
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn server() -> Server {
+ let cfg: LanguageServerConfig = toml::from_str("name = \"s\"\ncommand = \"s\"").unwrap();
+ Server::new(cfg, PathBuf::from("/p"), LanguageId::new("vue"))
+ }
+
+ #[test]
+ fn crashes_of_short_lived_instances_exhaust_the_budget_whatever_the_spacing() {
+ let s = server();
+ for _ in 0..MAX_RESTARTS {
+ // Even crashes spread minutes apart count while each instance dies young.
+ *s.started.lock() = Some(Instant::now());
+ assert!(s.record_crash().is_some());
+ }
+ *s.started.lock() = Some(Instant::now());
+ assert_eq!(s.record_crash(), None);
+ s.reset_for_restart();
+ assert!(s.record_crash().is_some());
+ }
+
+ #[test]
+ fn a_stable_run_resets_the_budget() {
+ let s = server();
+ for _ in 0..MAX_RESTARTS {
+ assert!(s.record_crash().is_some());
+ }
+ *s.started.lock() = Instant::now().checked_sub(STABLE_UPTIME);
+ assert_eq!(s.record_crash(), Some(Duration::from_millis(500)));
+ }
+
+ #[test]
+ fn crash_excerpt_keeps_the_exception_line() {
+ // Node.js 24 crash of vue-language-server (issue #25), verbatim shape.
+ let node = [
+ "C:\\tools\\node_modules\\@vue\\language-server\\lib\\server.js:40",
+ " projectInfoPromise = sendTsServerRequest('_vue:' + ts.server.protocol.CommandTypes.ProjectInfo, {",
+ " ^",
+ "",
+ "TypeError: Cannot read properties of undefined (reading 'protocol')",
+ " at Object.getLanguageService (C:\\tools\\node_modules\\@vue\\language-server\\lib\\server.js:40:86)",
+ " at Immediate.<anonymous> (C:\\tools\\node_modules\\@volar\\language-server\\lib\\features\\languageFeatures.js:744:62)",
+ " at process.processImmediate (node:internal/timers:504:21)",
+ "",
+ "Node.js v24.12.0",
+ ];
+ let out = crash_excerpt(&node, 5);
+ assert!(out.starts_with("TypeError: Cannot read properties of undefined (reading 'protocol')"), "{out}");
+ assert!(out.ends_with("Node.js v24.12.0"));
+
+ let python = [
+ "Traceback (most recent call last):",
+ " File \"x.py\", line 1",
+ "ModuleNotFoundError: No module named 'jedi'",
+ ];
+ assert_eq!(crash_excerpt(&python, 5), python.join("\n"));
+
+ let mut long_stack = vec!["Exception in thread \"main\" java.lang.IllegalStateException: boom"];
+ long_stack.extend(std::iter::repeat_n("\tat a.b.C.d(C.java:1)", 30));
+ let out = crash_excerpt(&long_stack, 5);
+ assert!(out.starts_with("Exception in thread \"main\""), "{out}");
+ assert_eq!(out.lines().count(), 7);
+
+ let plain = ["starting", "listening", "bye"];
+ assert_eq!(crash_excerpt(&plain, 2), "listening\nbye");
+ // "Error" in prose is not a headline.
+ assert_eq!(crash_excerpt(&["No Error here: fine", "a", "b"], 2), "a\nb");
+ }
+}
diff --git a/crates/ide-lsp/src/tsserver_bridge.rs b/crates/ide-lsp/src/tsserver_bridge.rs
new file mode 100644
index 000000000..5997fb36d
--- /dev/null
+++ b/crates/ide-lsp/src/tsserver_bridge.rs
@@ -0,0 +1,93 @@
+//! Vue Language Server (Volar 3) runs in "hybrid mode": TypeScript work goes to
+//! tsserver with `@vue/typescript-plugin`, through the client. It sends
+//! `tsserver/request` `[id, command, args]` and waits for `tsserver/response`
+//! `[id, body]`; the client forwards the command to vtsls, whose tsserver has the
+//! plugin loaded (`typescript.tsserverRequest`). Without an answer the server
+//! waits forever, so every request is answered — `null` when vtsls can't.
+
+use crate::LspManager;
+use crate::server::Server;
+use serde_json::{Value, json};
+use std::sync::Arc;
+use std::time::Duration;
+
+/// The server that hosts tsserver for the bridge.
+pub(crate) const TSSERVER_HOST: &str = "vtsls";
+const HOST_START_WAIT: Duration = Duration::from_secs(60);
+const REQUEST_TIMEOUT: Duration = Duration::from_secs(30);
+
+/// `[id, command, args]` items of a `tsserver/request` notification
+/// (vscode-jsonrpc wraps the single array argument: `[[id, command, args]]`).
+pub(crate) fn parse_requests(params: &Value) -> Vec<(Value, String, Value)> {
+ let one = |v: &Value| {
+ let a = v.as_array()?;
+ let command = a.get(1)?.as_str()?.to_owned();
+ Some((a.first()?.clone(), command, a.get(2).cloned().unwrap_or(Value::Null)))
+ };
+ match params.as_array() {
+ Some(items) if items.first().is_some_and(Value::is_array) => items.iter().filter_map(one).collect(),
+ Some(_) => one(params).into_iter().collect(),
+ None => Vec::new(),
+ }
+}
+
+impl LspManager {
+ /// Answers `tsserver/request`s of `from` (instance `generation`) via [`TSSERVER_HOST`].
+ pub(crate) fn forward_tsserver_requests(&self, from: Arc<Server>, generation: u64, params: Value) {
+ let Some(me) = self.me.upgrade() else { return };
+ for (id, command, args) in parse_requests(&params) {
+ let me = me.clone();
+ let from = from.clone();
+ self.runtime.spawn(async move {
+ let body = me.tsserver_request(&from, &command, args).await.unwrap_or(Value::Null);
+ if let Some(run) = from.running_gen(generation)
+ && let Err(e) = run.peer.notify("tsserver/response", json!([[id, body]]))
+ {
+ tracing::debug!("{}: tsserver/response: {e}", from.name);
+ }
+ });
+ }
+ }
+
+ async fn tsserver_request(&self, from: &Server, command: &str, args: Value) -> Option<Value> {
+ let host = self
+ .servers
+ .lock()
+ .iter()
+ .filter(|s| s.name == TSSERVER_HOST)
+ .min_by_key(|s| s.root != from.root)
+ .cloned()?;
+ let run = host.wait_ready(HOST_START_WAIT).await?;
+ let params = json!({
+ "command": "typescript.tsserverRequest",
+ "arguments": [command, args, { "isAsync": true, "lowPriority": true }],
+ });
+ let request = run.peer.request::<_, Value>("workspace/executeCommand", params, None);
+ match tokio::time::timeout(REQUEST_TIMEOUT, request).await {
+ Ok(Ok(result)) => result.get("body").cloned(),
+ Ok(Err(e)) => {
+ tracing::debug!("{TSSERVER_HOST}: {command}: {e}");
+ None
+ }
+ Err(_) => None,
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn parses_wrapped_and_bare_requests() {
+ let wrapped = json!([[1, "_vue:projectInfo", { "file": "/p/App.vue" }]]);
+ assert_eq!(
+ parse_requests(&wrapped),
+ vec![(json!(1), "_vue:projectInfo".to_owned(), json!({ "file": "/p/App.vue" }))]
+ );
+ let bare = json!([2, "_vue:getComponentNames", ["/p/App.vue"]]);
+ assert_eq!(parse_requests(&bare), vec![(json!(2), "_vue:getComponentNames".to_owned(), json!(["/p/App.vue"]))]);
+ assert!(parse_requests(&json!({ "id": 1 })).is_empty());
+ assert!(parse_requests(&json!([[3]])).is_empty());
+ }
+}
diff --git a/crates/ide-lsp/tests/real_servers.rs b/crates/ide-lsp/tests/real_servers.rs
index 42f23597a..5c42f7fae 100644
--- a/crates/ide-lsp/tests/real_servers.rs
+++ b/crates/ide-lsp/tests/real_servers.rs
@@ -227,3 +227,75 @@ async fn typescript_language_server_end_to_end() {
.await;
tokio::time::timeout(Duration::from_secs(10), mgr.shutdown_all()).await.unwrap();
}
+
+const APP_VUE: &str = "<script setup lang=\"ts\">\nconst count: number = 1\n</script>\n\n<template>\n <div>{{ count }}</div>\n</template>\n";
+
+fn npm_server(tools: &Path, name: &str, bin: &str, init: Option<serde_json::Value>) -> LanguageServerConfig {
+ LanguageServerConfig {
+ name: name.into(),
+ command: tools.join("node_modules/.bin").join(bin).to_string_lossy().into_owned(),
+ args: vec!["--stdio".into()],
+ env: Default::default(),
+ root_markers: vec!["package.json".into()],
+ initialization_options: init.map(|v| toml::Value::try_from(v).unwrap()),
+ install_hint: None,
+ fallback: false,
+ launch_error: None,
+ }
+}
+
+/// Vue Language Server 3 in hybrid mode: its `tsserver/request`s go through the
+/// client to vtsls with `@vue/typescript-plugin` (issue #25). Set
+/// `OPENIDEA_TEST_NPM_TOOLS` to a dir with `npm i @vue/language-server typescript@"<7" @vtsls/language-server`.
+#[tokio::test(flavor = "multi_thread")]
+#[ignore = "requires @vue/language-server and @vtsls/language-server (OPENIDEA_TEST_NPM_TOOLS)"]
+async fn vue_hybrid_mode_end_to_end() {
+ let tools = std::path::PathBuf::from(std::env::var("OPENIDEA_TEST_NPM_TOOLS").expect("OPENIDEA_TEST_NPM_TOOLS"));
+ let dir = tempfile::tempdir().unwrap();
+ let root = dir.path().canonicalize().unwrap();
+ std::fs::write(root.join("package.json"), "{\"name\":\"app\",\"private\":true}").unwrap();
+ std::fs::write(root.join("tsconfig.json"), "{\"compilerOptions\":{\"strict\":true},\"include\":[\"src/**/*\"]}")
+ .unwrap();
+ std::fs::create_dir_all(root.join("src")).unwrap();
+ let file = root.join("src/App.vue");
+ std::fs::write(&file, APP_VUE).unwrap();
+
+ let plugin = serde_json::json!({ "vtsls": { "tsserver": { "globalPlugins": [{
+ "name": "@vue/typescript-plugin",
+ "location": tools.join("node_modules/@vue/language-server").to_string_lossy(),
+ "languages": ["vue"],
+ "configNamespace": "typescript",
+ "enableForWorkspaceTypeScriptVersions": true,
+ }] } } });
+ for with_vtsls in [false, true] {
+ let mut vue = lang("vue", "vue", npm_server(&tools, "vue-language-server", "vue-language-server", None));
+ if with_vtsls {
+ vue.language_servers.push(npm_server(&tools, "vtsls", "vtsls", Some(plugin.clone())));
+ }
+ let (mgr, events) = manager(&root, LanguageRegistry::from_configs(vec![vue]));
+ let doc = DocId::next();
+ mgr.did_open(doc, &file, &LanguageId::new("vue"), 1, APP_VUE);
+ // `count` in `{{ count }}`.
+ let pos = Pos::new(5, 12);
+ if with_vtsls {
+ let hover = retry("hover", Duration::from_secs(90), || {
+ let mgr = mgr.clone();
+ async move { mgr.hover(doc, pos, Default::default()).await.ok().flatten() }
+ })
+ .await;
+ assert!(hover.contents.value.contains("count: number"), "{}", hover.contents.value);
+ }
+ retry("vue-language-server ready", Duration::from_secs(30), || {
+ let s = last_status(&events, "vue-language-server");
+ async move { matches!(s, Some((ServerStatus::Ready | ServerStatus::Busy, _))).then_some(()) }
+ })
+ .await;
+ // Every request of vue-language-server waits for a tsserver answer (the
+ // project info); without vtsls it is `null` and the server falls back.
+ let symbols = tokio::time::timeout(Duration::from_secs(20), mgr.document_symbols(doc)).await;
+ assert!(matches!(symbols, Ok(Ok(_))), "vue-language-server did not answer: {symbols:?}");
+ let crashed = matches!(last_status(&events, "vue-language-server"), Some((ServerStatus::Crashed, _)));
+ assert!(!crashed, "{:?}", last_status(&events, "vue-language-server"));
+ tokio::time::timeout(Duration::from_secs(10), mgr.shutdown_all()).await.unwrap();
+ }
+}
diff --git a/crates/ide-sdk/src/apply.rs b/crates/ide-sdk/src/apply.rs
index 490defe04..93e0ce644 100644
--- a/crates/ide-sdk/src/apply.rs
+++ b/crates/ide-sdk/src/apply.rs
@@ -2,7 +2,8 @@
//! language servers, run configurations and terminals.
use crate::discover::{project_venv_python, workspace_tsdk};
-use crate::exec::path_with;
+use crate::exec::{path_with, search_path};
+use crate::vue;
use crate::{bin_dir, exe, venv_of};
use ide_core::settings::Settings;
use ide_language::LanguageServerConfig;
@@ -258,6 +259,17 @@ pub fn configure_server(cfg: &mut LanguageServerConfig, root: &Path, server_root
_ => {}
}
}
+ let vue_command = s.tool_path(vue::SERVER).and_then(|p| setting_path(root, p));
+ let vue_command = vue_command.as_deref().map_or(vue::SERVER.into(), Path::to_string_lossy);
+ if name == "vtsls"
+ && let Some(vue) = vue::server_package(&vue_command, &search_path())
+ {
+ let plugin = vue::tsserver_plugin(&vue);
+ merge_init_options(cfg, json!({ "vtsls": { "tsserver": { "globalPlugins": [plugin] } } }));
+ }
+ if name == vue::SERVER {
+ configure_vue_typescript(cfg, root, server_root, s);
+ }
// Node-based servers (`#!/usr/bin/env node`) run on the selected Node.js.
if let Some(dir) = node_dir(root, s) {
@@ -270,6 +282,26 @@ pub fn configure_server(cfg: &mut LanguageServerConfig, root: &Path, server_root
}
}
+/// vue-language-server loads TypeScript as a library (`--tsdk`, else its own
+/// `require('typescript')`): the selected version, else its own, else the
+/// project's — whichever still has the language-service API.
+fn configure_vue_typescript(cfg: &mut LanguageServerConfig, root: &Path, server_root: &Path, s: &Settings) {
+ let selected = tsdk(server_root, s).or_else(|| tsdk(root, s)).filter(|l| vue::has_ts_api(l));
+ let package = vue::server_package(&cfg.command, &search_path());
+ let own = package.as_deref().and_then(vue::own_typescript);
+ let workspace = || workspace_tsdk(server_root).or_else(|| workspace_tsdk(root)).filter(|l| vue::has_ts_api(l));
+ let lib = match selected {
+ Some(lib) => Some(lib),
+ None if own.is_some() => None,
+ None => workspace(),
+ };
+ match lib {
+ Some(lib) => cfg.args.push(format!("--tsdk={}", lib.to_string_lossy())),
+ None if own.is_none() && package.is_some() => cfg.launch_error = Some(vue::missing_typescript_message()),
+ None => {}
+ }
+}
+
fn is_python_command(cmd: &str) -> bool {
let name = Path::new(cmd).file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
let name = name.strip_suffix(".exe").unwrap_or(&name);
diff --git a/crates/ide-sdk/src/lib.rs b/crates/ide-sdk/src/lib.rs
index 1068f19e5..95651dd42 100644
--- a/crates/ide-sdk/src/lib.rs
+++ b/crates/ide-sdk/src/lib.rs
@@ -13,6 +13,7 @@ pub mod libraries;
pub mod locate;
pub mod lombok;
pub mod python;
+mod vue;
use serde::{Deserialize, Serialize};
use specta::Type;
diff --git a/crates/ide-sdk/src/tests.rs b/crates/ide-sdk/src/tests.rs
index 86088a935..5bcc70e49 100644
--- a/crates/ide-sdk/src/tests.rs
+++ b/crates/ide-sdk/src/tests.rs
@@ -461,3 +461,55 @@ fn no_ecosystem_libraries_without_manifests() {
std::fs::create_dir_all(tmp.path().join("node_modules/react")).unwrap();
assert!(crate::libraries::project_libraries(tmp.path(), &Settings::default(), &[]).is_empty());
}
+
+/// Tools dir with vue-language-server and the given TypeScript files, plus a
+/// project; returns (tools, project).
+fn vue_setup(tmp: &Path, tools_ts: &str, project_ts: &str) -> (std::path::PathBuf, std::path::PathBuf) {
+ let tools = tmp.join("tools/node_modules");
+ let project = tmp.join("app");
+ for (p, content) in [
+ (tools.join(".bin/vue-language-server"), ""),
+ (tools.join("@vue/language-server/package.json"), "{}"),
+ (tools.join("typescript/lib").join(tools_ts), ""),
+ (project.join("node_modules/typescript/lib").join(project_ts), ""),
+ (project.join("node_modules/typescript/lib/tsserver.js"), ""),
+ ] {
+ std::fs::create_dir_all(p.parent().unwrap()).unwrap();
+ std::fs::write(p, content).unwrap();
+ }
+ (tools, project)
+}
+
+#[test]
+fn vue_language_server_gets_a_typescript_with_the_language_service_api() {
+ // Issue #25: `typescript@latest` (7.x) in the tools dir has no `ts.server`.
+ let s = Settings::default();
+ let cases = [
+ // (tools TypeScript, project TypeScript, expected --tsdk = project lib, launch error)
+ ("typescript.js", "typescript.js", false, false), // own TypeScript 5/6 works
+ ("tsc.js", "typescript.js", true, false), // own TS 7: the project's
+ ("tsc.js", "tsc.js", false, true), // nothing usable: clear error
+ ];
+ for (tools_ts, project_ts, uses_project, error) in cases {
+ let tmp = tempfile::tempdir().unwrap();
+ let (tools, project) = vue_setup(tmp.path(), tools_ts, project_ts);
+ let mut cfg = server("vue-language-server");
+ cfg.command = tools.join(".bin/vue-language-server").to_string_lossy().into_owned();
+ configure_server(&mut cfg, &project, &project, &s);
+ let tsdk = cfg.args.iter().find_map(|a| a.strip_prefix("--tsdk=")).map(std::path::PathBuf::from);
+ let project_lib = project.join("node_modules/typescript/lib");
+ assert_eq!(tsdk, uses_project.then_some(project_lib), "{tools_ts} / {project_ts}");
+ assert_eq!(cfg.launch_error.is_some(), error, "{tools_ts} / {project_ts}");
+ }
+
+ // A selected version wins over the server's own.
+ let tmp = tempfile::tempdir().unwrap();
+ let (tools, project) = vue_setup(tmp.path(), "typescript.js", "typescript.js");
+ let mut s = Settings::default();
+ s.languages.typescript.version = "workspace".into();
+ let mut cfg = server("vue-language-server");
+ cfg.command = tools.join(".bin/vue-language-server").to_string_lossy().into_owned();
+ configure_server(&mut cfg, &project, &project, &s);
+ let lib = project.join("node_modules/typescript/lib");
+ assert_eq!(cfg.args, [format!("--tsdk={}", lib.to_string_lossy())]);
+}
diff --git a/crates/ide-sdk/src/vue.rs b/crates/ide-sdk/src/vue.rs
new file mode 100644
index 000000000..6809485b7
--- /dev/null
+++ b/crates/ide-sdk/src/vue.rs
@@ -0,0 +1,121 @@
+//! Vue Language Server (Volar 3): the TypeScript it loads as a library, and the
+//! `@vue/typescript-plugin` that vtsls' tsserver hosts for it (hybrid mode).
+
+use std::ffi::OsStr;
+use std::path::{Path, PathBuf};
+
+pub(crate) const SERVER: &str = "vue-language-server";
+const PACKAGE: &str = "@vue/language-server";
+const PLUGIN: &str = "@vue/typescript-plugin";
+
+/// The TypeScript `lib` directory has the language-service API (`typescript.js`).
+/// TypeScript 7, the native port, ships only `tsc`.
+pub(crate) fn has_ts_api(lib: &Path) -> bool {
+ lib.join("typescript.js").is_file()
+}
+
+/// `command` as given (a path) or found on `path`, npm shims included.
+fn find_command(command: &str, path: &OsStr) -> Option<PathBuf> {
+ let p = Path::new(command);
+ if p.is_absolute() {
+ return p.is_file().then(|| p.to_path_buf());
+ }
+ let exts: &[&str] = if cfg!(windows) { &[".cmd", ".exe", ""] } else { &[""] };
+ std::env::split_paths(path)
+ .flat_map(|d| exts.iter().map(move |e| d.join(format!("{command}{e}"))))
+ .find(|c| c.is_file())
+}
+
+/// The npm package an executable comes from: next to a `node_modules/.bin` shim
+/// (the IDE's tools dir, a project), a Windows global shim (`%APPDATA%\npm`), a
+/// Unix global `<prefix>/bin` or a symlink into the package.
+fn package_dir(bin: &Path, package: &str) -> Option<PathBuf> {
+ let dir = bin.parent()?;
+ let mut candidates = vec![dir.join("node_modules").join(package)];
+ if dir.file_name() == Some(OsStr::new(".bin"))
+ && let Some(node_modules) = dir.parent()
+ {
+ candidates.push(node_modules.join(package));
+ }
+ if let Ok(real) = dunce::canonicalize(bin) {
+ candidates.extend(real.ancestors().filter(|a| a.ends_with(package)).map(Path::to_path_buf));
+ }
+ if let Some(prefix) = dir.parent() {
+ candidates.push(prefix.join("lib").join("node_modules").join(package));
+ }
+ candidates.into_iter().find(|c| c.join("package.json").is_file())
+}
+
+/// `@vue/language-server`'s directory for the `vue-language-server` command.
+pub(crate) fn server_package(command: &str, path: &OsStr) -> Option<PathBuf> {
+ package_dir(&find_command(command, path)?, PACKAGE)
+}
+
+/// The TypeScript `require('typescript')` resolves to from `package`, when usable.
+pub(crate) fn own_typescript(package: &Path) -> Option<PathBuf> {
+ package.ancestors().map(|a| a.join("node_modules").join("typescript").join("lib")).find(|l| has_ts_api(l))
+}
+
+/// vtsls `globalPlugins` entry loading the Vue plugin shipped with `package`.
+pub(crate) fn tsserver_plugin(package: &Path) -> serde_json::Value {
+ serde_json::json!({
+ "name": PLUGIN,
+ "location": package.to_string_lossy(),
+ "languages": ["vue"],
+ "configNamespace": "typescript",
+ "enableForWorkspaceTypeScriptVersions": true,
+ })
+}
+
+pub(crate) fn missing_typescript_message() -> String {
+ "Vue Language Server needs TypeScript 5 or 6 (TypeScript 7 has no language service API). \
+ Reinstall it in Settings › Languages & Frameworks › Language Servers, add typescript@\"<7\" \
+ to the project, or pick a TypeScript version in Settings › Languages & Frameworks › TypeScript."
+ .to_owned()
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn touch(p: &Path) {
+ std::fs::create_dir_all(p.parent().unwrap()).unwrap();
+ std::fs::write(p, "{}").unwrap();
+ }
+
+ #[test]
+ fn finds_the_package_of_every_npm_install_layout() {
+ let tmp = tempfile::tempdir().unwrap();
+ let t = tmp.path();
+ // (executable, package.json) per layout.
+ let layouts = [
+ // The IDE's tools dir / a project: node_modules/.bin shim.
+ ("tools/node_modules/.bin/vue-language-server", "tools/node_modules/@vue/language-server/package.json"),
+ // Windows global: %APPDATA%\npm\vue-language-server(.cmd) + %APPDATA%\npm\node_modules.
+ ("npm/vue-language-server", "npm/node_modules/@vue/language-server/package.json"),
+ // Unix global prefix: <prefix>/bin + <prefix>/lib/node_modules.
+ ("prefix/bin/vue-language-server", "prefix/lib/node_modules/@vue/language-server/package.json"),
+ ];
+ for (bin, pkg) in layouts {
+ touch(&t.join(bin));
+ touch(&t.join(pkg));
+ let found = server_package(&t.join(bin).to_string_lossy(), OsStr::new(""));
+ assert_eq!(found, Some(t.join(pkg).parent().unwrap().to_path_buf()), "{bin}");
+ }
+ let path = std::env::join_paths([t.join("tools/node_modules/.bin")]).unwrap();
+ assert_eq!(server_package(SERVER, &path), Some(t.join("tools/node_modules/@vue/language-server")));
+ assert_eq!(server_package("not-installed", &path), None);
+ }
+
+ #[test]
+ fn own_typescript_skips_typescript_7() {
+ let tmp = tempfile::tempdir().unwrap();
+ let pkg = tmp.path().join("node_modules/@vue/language-server");
+ touch(&pkg.join("package.json"));
+ // TypeScript 7 ships only `tsc`.
+ touch(&tmp.path().join("node_modules/typescript/lib/tsc.js"));
+ assert_eq!(own_typescript(&pkg), None);
+ touch(&tmp.path().join("node_modules/typescript/lib/typescript.js"));
+ assert_eq!(own_typescript(&pkg), Some(tmp.path().join("node_modules/typescript/lib")));
+ }
+}
diff --git a/crates/ide-tools/src/lib.rs b/crates/ide-tools/src/lib.rs
index 1b1ec4a57..f11db8bf1 100644
--- a/crates/ide-tools/src/lib.rs
+++ b/crates/ide-tools/src/lib.rs
@@ -90,6 +90,14 @@ struct Manifest {
const MANIFEST: &str = ".openidea-tool.json";
+/// `typescript@<7` → `typescript`, `@vue/language-server` unchanged.
+fn npm_name(spec: &str) -> &str {
+ match spec[1..].find('@') {
+ Some(i) => &spec[..i + 1],
+ None => spec,
+ }
+}
+
pub fn tools_dir(app_data: &Path) -> PathBuf {
app_data.join("tools")
}
@@ -349,6 +357,17 @@ impl Tools {
json.get("version")?.as_str().map(String::from)
}
+ /// Whether an installed npm tool other than `tool` also installs `package`.
+ fn npm_dependency_in_use(&self, tool: &str, package: &str) -> bool {
+ TOOLS.iter().any(|t| match t.method {
+ Method::Npm { packages } if t.name != tool => {
+ packages.iter().skip(1).any(|p| npm_name(p) == package)
+ && self.npm_package_version(npm_name(packages[0])).is_some()
+ }
+ _ => false,
+ })
+ }
+
fn query_version(&self, spec: &ToolSpec, found: &Path) -> Option<String> {
let (cmd, args) = spec.version?;
let sibling = found.parent().and_then(|d| self.exe_in(d, cmd));
@@ -518,7 +537,7 @@ impl Tools {
let managed = managed_bin_dir(&self.root, spec, self.platform).and_then(|d| self.exe_in(&d, main));
if let Some(path) = managed {
let version = match spec.method {
- Method::Npm { packages } => self.npm_package_version(packages[0]),
+ Method::Npm { packages } => self.npm_package_version(npm_name(packages[0])),
_ => self.manifest(spec.name).and_then(|m| m.version),
}
.or_else(|| self.query_version(spec, &path));
@@ -644,7 +663,7 @@ impl Tools {
let (manager, pnpm) = self.npm_manager()?;
self.ensure_package_json()?;
let mut c = self.command(manager);
- let specs = packages.iter().map(|p| format!("{p}@latest"));
+ let specs = packages.iter().map(|p| if npm_name(p) == *p { format!("{p}@latest") } else { p.to_string() });
if pnpm {
c.arg("add").arg("--dir").arg(&self.root).args(specs);
} else {
@@ -1038,12 +1057,19 @@ impl Tools {
}
Method::Npm { packages } => {
if self.root.join("node_modules").exists() {
+ // Shared dependencies (`typescript`) stay while another installed tool needs them.
+ let packages: Vec<&str> = packages
+ .iter()
+ .enumerate()
+ .filter(|(i, p)| *i == 0 || !self.npm_dependency_in_use(spec.name, npm_name(p)))
+ .map(|(_, p)| npm_name(p))
+ .collect();
let (manager, pnpm) = self.npm_manager()?;
let mut c = self.command(manager);
if pnpm {
- c.arg("remove").arg("--dir").arg(&self.root).args(packages);
+ c.arg("remove").arg("--dir").arg(&self.root).args(&packages);
} else {
- c.args(["uninstall", "--no-fund", "--no-audit", "--prefix"]).arg(&self.root).args(packages);
+ c.args(["uninstall", "--no-fund", "--no-audit", "--prefix"]).arg(&self.root).args(&packages);
}
c.current_dir(&self.root);
run_streamed(c, &cancel, &quiet)?;
diff --git a/crates/ide-tools/src/registry.rs b/crates/ide-tools/src/registry.rs
index bd25e806f..7ca612b8b 100644
--- a/crates/ide-tools/src/registry.rs
+++ b/crates/ide-tools/src/registry.rs
@@ -112,6 +112,10 @@ const fn ver(cmd: &'static str) -> Option<(&'static str, &'static [&'static str]
Some((cmd, &["--version"]))
}
+/// The TypeScript these npm servers load as a library (`tsserver.js`, `ts.server`):
+/// TypeScript 7 (the native port) ships neither, and `@latest` resolves to it.
+pub const TYPESCRIPT: &str = "typescript@<7";
+
pub static TOOLS: &[ToolSpec] = &[
ToolSpec {
name: "rust-analyzer",
@@ -138,7 +142,7 @@ pub static TOOLS: &[ToolSpec] = &[
display: "typescript-language-server",
kind: LanguageServer,
commands: &["typescript-language-server"],
- method: Method::Npm { packages: &["typescript-language-server", "typescript"] },
+ method: Method::Npm { packages: &["typescript-language-server", TYPESCRIPT] },
version: ver("typescript-language-server"),
homepage: "https://github.com/typescript-language-server/typescript-language-server",
needs: &[],
@@ -228,7 +232,7 @@ pub static TOOLS: &[ToolSpec] = &[
display: "Svelte Language Server",
kind: LanguageServer,
commands: &["svelteserver"],
- method: Method::Npm { packages: &["svelte-language-server"] },
+ method: Method::Npm { packages: &["svelte-language-server", TYPESCRIPT] },
version: V,
homepage: "https://github.com/sveltejs/language-tools",
needs: &[],
@@ -238,7 +242,7 @@ pub static TOOLS: &[ToolSpec] = &[
display: "Vue Language Server",
kind: LanguageServer,
commands: &["vue-language-server"],
- method: Method::Npm { packages: &["@vue/language-server"] },
+ method: Method::Npm { packages: &["@vue/language-server", TYPESCRIPT] },
version: V,
homepage: "https://github.com/vuejs/language-tools",
needs: &[],
diff --git a/crates/ide-tools/src/tests.rs b/crates/ide-tools/src/tests.rs
index 2edf2507e..b6b9b8a67 100644
--- a/crates/ide-tools/src/tests.rs
+++ b/crates/ide-tools/src/tests.rs
@@ -272,6 +272,54 @@ echo "added 1 package""#,
assert!(env.root.join("package.json").exists());
}
+/// Servers that load TypeScript as a library get one with its JS API: `@latest`
+/// is TypeScript 7 (native, no `ts.server`), which crashed vue-language-server (#25).
+/// Uninstalling one keeps the TypeScript another installed server still uses.
+#[cfg(unix)]
+#[test]
+fn npm_typescript_is_pinned_and_shared() {
+ let env = Env::new();
+ let log = env.root.parent().unwrap().join("npm-args.txt");
+ env.script(
+ &env.sys,
+ "npm",
+ &format!(
+ r#"echo "$@" >> '{log}'
+prefix=""; for a in "$@"; do [ "$prev" = "--prefix" ] && prefix="$a"; prev="$a"; done
+[ "$1" = "install" ] || exit 0
+/bin/mkdir -p "$prefix/node_modules/.bin"
+for a in "$@"; do case "$a" in
+ typescript-language-server@latest) n=typescript-language-server;;
+ @vue/language-server@latest) n=vue-language-server; d=@vue/language-server;;
+ *) continue;;
+esac
+d="${{d:-$n}}"; /bin/mkdir -p "$prefix/node_modules/$d"
+echo '{{"version":"1.0.0"}}' > "$prefix/node_modules/$d/package.json"
+printf '#!/bin/sh\necho 1.0.0\n' > "$prefix/node_modules/.bin/$n"; /bin/chmod +x "$prefix/node_modules/.bin/$n"; d=""
+done"#,
+ log = log.display()
+ ),
+ );
+ let tools = env.tools();
+ for name in ["vue-language-server", "typescript-language-server"] {
+ assert_eq!(
+ tools.install(name, &langs(), &CancellationToken::new(), &|_| {}).unwrap().status,
+ ToolStatus::Installed
+ );
+ }
+ let installs = fs::read_to_string(&log).unwrap();
+ for line in installs.lines() {
+ assert!(line.contains("typescript@<7") && !line.contains("typescript@latest"), "{line}");
+ }
+ assert!(installs.contains("@vue/language-server@latest"), "{installs}");
+
+ fs::write(&log, "").unwrap();
+ tools.uninstall("vue-language-server", &langs()).unwrap();
+ let uninstall = fs::read_to_string(&log).unwrap();
+ assert!(uninstall.contains("uninstall") && uninstall.contains("@vue/language-server"), "{uninstall}");
+ assert!(!uninstall.contains("typescript"), "typescript-language-server still needs it: {uninstall}");
+}
+
#[test]
fn installed_bundle_is_detected_and_resolvable() {
let env = Env::new();
diff --git a/languages/javascript.toml b/languages/javascript.toml
index 9eca84ee5..d16c1ad57 100644
--- a/languages/javascript.toml
+++ b/languages/javascript.toml
@@ -22,7 +22,7 @@ fallback = true
command = "typescript-language-server"
args = ["--stdio"]
root-markers = ["jsconfig.json", "tsconfig.json", "package.json"]
-install-hint = "npm i -g typescript typescript-language-server"
+install-hint = "npm i -g typescript@\"<7\" typescript-language-server"
[debugger]
adapter = "js-debug"
diff --git a/languages/javascriptreact.toml b/languages/javascriptreact.toml
index ddca8d529..540722ee3 100644
--- a/languages/javascriptreact.toml
+++ b/languages/javascriptreact.toml
@@ -21,7 +21,7 @@ fallback = true
command = "typescript-language-server"
args = ["--stdio"]
root-markers = ["jsconfig.json", "tsconfig.json", "package.json"]
-install-hint = "npm i -g typescript typescript-language-server"
+install-hint = "npm i -g typescript@\"<7\" typescript-language-server"
[debugger]
adapter = "js-debug"
diff --git a/languages/typescript.toml b/languages/typescript.toml
index 60432e162..c8dc5779d 100644
--- a/languages/typescript.toml
+++ b/languages/typescript.toml
@@ -21,7 +21,7 @@ fallback = true
command = "typescript-language-server"
args = ["--stdio"]
root-markers = ["tsconfig.json", "jsconfig.json", "package.json"]
-install-hint = "npm i -g typescript typescript-language-server"
+install-hint = "npm i -g typescript@\"<7\" typescript-language-server"
[debugger]
adapter = "js-debug"
diff --git a/languages/typescriptreact.toml b/languages/typescriptreact.toml
index ab3c27c8c..8c5a439d9 100644
--- a/languages/typescriptreact.toml
+++ b/languages/typescriptreact.toml
@@ -21,7 +21,7 @@ fallback = true
command = "typescript-language-server"
args = ["--stdio"]
root-markers = ["tsconfig.json", "jsconfig.json", "package.json"]
-install-hint = "npm i -g typescript typescript-language-server"
+install-hint = "npm i -g typescript@\"<7\" typescript-language-server"
[debugger]
adapter = "js-debug"
diff --git a/languages/vue.toml b/languages/vue.toml
index aab4e5e0a..1176b0ecb 100644
--- a/languages/vue.toml
+++ b/languages/vue.toml
@@ -10,4 +10,14 @@ name = "vue-language-server"
command = "vue-language-server"
args = ["--stdio"]
root-markers = ["package.json", "vite.config.ts", "vite.config.js", "nuxt.config.ts", "tsconfig.json"]
-install-hint = "npm i -g @vue/language-server (TypeScript support also needs @vue/typescript-plugin in vtsls)"
+install-hint = "npm i -g @vue/language-server typescript@\"<7\""
+
+# Hybrid mode: TypeScript in `.vue` files comes from tsserver with
+# `@vue/typescript-plugin` (configured by the settings hook); vue-language-server
+# reaches it through `tsserver/request`, which the client forwards to vtsls.
+[[language-servers]]
+name = "vtsls"
+command = "vtsls"
+args = ["--stdio"]
+root-markers = ["tsconfig.json", "jsconfig.json", "package.json"]
+install-hint = "npm i -g @vtsls/language-server"