use std::path::{Path, PathBuf};
use serde_json::{json, Value};
use crate::ast::Language;
use super::install;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum Readiness {
Initialized,
Quiescent,
ProjectLoaded,
}
#[derive(Clone, Copy, Debug)]
pub(crate) enum RootRule {
Outermost(&'static [&'static str]),
NearestOrIndexRoot(&'static [&'static str]),
WorkspaceOrModule {
workspace: &'static [&'static str],
module: &'static [&'static str],
},
}
pub(crate) struct Launch {
pub id: &'static str,
pub programs: &'static [&'static str],
pub program_env: &'static str,
pub args: &'static [&'static str],
pub project_bin: Option<&'static str>,
pub readiness: Readiness,
pub hidden_path_safe_root: bool,
}
pub(crate) struct ServerSpec {
pub id: &'static str,
pub launches: &'static [Launch],
pub language_id: fn(Language) -> &'static str,
pub root: RootRule,
initialization: fn() -> Value,
settings: fn(&str) -> Value,
}
impl ServerSpec {
pub(crate) fn initialization_options(&self) -> Value {
(self.initialization)()
}
pub(crate) fn settings(&self) -> fn(&str) -> Value {
self.settings
}
pub(crate) fn workspace_root(&self, file: &Path, index_root: &Path) -> Option<PathBuf> {
let ancestors = || {
file.ancestors()
.skip(1)
.take_while(|dir| dir.starts_with(index_root))
};
let marked = |dir: &&Path, markers: &[&str]| markers.iter().any(|m| dir.join(m).exists());
match self.root {
RootRule::Outermost(markers) => ancestors()
.filter(|dir| marked(dir, markers))
.last()
.map(Path::to_path_buf),
RootRule::NearestOrIndexRoot(markers) => Some(
ancestors()
.find(|dir| marked(dir, markers))
.unwrap_or(index_root)
.to_path_buf(),
),
RootRule::WorkspaceOrModule { workspace, module } => ancestors()
.filter(|dir| marked(dir, workspace))
.last()
.or_else(|| ancestors().find(|dir| marked(dir, module)))
.map(Path::to_path_buf),
}
}
}
impl Launch {
pub(crate) fn resolve_program(&self, root: &Path) -> Result<String, String> {
#[cfg(test)]
if let Some(program) = test_override::get(self.id) {
return Ok(program);
}
self.resolve_with(&install::ProcessProbe, root)
}
pub(crate) fn resolve_with(
&self,
probe: &dyn install::Probe,
root: &Path,
) -> Result<String, String> {
if let Some(program) = probe.raw_var(self.program_env) {
let program = PathBuf::from(program);
return if program.is_file() {
Ok(program.to_string_lossy().into_owned())
} else {
Err(format!(
"{} names `{}`, which is not a file",
self.program_env,
program.display()
))
};
}
let mut dirs: Vec<PathBuf> = self
.project_bin
.map(|dir| root.join(dir))
.into_iter()
.collect();
if let Some(path) = probe.var("PATH") {
dirs.extend(std::env::split_paths(&path).filter(|dir| dir.is_absolute()));
}
dirs.extend(install::install_dirs(probe, root));
let mut skipped = Vec::new();
for program in self.programs {
for dir in &dirs {
let Some(found) = find_in(dir, program) else {
continue;
};
match self.unusable(probe, root, &found, program) {
Some(reason) => skipped.push(reason),
None => return Ok(found.to_string_lossy().into_owned()),
}
}
}
skipped.dedup();
if !skipped.is_empty() {
return Err(skipped.join("; "));
}
Err(format!(
"{} is not installed (looked for {} on PATH and in {})",
self.id,
self.programs.join(", "),
install::install_dirs(probe, root)
.iter()
.map(|dir| dir.display().to_string())
.collect::<Vec<_>>()
.join(", ")
))
}
fn unusable(
&self,
probe: &dyn install::Probe,
root: &Path,
found: &Path,
program: &str,
) -> Option<String> {
if install::is_rustup_proxy(found) {
let Some(toolchain) = install::rustup_toolchain(probe, root) else {
return Some(format!(
"`{}` is a rustup proxy, and rustup selects no installed toolchain for {}",
found.display(),
root.display()
));
};
return find_in(&toolchain.bin, program).is_none().then(|| {
format!(
"{program} is not installed for the {} toolchain (rustup component add {program})",
toolchain.name
)
});
}
if program == "tsc" {
let Some(major) = typescript_major(found) else {
return Some(format!(
"cannot determine the TypeScript version for `{}`; `tsc --lsp` needs TypeScript 7",
found.display()
));
};
return (major < 7).then(|| {
format!(
"`{}` is TypeScript {major}; `tsc --lsp` needs TypeScript 7",
found.display()
)
});
}
None
}
}
fn typescript_major(tsc: &Path) -> Option<u64> {
let mut script = std::fs::canonicalize(tsc).ok()?;
if script
.extension()
.is_some_and(|ext| ext.eq_ignore_ascii_case("cmd"))
{
let shim = std::fs::read_to_string(&script).ok()?;
let (_, invocation) = shim
.lines()
.last()?
.rsplit_once(" & \"%_prog%\" \"%dp0%\\")?;
let target = invocation.strip_suffix("\" %*")?;
let relative = match target {
r"..\typescript\bin\tsc" => "../typescript/bin/tsc",
r"node_modules\typescript\bin\tsc" => "node_modules/typescript/bin/tsc",
_ => return None,
};
script = std::fs::canonicalize(script.parent()?.join(relative)).ok()?;
}
let package = script.parent()?.parent()?.join("package.json");
let manifest: Value = serde_json::from_str(&std::fs::read_to_string(package).ok()?).ok()?;
if manifest.get("name")?.as_str()? != "typescript" {
return None;
}
manifest
.get("version")?
.as_str()?
.split('.')
.next()?
.parse()
.ok()
}
#[cfg(test)]
mod version_tests {
use super::typescript_major;
#[test]
fn npm_windows_shims_identify_the_launched_typescript_package() {
let root = tempfile::tempdir().unwrap();
for (shim_dir, package_dir, target) in [
(
"local/node_modules/.bin",
"local/node_modules/typescript",
r"..\typescript\bin\tsc",
),
(
"global",
"global/node_modules/typescript",
r"node_modules\typescript\bin\tsc",
),
] {
let shim_dir = root.path().join(shim_dir);
let package_dir = root.path().join(package_dir);
std::fs::create_dir_all(&shim_dir).unwrap();
std::fs::create_dir_all(package_dir.join("bin")).unwrap();
std::fs::write(package_dir.join("bin/tsc"), "").unwrap();
std::fs::write(
package_dir.join("package.json"),
r#"{"name":"typescript","version":"7.0.1"}"#,
)
.unwrap();
let shim = shim_dir.join("tsc.cmd");
std::fs::write(&shim, format!("endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & \"%_prog%\" \"%dp0%\\{target}\" %*\r\n")).unwrap();
assert_eq!(typescript_major(&shim), Some(7));
std::fs::write(&shim, "@echo off\r\necho unrelated\r\n").unwrap();
assert_eq!(
typescript_major(&shim),
None,
"an unrelated launcher must not inherit a neighboring package's version"
);
}
}
}
fn find_in(dir: &Path, program: &str) -> Option<PathBuf> {
let names: Vec<String> = if cfg!(windows) {
["exe", "cmd", "bat"]
.iter()
.map(|extension| format!("{program}.{extension}"))
.collect()
} else {
vec![program.to_string()]
};
names
.into_iter()
.map(|name| dir.join(name))
.find(|candidate| candidate.is_file())
}
const RUST_ANALYZER: ServerSpec = ServerSpec {
id: "rust",
launches: &[Launch {
id: "rust-analyzer",
programs: &["rust-analyzer"],
program_env: "HARN_LSP_SERVER_RUST_ANALYZER",
args: &[],
project_bin: None,
readiness: Readiness::Quiescent,
hidden_path_safe_root: false,
}],
language_id: |_| "rust",
root: RootRule::Outermost(&["Cargo.toml"]),
initialization: rust_analyzer_settings,
settings: |section| match section {
"rust-analyzer" => rust_analyzer_settings(),
_ => Value::Null,
},
};
fn rust_analyzer_settings() -> Value {
json!({
"checkOnSave": false,
"check": {"workspace": false},
"cargo": {"buildScripts": {"enable": false}, "features": "all"},
"procMacro": {"enable": false},
"cachePriming": {"enable": false},
"diagnostics": {"enable": false},
})
}
const TYPESCRIPT: ServerSpec = ServerSpec {
id: "typescript",
launches: &[
Launch {
id: "typescript-language-server",
programs: &["typescript-language-server"],
program_env: "HARN_LSP_SERVER_TYPESCRIPT_LANGUAGE_SERVER",
args: &["--stdio"],
project_bin: Some("node_modules/.bin"),
readiness: Readiness::ProjectLoaded,
hidden_path_safe_root: false,
},
Launch {
id: "tsc-lsp",
programs: &["tsc"],
program_env: "HARN_LSP_SERVER_TSC_LSP",
args: &["--lsp", "--stdio"],
project_bin: Some("node_modules/.bin"),
readiness: Readiness::Initialized,
hidden_path_safe_root: false,
},
],
language_id: |language| match language {
Language::Tsx => "typescriptreact",
Language::JavaScript => "javascript",
Language::Jsx => "javascriptreact",
_ => "typescript",
},
root: RootRule::NearestOrIndexRoot(&["tsconfig.json", "jsconfig.json", "package.json"]),
initialization: || {
json!({
"preferences": {
"providePrefixAndSuffixTextForRename": false,
"allowRenameOfImportPath": false,
},
"tsserver": {"useSyntaxServer": "never"},
})
},
settings: |section| match section {
"typescript" | "javascript" | "js/ts" => {
json!({"preferences": {"useAliasesForRenames": false}})
}
_ => Value::Null,
},
};
const PYRIGHT: ServerSpec = ServerSpec {
id: "python",
launches: &[Launch {
id: "pyright",
programs: &["basedpyright-langserver", "pyright-langserver"],
program_env: "HARN_LSP_SERVER_PYRIGHT",
args: &["--stdio"],
project_bin: None,
readiness: Readiness::Initialized,
hidden_path_safe_root: false,
}],
language_id: |_| "python",
root: RootRule::NearestOrIndexRoot(&[
"pyrightconfig.json",
"pyproject.toml",
"setup.py",
"setup.cfg",
]),
initialization: || Value::Null,
settings: |_| Value::Null,
};
const GOPLS: ServerSpec = ServerSpec {
id: "go",
launches: &[Launch {
id: "gopls",
programs: &["gopls"],
program_env: "HARN_LSP_SERVER_GOPLS",
args: &[],
project_bin: None,
readiness: Readiness::ProjectLoaded,
hidden_path_safe_root: true,
}],
language_id: |_| "go",
root: RootRule::WorkspaceOrModule {
workspace: &["go.work"],
module: &["go.mod"],
},
initialization: || Value::Null,
settings: |_| Value::Null,
};
pub(crate) fn for_language(language: Language) -> Option<&'static ServerSpec> {
match language {
Language::Rust => Some(&RUST_ANALYZER),
Language::TypeScript | Language::Tsx | Language::JavaScript | Language::Jsx => {
Some(&TYPESCRIPT)
}
Language::Python => Some(&PYRIGHT),
Language::Go => Some(&GOPLS),
_ => None,
}
}
#[cfg(test)]
pub(crate) mod test_override {
use std::cell::RefCell;
use std::collections::HashMap;
thread_local! {
static PROGRAMS: RefCell<HashMap<&'static str, String>> = RefCell::new(HashMap::new());
}
pub(crate) fn get(id: &str) -> Option<String> {
PROGRAMS.with(|programs| programs.borrow().get(id).cloned())
}
pub(crate) fn set(id: &'static str, program: &str) {
PROGRAMS.with(|programs| programs.borrow_mut().insert(id, program.to_string()));
}
}