Struct WorkspaceCache 

pub struct WorkspaceCache { /* private fields */ }

Handle to the cache directory for a single workspace. Construction is cheap (creates directories on demand); the same handle can be shared across threads via Arc — it holds no mutable state.

Implementations

impl WorkspaceCache

pub fn new(root: &Path) -> Option<Self>

Create (or re-open) the cache directory for a workspace rooted at root. Returns None when the system has no usable home/cache directory — callers should treat that as “cache disabled” and proceed without persistence.

If the existing cache directory exceeds CACHE_SIZE_CAP, it is cleared before the handle is returned. That’s a coarse knob — K3 could refine to LRU-by-mtime — but crossing 512 MiB at startup indicates the workspace itself has more files than the cap fits, and the rebuild cost is bounded to one full re-scan.

pub fn cache_dir(&self) -> &Path

The filesystem path of this workspace’s cache directory.

pub fn size_bytes(&self) -> Result<u64>

Total bytes consumed by this workspace’s cache directory, including nested subdirectories — mir’s AnalysisCache lives under a session/ subdirectory of this one (see set_session_cache_dir), so the layout isn’t flat even though this directory’s own entries are.

pub fn with_dir(dir: PathBuf) -> Self

Override the root directory directly. The directory is used verbatim (no schema / workspace subdirectories are appended). Use for tests or when the caller provides an explicit cachePath initializationOption.

pub fn key_for(uri: &str, content: &str) -> CacheKey

Build a cache key for (uri, content). The filename half (uri_hash) stays fixed across edits to the same URI so a re-index overwrites its existing slot; the validation half (content_hash) changes on every edit so a read against stale content misses.

pub fn read<T: DeserializeOwned>(&self, key: &CacheKey) -> Option<T>

Deserialize a previously-cached value. Returns None on any I/O or decode failure, or when the entry’s stored content hash no longer matches key (the slot holds a stale revision) — all of which should look identical to a missing entry so callers fall through to the recompute path.

pub fn write<T: Serialize>(&self, key: &CacheKey, value: &T) -> Result<()>

Atomically publish an entry to the cache. Writes to a sibling temp file then renames, so readers never see a half-written payload even if the process dies mid-write. Because the filename is keyed on URI alone, this overwrites whatever revision (if any) previously occupied the slot rather than leaving it behind.

No fsync: the cache is advisory-only — a crash that loses a write just produces a cache miss on the next startup, which safely falls back to re-parsing. Skipping sync_all() avoids 5–15 ms per file on macOS, which on a 1,500-file project accounts for most of the cold indexing time.

pub fn clear(&self) -> Result<()>

Drop every entry in this workspace’s cache. Safe to call while other threads are reading — individual read calls that race with a clear will see None rather than garbage, and the next write recreates the entry.

Trait Implementations

impl Clone for WorkspaceCache

fn clone(&self) -> WorkspaceCache

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for WorkspaceCache

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.