Skip to main content

rust_meth_lib/
results_cache.rs

1//! Persistent cache for `query_methods` results.
2//!
3//! Stores `Vec<Method>` as JSON on disk, keyed by
4//! `(type_name, effective_deps, ra_version, lib_version)`. A cache hit
5//! returns results immediately with zero LSP cost — no rust-analyzer
6//! subprocess, no Cargo resolution, no probe directory needed.
7//!
8//! Cache entries are stored in `$XDG_CACHE_HOME/rust-meth/results/`
9//! (falling back to `~/.cache/rust-meth/results/`). The key includes
10//! the `rust-analyzer` version and `rust-meth-lib` version so upgrades
11//! automatically invalidate stale entries.
12
13use std::fs;
14use std::path::PathBuf;
15
16use crate::analyzer::Method;
17use crate::probe::cache_key_hash;
18
19// Directory
20
21/// Returns the root directory of the persistent results cache.
22///
23/// Respects `$XDG_CACHE_HOME` if set, otherwise falls back to `~/.cache`.
24/// The full path is `$XDG_CACHE_HOME/rust-meth/results/`.
25#[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// Entry
39
40/// Metadata and results for a single results cache entry.
41#[derive(Debug, Clone)]
42pub struct ResultsCacheEntry {
43    /// The Rust type that was queried.
44    pub type_name: String,
45    /// The effective TOML dependency string, if any.
46    pub deps: Option<String>,
47    /// The `rust-analyzer` version this entry was created with.
48    pub ra_version: String,
49    /// The `rust-meth-lib` version this entry was created with.
50    pub lib_version: String,
51    /// Number of methods stored in this entry.
52    pub method_count: usize,
53    /// Absolute path to the cache file on disk.
54    pub path: PathBuf,
55}
56
57/// Serialized form stored on disk.
58#[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// Public API
68
69/// Returns all entries currently in the persistent results cache.
70///
71/// Reads each `.json` file in [`results_cache_dir`]. Entries that are
72/// missing or malformed are silently skipped.
73#[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
100/// Removes all entries from the persistent results cache.
101///
102/// Deletes the entire [`results_cache_dir`] and its contents.
103///
104/// # Errors
105///
106/// Returns an error if the directory cannot be removed.
107pub 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/// Attempts to load cached methods for the given query parameters.
116///
117/// Returns `None` if no entry exists or if the file is malformed.
118#[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
135/// Saves method results to the persistent cache.
136///
137/// Failures are silent, a failed write doesn't affect the query result.
138pub 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}