Struct DepGraph 

pub struct DepGraph { /* private fields */ }

Implementations

impl DepGraph

pub fn new() -> Self

Create a new empty dependency graph.

pub fn cached_normalize_key_path( &self, path: &Path, key_root: Option<&Path>, ) -> Arc<str>

Cached version of crate::depgraph::context::normalize_key_path.

Looks up (path, key_root) in path_key_cache. On hit, returns the cached Arc<str> without re-running the underlying normalization. On miss, computes via normalize_key_path and inserts (subject to the PATH_KEY_CACHE_MAX_ENTRIES cap — past the cap, the result is returned without caching so memory stays bounded).

Issue #550 — the compute_artifact_key hot loop’s per-header allocation hotspot.

pub fn register(&self, ctx: CompileContext) -> ContextKey

Register a compilation context. Returns the context key. If the context already exists, returns the existing key.

pub fn register_with_root_and_salt( &self, ctx: CompileContext, key_root: Option<NormalizedPath>, worktree_salt: Option<&Path>, ) -> ContextKey

Register a compilation context with an optional key root used to normalize project-local paths across workspace renames. Variant of Self::register_with_root that folds an optional worktree_salt into the context key (issue #474). Used by the multi-file compile path when keys::requires_worktree_in_key is true for the unit. Returns only the resulting ContextKey.

pub fn register_with_root( &self, ctx: CompileContext, key_root: Option<NormalizedPath>, ) -> ContextKey

pub fn register_with_root_result( &self, ctx: CompileContext, key_root: Option<NormalizedPath>, ) -> ContextRegistration

pub fn register_with_root_and_salt_result( &self, ctx: CompileContext, key_root: Option<NormalizedPath>, worktree_salt: Option<&Path>, ) -> ContextRegistration

Issue #474: variant of Self::register_with_root_result that folds an optional worktree_salt into the context key. Used by the C/C++ compile pipeline when keys::requires_worktree_in_key returns true (PCH builds + MSVC), so the resulting cache entry is scoped to one worktree and can’t be served to a sibling clone whose embedded paths would diverge from the artifact’s.

pub fn register_with_key( &self, key: ContextKey, ctx: CompileContext, ) -> ContextKey

Register a compilation context with a precomputed key.

Used for Rustc compilations where the context key is computed from RustcCompileContext (different domain tag) but the dep_graph stores a CompileContext with the source file path for freshness checks.

pub fn register_with_key_and_root( &self, key: ContextKey, ctx: CompileContext, key_root: Option<NormalizedPath>, ) -> ContextKey

pub fn register_with_key_and_root_result( &self, key: ContextKey, ctx: CompileContext, key_root: Option<NormalizedPath>, ) -> ContextRegistration

pub fn register_rustc_with_key_and_root_result( &self, key: ContextKey, ctx: CompileContext, key_root: Option<NormalizedPath>, externs: Vec<(String, NormalizedPath)>, ) -> ContextRegistration

Register a rustc context with its current --extern file inputs.

Rustc context keys already reduce extern path prefixes to filename identity. The dependency graph keeps the actual extern paths here only for hashing/freshness; artifact keys incorporate them by crate name.

pub fn is_cold(&self, key: &ContextKey) -> bool

Returns true if the context has never been updated (no artifact key). Used by the server to skip pre-compile hashing on cold contexts where check_diagnostic would return Cold without examining any hashes.

pub fn check<F, G>( &self, key: &ContextKey, is_fresh: F, get_hash: G, ) -> CacheVerdict

where F: Fn(&Path) -> bool, G: Fn(&Path) -> Option<ContentHash>,

Check if a compilation can use cached output.

is_fresh is called for each file path. It should query Layer 1 (fscache) and return true if the file has not changed since last known state.

get_hash retrieves the content hash for a file from Layer 1.

pub fn check_diagnostic<F, G>( &self, key: &ContextKey, is_fresh: F, get_hash: G, ) -> (CacheVerdict, String)

where F: Fn(&Path) -> bool, G: Fn(&Path) -> Option<ContentHash>,

Check if a compilation can use cached output, with diagnostic reason.

Same logic as check() but returns a reason string explaining why the verdict was reached (useful for session logs).

pub fn try_fast_hit<G>( &self, key: &ContextKey, get_hash: G, ) -> Option<ArtifactKey>

where G: Fn(&Path) -> Option<ContentHash>,

Fast-path artifact key check: recompute the key from caller-provided hashes and compare against the stored key. Returns Some(key) when they match (common cache-hit case), None otherwise.

Compared to check_diagnostic, this method:

• Uses a shared DashMap read (no write lock)
• Skips redundant per-file journal freshness checks (caller already stat-verified every file during the hash phase)
• Avoids NormalizedPath clones by working with references into the entry

Call this after hashing and before check_diagnostic. On None, fall back to the full check_diagnostic for miss-reason diagnostics.

pub fn update<G>( &self, key: &ContextKey, scan_result: ScanResult, get_hash: G, ) -> Option<ArtifactKey>

where G: Fn(&Path) -> Option<ContentHash>,

After a compile (or on cold path), record the full include list.

get_hash retrieves the content hash for a file from Layer 1.

pub fn invalidate_artifact_keys(&self, evicted_hex: &HashSet<String>) -> usize

Clear artifact_key on every context whose currently-recorded artifact key is in evicted_hex. Returns the number of contexts whose key was cleared.

Issue #680 — eviction-divergence fix. When the disk artifact GC (evict_disk_artifacts) removes an artifact, the depgraph contexts that point at the now-evicted key still report CacheVerdict::Hit { artifact_key } on their next check, which then surfaces in the daemon log as artifact_not_found and a wasted recompile (the user observed a 15.7% real hit rate on a soldr dogfood rebuild that should have been ~99%). Wiring the disk GC to call this method after each eviction batch keeps the two stores in agreement: the next check on an evicted context returns Cold (forcing a clean miss + re-store) instead of a stale Hit.

Key comparison uses the hex form (ArtifactKey::hash().to_hex()) so callers — which already have the evicted artifacts’ string keys from the disk eviction pass — do not have to round-trip through ArtifactKey construction.

last_accessed is intentionally NOT bumped — this is a passive invalidation, and resetting access time would extend the context’s trim() lifetime past its disk-evicted artifact.

pub fn trim(&self, max_age: Duration) -> usize

Trim entries not accessed within the given duration. Returns the number of entries removed.

pub fn clear(&self)

Clear all graph state: files, contexts, and stats counters.

pub fn stats(&self) -> DepGraphStats

Get statistics about the graph.

pub fn get_state(&self, key: &ContextKey) -> Option<ContextState>

Get the state of a context entry.

pub fn state_breakdown(&self) -> (usize, usize, usize)

Count contexts by state. Returned as (cold, warm, stale).

Used by the daemon’s depgraph save / load logging to diagnose post-save / post-load state distribution — specifically to find out whether contexts are getting persisted as Warm (so is_cold returns false after restore, enabling the cache lookup path) or as Cold (so every warm-side compile takes the cold_skip branch and misses regardless of artifact-store state).

pub fn contexts_with_artifact_key(&self) -> usize

Number of contexts whose artifact_key is set. Combined with state_breakdown() this distinguishes contexts that have a computed key (a successful prior compile) from contexts that were registered but never reached a Warm state.

pub fn get_includes(&self, key: &ContextKey) -> Option<Vec<NormalizedPath>>

Get the resolved includes for a context.

pub fn get_rustc_externs( &self, key: &ContextKey, ) -> Option<Vec<(String, NormalizedPath)>>

Get rustc extern input paths for a context.

pub fn store_file_includes( &self, path: NormalizedPath, includes: Vec<IncludeDirective>, )

Store scanned includes for a file (shared file node).

pub fn get_file_includes( &self, path: &NormalizedPath, ) -> Option<Vec<IncludeDirective>>

Get scanned includes for a file.

pub fn mark_stale(&self, key: &ContextKey) -> bool

Mark a context as stale, requiring rescan on next check. Returns true if the context existed and was marked stale.

pub fn ingest_compile_commands( &self, commands: &[CompileCommand], system_includes: &[NormalizedPath], ) -> Vec<ContextKey>

Bulk-populate contexts from parsed compile commands.

For each command, parses the arguments, builds a CompileContext (merging in the provided system include paths), and registers it. Returns the context keys for all successfully registered entries.

impl DepGraph

pub fn to_snapshot(&self) -> DepGraphSnapshot

Create a serializable snapshot of the current graph state.

pub fn from_snapshot(snap: DepGraphSnapshot) -> Self

Reconstruct a DepGraph from a deserialized snapshot.

impl DepGraph

pub fn watch_set(&self) -> WatchSet

Compute the set of directories that should be watched.

Includes:

• Parent directories of all resolved include paths (to detect modifications)
• Parent directories of source files (to detect source changes)
• All include search directories from all contexts (to detect new files)

pub fn check_shadow(&self, new_file: &Path) -> Vec<ContextKey>

Check if a newly created file shadows any existing resolved include in any context. Returns context keys that should be marked stale.

A shadow occurs when new_file has the same filename as an existing resolved include, and new_file’s directory appears earlier (higher priority) in that context’s include search path.

pub fn check_new_resolve(&self, new_file: &Path) -> Vec<ContextKey>

Check if a newly created file resolves any previously unresolved #include in any context. Returns affected context keys.

Trait Implementations

impl Debug for DepGraph

The core dependency graph.

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

Formats the value using the given formatter.

impl Default for DepGraph

fn default() -> Self

Returns the “default value” for a type.