use std::path::{Path, PathBuf};
use std::process::Command;
#[derive(Clone, Copy)]
pub struct LspLanguage {
pub language_id: &'static str,
pub server_key: &'static str,
}
#[derive(Clone, Copy)]
struct LspLanguageMapping {
extensions: &'static [&'static str],
language_id: &'static str,
server_key: &'static str,
}
#[derive(Clone, Copy)]
pub struct LspServerConfig {
pub key: &'static str,
pub env_vars: &'static [&'static str],
pub default_command: &'static [&'static str],
}
pub struct LspCommand {
pub program: String,
pub args: Vec<String>,
}
const LSP_LANGUAGE_MAPPINGS: &[LspLanguageMapping] = &[
LspLanguageMapping {
extensions: &["rs"],
language_id: "rust",
server_key: "rust-analyzer",
},
LspLanguageMapping {
extensions: &["py"],
language_id: "python",
server_key: "pyright",
},
LspLanguageMapping {
extensions: &["js", "jsx"],
language_id: "javascript",
server_key: "typescript-language-server",
},
LspLanguageMapping {
extensions: &["ts", "tsx"],
language_id: "typescript",
server_key: "typescript-language-server",
},
LspLanguageMapping {
extensions: &["lua"],
language_id: "lua",
server_key: "lua-language-server",
},
LspLanguageMapping {
extensions: &["go"],
language_id: "go",
server_key: "gopls",
},
];
const LSP_SERVER_CONFIGS: &[LspServerConfig] = &[
LspServerConfig {
key: "rust-analyzer",
env_vars: &["RUST_ANALYZER", "RUST_ANALYZER_PATH"],
default_command: &["rust-analyzer"],
},
LspServerConfig {
key: "pyright",
env_vars: &["PYRIGHT_LANGSERVER", "PYRIGHT_LANGSERVER_PATH"],
default_command: &["pyright-langserver", "--stdio"],
},
LspServerConfig {
key: "typescript-language-server",
env_vars: &[
"TYPESCRIPT_LANGUAGE_SERVER",
"TYPESCRIPT_LANGUAGE_SERVER_PATH",
],
default_command: &["typescript-language-server", "--stdio"],
},
LspServerConfig {
key: "lua-language-server",
env_vars: &["LUA_LANGUAGE_SERVER", "LUA_LANGUAGE_SERVER_PATH"],
default_command: &["lua-language-server"],
},
LspServerConfig {
key: "gopls",
env_vars: &["GOPLS", "GOPLS_PATH"],
default_command: &["gopls"],
},
];
pub fn lsp_language_for_extension(extension: &str) -> Option<LspLanguage> {
LSP_LANGUAGE_MAPPINGS
.iter()
.find(|mapping| {
mapping
.extensions
.iter()
.any(|ext| ext.eq_ignore_ascii_case(extension))
})
.map(|mapping| LspLanguage {
language_id: mapping.language_id,
server_key: mapping.server_key,
})
}
pub fn lsp_language_for_path(path: &Path) -> Option<LspLanguage> {
let extension = path.extension()?.to_str()?;
lsp_language_for_extension(extension)
}
pub fn lsp_server_config(key: &str) -> Option<&'static LspServerConfig> {
LSP_SERVER_CONFIGS.iter().find(|config| config.key == key)
}
pub fn resolve_lsp_command(
config: &LspServerConfig,
) -> Result<LspCommand, String> {
let program = if config.key == "rust-analyzer" {
resolve_rust_analyzer_command()?
} else if config.key == "gopls" {
resolve_gopls_command()?
} else {
resolve_program_from_envs(config.env_vars)
.unwrap_or_else(|| config.default_command[0].to_string())
};
let args = config
.default_command
.iter()
.skip(1)
.map(|arg| arg.to_string())
.collect();
Ok(LspCommand { program, args })
}
fn resolve_program_from_envs(env_vars: &[&str]) -> Option<String> {
resolve_program_from_envs_with(env_vars, |var| std::env::var(var).ok())
}
fn resolve_program_from_envs_with(
env_vars: &[&str],
lookup: impl Fn(&str) -> Option<String>,
) -> Option<String> {
for var in env_vars {
if let Some(path) = lookup(var) {
let path = path.trim();
if !path.is_empty() {
return Some(path.to_string());
}
}
}
None
}
fn resolve_rust_analyzer_command() -> Result<String, String> {
resolve_rust_analyzer_command_with(
|var| std::env::var(var).ok(),
|| Command::new("rust-analyzer").arg("--version").output().is_ok(),
|| {
let output = Command::new("rustup")
.args(["which", "rust-analyzer"])
.output()
.ok()?;
if !output.status.success() {
return None;
}
let path =
String::from_utf8_lossy(&output.stdout).trim().to_string();
(!path.is_empty()).then_some(path)
},
)
}
fn resolve_rust_analyzer_command_with(
lookup: impl Fn(&str) -> Option<String>,
is_on_path: impl Fn() -> bool,
rustup_which: impl Fn() -> Option<String>,
) -> Result<String, String> {
if let Some(path) = resolve_program_from_envs_with(
&["RUST_ANALYZER", "RUST_ANALYZER_PATH"],
&lookup,
) {
return Ok(path);
}
if is_on_path() {
return Ok("rust-analyzer".to_string());
}
if let Some(path) = rustup_which() {
return Ok(path);
}
Err(
"rust-analyzer not found. Please run rustup component add rust-analyzer or brew install rust-analyzer"
.to_string(),
)
}
fn resolve_gopls_command() -> Result<String, String> {
resolve_gopls_command_with(
|var| std::env::var(var).ok(),
|| Command::new("gopls").arg("version").output().is_ok(),
|| go_env_var("GOBIN"),
|| go_env_var("GOPATH"),
Path::exists,
)
}
fn go_env_var(var: &str) -> Option<String> {
let output = Command::new("go").args(["env", var]).output().ok()?;
if !output.status.success() {
return None;
}
let value = String::from_utf8_lossy(&output.stdout).trim().to_string();
(!value.is_empty()).then_some(value)
}
fn resolve_gopls_command_with(
lookup: impl Fn(&str) -> Option<String>,
is_on_path: impl Fn() -> bool,
gobin: impl Fn() -> Option<String>,
gopath: impl Fn() -> Option<String>,
exists: impl Fn(&Path) -> bool,
) -> Result<String, String> {
if let Some(path) =
resolve_program_from_envs_with(&["GOPLS", "GOPLS_PATH"], &lookup)
{
return Ok(path);
}
if is_on_path() {
return Ok("gopls".to_string());
}
if let Some(gobin_path) = gobin() {
let candidate = PathBuf::from(gobin_path).join("gopls");
if exists(&candidate) {
return Ok(candidate.to_string_lossy().to_string());
}
}
if let Some(gopath_value) = gopath() {
for path in std::env::split_paths(&gopath_value) {
if path.as_os_str().is_empty() {
continue;
}
let candidate = path.join("bin").join("gopls");
if exists(&candidate) {
return Ok(candidate.to_string_lossy().to_string());
}
}
}
Err(
"gopls not found. Please set GOPLS/GOPLS_PATH or add GOPATH/bin to PATH"
.to_string(),
)
}
#[cfg(target_os = "macos")]
pub fn ensure_rust_analyzer_config() {
let Some(home) = std::env::var_os("HOME") else { return };
let mut path = std::path::PathBuf::from(home);
path.push("Library");
path.push("Application Support");
path.push("rust-analyzer");
let _ = std::fs::create_dir_all(&path);
path.push("rust-analyzer.toml");
if !path.exists() {
let _ = std::fs::write(path, "");
}
}
#[cfg(not(target_os = "macos"))]
pub fn ensure_rust_analyzer_config() {}
#[cfg(test)]
mod tests {
use super::*;
use std::collections::HashMap;
fn lookup_from(vars: &[(&str, &str)]) -> impl Fn(&str) -> Option<String> {
let map: HashMap<&str, &str> = vars.iter().copied().collect();
move |var: &str| map.get(var).map(|v| v.to_string())
}
#[test]
#[allow(clippy::unwrap_used)]
fn test_lsp_language_for_extension_known() {
let lang = lsp_language_for_extension("rs").unwrap();
assert_eq!(lang.language_id, "rust");
assert_eq!(lang.server_key, "rust-analyzer");
}
#[test]
#[allow(clippy::unwrap_used)]
fn test_lsp_language_for_extension_is_case_insensitive() {
let lang = lsp_language_for_extension("RS").unwrap();
assert_eq!(lang.language_id, "rust");
}
#[test]
#[allow(clippy::unwrap_used)]
fn test_lsp_language_for_extension_shared_by_multiple_extensions() {
let jsx = lsp_language_for_extension("jsx").unwrap();
let ts = lsp_language_for_extension("tsx").unwrap();
assert_eq!(jsx.server_key, "typescript-language-server");
assert_eq!(ts.language_id, "typescript");
}
#[test]
fn test_lsp_language_for_extension_unknown() {
assert!(lsp_language_for_extension("xyz").is_none());
}
#[test]
#[allow(clippy::unwrap_used)]
fn test_lsp_language_for_path_known_extension() {
let lang = lsp_language_for_path(Path::new("src/main.go")).unwrap();
assert_eq!(lang.server_key, "gopls");
}
#[test]
fn test_lsp_language_for_path_no_extension() {
assert!(lsp_language_for_path(Path::new("Makefile")).is_none());
}
#[test]
fn test_lsp_language_for_path_unknown_extension() {
assert!(lsp_language_for_path(Path::new("data.xyz")).is_none());
}
#[test]
#[allow(clippy::unwrap_used)]
fn test_lsp_server_config_known() {
let cfg = lsp_server_config("gopls").unwrap();
assert_eq!(cfg.env_vars, &["GOPLS", "GOPLS_PATH"]);
assert_eq!(cfg.default_command, &["gopls"]);
}
#[test]
fn test_lsp_server_config_unknown() {
assert!(lsp_server_config("unknown-server").is_none());
}
#[test]
fn test_resolve_program_from_envs_with_first_set_var_wins() {
let lookup = lookup_from(&[("SECOND", "/bin/second")]);
let result =
resolve_program_from_envs_with(&["FIRST", "SECOND"], lookup);
assert_eq!(result, Some("/bin/second".to_string()));
}
#[test]
fn test_resolve_program_from_envs_with_skips_blank_values() {
let lookup =
lookup_from(&[("FIRST", " "), ("SECOND", "/bin/second")]);
let result =
resolve_program_from_envs_with(&["FIRST", "SECOND"], lookup);
assert_eq!(result, Some("/bin/second".to_string()));
}
#[test]
fn test_resolve_program_from_envs_with_none_when_all_unset() {
let lookup = lookup_from(&[]);
let result =
resolve_program_from_envs_with(&["FIRST", "SECOND"], lookup);
assert_eq!(result, None);
}
#[test]
fn test_resolve_program_from_envs_with_trims_surrounding_whitespace() {
let lookup = lookup_from(&[("FIRST", " /bin/first\n")]);
let result =
resolve_program_from_envs_with(&["FIRST", "SECOND"], lookup);
assert_eq!(result, Some("/bin/first".to_string()));
}
#[test]
fn test_resolve_rust_analyzer_command_with_env_var_takes_priority() {
let lookup = lookup_from(&[("RUST_ANALYZER", "/custom/rust-analyzer")]);
let result =
resolve_rust_analyzer_command_with(lookup, || true, || None);
assert_eq!(result, Ok("/custom/rust-analyzer".to_string()));
}
#[test]
fn test_resolve_rust_analyzer_command_with_falls_back_to_path() {
let lookup = lookup_from(&[]);
let result =
resolve_rust_analyzer_command_with(lookup, || true, || None);
assert_eq!(result, Ok("rust-analyzer".to_string()));
}
#[test]
fn test_resolve_rust_analyzer_command_with_falls_back_to_rustup() {
let lookup = lookup_from(&[]);
let result = resolve_rust_analyzer_command_with(
lookup,
|| false,
|| Some("/home/user/.rustup/bin/rust-analyzer".to_string()),
);
assert_eq!(
result,
Ok("/home/user/.rustup/bin/rust-analyzer".to_string())
);
}
#[test]
#[allow(clippy::unwrap_used)]
fn test_resolve_rust_analyzer_command_with_returns_err_when_nothing_found()
{
let lookup = lookup_from(&[]);
let result =
resolve_rust_analyzer_command_with(lookup, || false, || None);
result.unwrap_err();
}
#[test]
fn test_resolve_gopls_command_with_env_var_takes_priority() {
let lookup = lookup_from(&[("GOPLS", "/custom/gopls")]);
let result = resolve_gopls_command_with(
lookup,
|| true,
|| None,
|| None,
|_| true,
);
assert_eq!(result, Ok("/custom/gopls".to_string()));
}
#[test]
fn test_resolve_gopls_command_with_falls_back_to_path() {
let lookup = lookup_from(&[]);
let result = resolve_gopls_command_with(
lookup,
|| true,
|| None,
|| None,
|_| true,
);
assert_eq!(result, Ok("gopls".to_string()));
}
#[test]
fn test_resolve_gopls_command_with_falls_back_to_gobin_when_it_exists() {
let lookup = lookup_from(&[]);
let result = resolve_gopls_command_with(
lookup,
|| false,
|| Some("/home/user/go/bin".to_string()),
|| None,
|p| p == Path::new("/home/user/go/bin/gopls"),
);
assert_eq!(result, Ok("/home/user/go/bin/gopls".to_string()));
}
#[test]
fn test_resolve_gopls_command_with_falls_back_to_gopath_when_it_exists() {
let lookup = lookup_from(&[]);
let result = resolve_gopls_command_with(
lookup,
|| false,
|| None,
|| Some("/nonexistent:/home/user/go".to_string()),
|p| p == Path::new("/home/user/go/bin/gopls"),
);
assert_eq!(result, Ok("/home/user/go/bin/gopls".to_string()));
}
#[test]
#[allow(clippy::unwrap_used)]
fn test_resolve_gopls_command_with_skips_gobin_when_gopls_does_not_exist_there()
{
let lookup = lookup_from(&[]);
let result = resolve_gopls_command_with(
lookup,
|| false,
|| Some("/home/user/go/bin".to_string()),
|| Some("/home/user/go".to_string()),
|_| false,
);
result.unwrap_err();
}
#[test]
#[allow(clippy::unwrap_used)]
fn test_resolve_gopls_command_with_returns_err_when_nothing_found() {
let lookup = lookup_from(&[]);
let result = resolve_gopls_command_with(
lookup,
|| false,
|| None,
|| None,
|_| false,
);
result.unwrap_err();
}
}