Struct GraphCacheStore 

pub struct GraphCacheStore {
    pub version: u32,
    pub manifest: GraphCacheManifest,
    pub graph: ModuleGraph,
    pub resolved_project: CachedResolvedProject,
}

On-disk graph cache entry: a manifest plus the graph it validates.

Fields

version: u32

Schema version. Checked on load; a mismatch misses so a stale file from an older binary is never deserialized into the wrong shape.

manifest: GraphCacheManifest

Inputs that must match the current run for the graph to be trusted.

graph: ModuleGraph

The previously-built graph. Its namespace_imported bitset is #[serde(skip)], so the loader reconstructs it from the edge set.

resolved_project: CachedResolvedProject

Resolver output aligned with the cached graph. Exact manifest hits use it alongside the graph; stable-key resolver hits remap it and rebuild the graph with current FileIds.

Implementations

impl GraphCacheStore

pub fn load(cache_dir: &Path) -> Result<GraphCacheStore, CacheRejection>

Load the persisted graph cache from cache_dir.

Errors

Returns the CacheRejection that decided against reuse: the file is missing, undecodable, or written for a different GRAPH_CACHE_VERSION. The caller compares the loaded manifest against the current inputs before trusting the graph or resolver payload, and reports its own rejection reason for that comparison.

The version is read from the file header BEFORE the payload is decoded. A format bump changes the encoded shape, so a blob from the previous release fails to decode and a version comparison made afterwards is unreachable on the one event that triggers it most: an upgrade. fallow doctor reports this reason verbatim, so a routine version bump must not read as corruption, and a file that is not a fallow cache at all must not read as a version bump.

A file that existed and was then refused logs at warn: the run paid the read and the decode and reused nothing. A missing file stays quiet.

pub fn save(&self, cache_dir: &Path)

Persist this graph cache to cache_dir, best-effort.

Creates the cache directory, writes a .gitignore, encodes the store with postcard, and writes graph-cache.bin atomically. Every IO error is logged at debug and swallowed; the graph cache must never fail the surrounding analysis run.

Trait Implementations

impl<'de> Deserialize<'de> for GraphCacheStore

fn deserialize<__D>( __deserializer: __D, ) -> Result<GraphCacheStore, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for GraphCacheStore

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.