rust_meth_lib/
results_cache.rs1use std::fs;
14use std::path::PathBuf;
15
16use crate::analyzer::Method;
17use crate::probe::cache_key_hash;
18
19#[must_use]
26pub fn results_cache_dir() -> PathBuf {
27 let base = std::env::var_os("XDG_CACHE_HOME").map_or_else(
28 || {
29 std::env::var_os("HOME")
30 .map_or_else(std::env::temp_dir, PathBuf::from)
31 .join(".cache")
32 },
33 PathBuf::from,
34 );
35 base.join("rust-meth").join("results")
36}
37
38#[derive(Debug, Clone)]
42pub struct ResultsCacheEntry {
43 pub type_name: String,
45 pub deps: Option<String>,
47 pub ra_version: String,
49 pub lib_version: String,
51 pub method_count: usize,
53 pub path: PathBuf,
55}
56
57#[derive(serde::Serialize, serde::Deserialize)]
59struct ResultsFile {
60 type_name: String,
61 effective_deps: Option<String>,
62 ra_version: String,
63 lib_version: String,
64 methods: Vec<Method>,
65}
66
67#[must_use]
74pub fn results_cache_entries() -> Vec<ResultsCacheEntry> {
75 let dir = results_cache_dir();
76 let Ok(read_dir) = fs::read_dir(&dir) else {
77 return Vec::new();
78 };
79 read_dir
80 .filter_map(|entry| {
81 let entry = entry.ok()?;
82 let path = entry.path();
83 if path.extension()?.to_str()? != "json" {
84 return None;
85 }
86 let bytes = fs::read(&path).ok()?;
87 let file: ResultsFile = serde_json::from_slice(&bytes).ok()?;
88 Some(ResultsCacheEntry {
89 type_name: file.type_name,
90 deps: file.effective_deps,
91 ra_version: file.ra_version,
92 lib_version: file.lib_version,
93 method_count: file.methods.len(),
94 path,
95 })
96 })
97 .collect()
98}
99
100pub fn clear_results_cache() -> std::io::Result<()> {
108 let dir = results_cache_dir();
109 if dir.exists() {
110 fs::remove_dir_all(&dir)?;
111 }
112 Ok(())
113}
114
115#[must_use]
119pub fn load_results(
120 type_name: &str,
121 effective_deps: Option<&str>,
122 ra_version: &str,
123) -> Option<Vec<Method>> {
124 let path = entry_path(type_name, effective_deps, ra_version);
125 let bytes = fs::read(&path).ok()?;
126 let file: ResultsFile = serde_json::from_slice(&bytes).ok()?;
127
128 if std::env::var("RUST_METH_DEBUG").is_ok() {
129 eprintln!("[debug] results cache hit: {}", path.display());
130 }
131
132 Some(file.methods)
133}
134
135pub fn save_results(
139 type_name: &str,
140 effective_deps: Option<&str>,
141 ra_version: &str,
142 methods: &[Method],
143) {
144 let save = || -> std::io::Result<()> {
145 let dir = results_cache_dir();
146 fs::create_dir_all(&dir)?;
147 let file = ResultsFile {
148 type_name: type_name.to_string(),
149 effective_deps: effective_deps.map(str::to_owned),
150 ra_version: ra_version.to_string(),
151 lib_version: env!("CARGO_PKG_VERSION").to_string(),
152 methods: methods.to_vec(),
153 };
154 let path = entry_path(type_name, effective_deps, ra_version);
155 fs::write(path, serde_json::to_vec_pretty(&file)?)?;
156 Ok(())
157 };
158
159 if let Err(e) = save()
160 && std::env::var("RUST_METH_DEBUG").is_ok()
161 {
162 eprintln!("[debug] failed to save results cache: {e}");
163 }
164}
165
166fn entry_path(type_name: &str, effective_deps: Option<&str>, ra_version: &str) -> PathBuf {
167 let hash = cache_key_hash(type_name, effective_deps, None, ra_version);
168 results_cache_dir().join(format!("{hash}.json"))
169}