use std::path::{Path, PathBuf};
use super::msvc::{self, WindowsLayout};
use super::toolchain::CommandRunner;
const MAX_VERSIONS: usize = 4;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SystemHeaders {
pub directories: Vec<PathBuf>,
pub based_on: String,
}
pub fn discover(runner: &impl CommandRunner, layout: &WindowsLayout) -> Option<SystemHeaders> {
if cfg!(windows) {
return from_windows(runner, layout);
}
from_unix(runner)
}
fn from_windows(runner: &impl CommandRunner, layout: &WindowsLayout) -> Option<SystemHeaders> {
let found = msvc::discover(runner, layout)?;
if found.include.is_empty() {
return None;
}
let toolset = found.toolset.version.clone();
let sdk = found
.sdk
.as_ref()
.map(|sdk| format!(", Windows SDK {}", sdk.version))
.unwrap_or_default();
Some(SystemHeaders {
based_on: format!("the MSVC toolset {toolset}{sdk}"),
directories: found.include,
})
}
fn from_unix(runner: &impl CommandRunner) -> Option<SystemHeaders> {
let mut directories = Vec::new();
let mut based_on = Vec::new();
for conventional in ["/usr/local/include", "/usr/include"] {
let path = PathBuf::from(conventional);
if path.is_dir() {
directories.push(path);
based_on.push(conventional.to_string());
}
}
for cxx_root in cxx_header_roots() {
directories.extend(newest_versions(&cxx_root, MAX_VERSIONS));
based_on.push(cxx_root.display().to_string());
}
if let Some(sdk) = macos_sdk(runner) {
directories.push(sdk.clone());
based_on.push(sdk.display().to_string());
}
directories.dedup();
if directories.is_empty() {
return None;
}
Some(SystemHeaders {
directories,
based_on: based_on.join(", "),
})
}
fn cxx_header_roots() -> Vec<PathBuf> {
let mut roots = vec![PathBuf::from("/usr/include/c++")];
if let Ok(entries) = std::fs::read_dir("/usr/include") {
let mut triples: Vec<PathBuf> = entries
.flatten()
.filter(|entry| entry.file_type().is_ok_and(|kind| kind.is_dir()))
.map(|entry| entry.path().join("c++"))
.filter(|path| path.is_dir())
.collect();
triples.sort();
roots.extend(triples);
}
if let Ok(entries) = std::fs::read_dir("/usr/lib") {
let mut llvm: Vec<PathBuf> = entries
.flatten()
.filter_map(|entry| {
let name = entry.file_name().to_string_lossy().to_string();
name.starts_with("llvm")
.then(|| entry.path())?
.join("lib")
.join("clang")
.exists()
.then(|| entry.path().join("lib").join("clang"))
})
.collect();
llvm.sort();
for root in llvm {
if let Ok(versions) = std::fs::read_dir(&root) {
let mut versions: Vec<PathBuf> = versions
.flatten()
.map(|entry| entry.path().join("include"))
.filter(|path| path.is_dir())
.collect();
versions.sort();
roots.extend(versions);
}
}
}
roots
}
fn newest_versions(root: &Path, take: usize) -> Vec<PathBuf> {
let Ok(entries) = std::fs::read_dir(root) else {
return Vec::new();
};
let mut versions: Vec<PathBuf> = entries
.flatten()
.filter(|entry| entry.file_type().is_ok_and(|kind| kind.is_dir()))
.map(|entry| entry.path())
.filter(|path| {
path.file_name()
.and_then(|name| name.to_str())
.is_some_and(|name| {
name.chars()
.next()
.is_some_and(|first| first.is_ascii_digit())
})
})
.collect();
versions.sort_by_key(|path| {
std::cmp::Reverse(
path.file_name()
.and_then(|name| name.to_str())
.and_then(|name| name.parse::<u64>().ok())
.unwrap_or(0),
)
});
versions.truncate(take);
versions
}
fn macos_sdk(runner: &impl CommandRunner) -> Option<PathBuf> {
let output = runner.run(Path::new("xcrun"), &["--show-sdk-path"], &[])?;
if !output.succeeded {
return None;
}
let sdk = PathBuf::from(output.stdout.trim());
let include = sdk.join("usr").join("include");
include.is_dir().then_some(include)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_machine_without_a_conventional_layout_has_no_guess() {
let nowhere = WindowsLayout {
program_files: vec![PathBuf::from("/nowhere")],
windows_sdk_dir: None,
vc_tools_install_dir: None,
};
let runner = NoCommands;
if cfg!(windows) {
assert!(from_windows(&runner, &nowhere).is_none());
}
if !cfg!(windows) {
if let Some(found) = from_unix(&runner) {
for directory in &found.directories {
assert!(directory.is_dir(), "{}", directory.display());
}
assert!(!found.based_on.is_empty());
}
}
}
#[test]
fn only_versioned_directories_are_taken_and_the_newest_first() {
let root = std::env::temp_dir().join("cppls-system-headers");
let _ = std::fs::remove_dir_all(&root);
for version in ["9", "12", "13", "not-a-version"] {
std::fs::create_dir_all(root.join(version)).expect("the fixture directory");
}
let found = newest_versions(&root, 2);
let names: Vec<String> = found
.iter()
.map(|path| path.file_name().unwrap().to_string_lossy().to_string())
.collect();
assert_eq!(names, ["13", "12"], "newest first, and nothing else");
let _ = std::fs::remove_dir_all(&root);
}
struct NoCommands;
impl CommandRunner for NoCommands {
fn run(
&self,
_: &Path,
_: &[&str],
_: &[(std::ffi::OsString, std::ffi::OsString)],
) -> Option<super::super::toolchain::Output> {
None
}
}
}