use std::fs;
use std::path::PathBuf;
use crate::analyzer::Method;
use crate::probe::cache_key_hash;
#[must_use]
pub fn results_cache_dir() -> PathBuf {
let base = std::env::var_os("XDG_CACHE_HOME").map_or_else(
|| {
std::env::var_os("HOME")
.map_or_else(std::env::temp_dir, PathBuf::from)
.join(".cache")
},
PathBuf::from,
);
base.join("rust-meth").join("results")
}
#[derive(Debug, Clone)]
pub struct ResultsCacheEntry {
pub type_name: String,
pub deps: Option<String>,
pub ra_version: String,
pub lib_version: String,
pub method_count: usize,
pub path: PathBuf,
}
#[derive(serde::Serialize, serde::Deserialize)]
struct ResultsFile {
type_name: String,
effective_deps: Option<String>,
ra_version: String,
lib_version: String,
methods: Vec<Method>,
}
#[must_use]
pub fn results_cache_entries() -> Vec<ResultsCacheEntry> {
let dir = results_cache_dir();
let Ok(read_dir) = fs::read_dir(&dir) else {
return Vec::new();
};
read_dir
.filter_map(|entry| {
let entry = entry.ok()?;
let path = entry.path();
if path.extension()?.to_str()? != "json" {
return None;
}
let bytes = fs::read(&path).ok()?;
let file: ResultsFile = serde_json::from_slice(&bytes).ok()?;
Some(ResultsCacheEntry {
type_name: file.type_name,
deps: file.effective_deps,
ra_version: file.ra_version,
lib_version: file.lib_version,
method_count: file.methods.len(),
path,
})
})
.collect()
}
pub fn clear_results_cache() -> std::io::Result<()> {
let dir = results_cache_dir();
if dir.exists() {
fs::remove_dir_all(&dir)?;
}
Ok(())
}
#[must_use]
pub fn load_results(
type_name: &str,
effective_deps: Option<&str>,
ra_version: &str,
) -> Option<Vec<Method>> {
let path = entry_path(type_name, effective_deps, ra_version);
let bytes = fs::read(&path).ok()?;
let file: ResultsFile = serde_json::from_slice(&bytes).ok()?;
if std::env::var("RUST_METH_DEBUG").is_ok() {
eprintln!("[debug] results cache hit: {}", path.display());
}
Some(file.methods)
}
pub fn save_results(
type_name: &str,
effective_deps: Option<&str>,
ra_version: &str,
methods: &[Method],
) {
let save = || -> std::io::Result<()> {
let dir = results_cache_dir();
fs::create_dir_all(&dir)?;
let file = ResultsFile {
type_name: type_name.to_string(),
effective_deps: effective_deps.map(str::to_owned),
ra_version: ra_version.to_string(),
lib_version: env!("CARGO_PKG_VERSION").to_string(),
methods: methods.to_vec(),
};
let path = entry_path(type_name, effective_deps, ra_version);
fs::write(path, serde_json::to_vec_pretty(&file)?)?;
Ok(())
};
if let Err(e) = save()
&& std::env::var("RUST_METH_DEBUG").is_ok()
{
eprintln!("[debug] failed to save results cache: {e}");
}
}
fn entry_path(type_name: &str, effective_deps: Option<&str>, ra_version: &str) -> PathBuf {
let hash = cache_key_hash(type_name, effective_deps, None, ra_version);
results_cache_dir().join(format!("{hash}.json"))
}