Struct BindingResolver 

struct BindingResolver<'a, 'g, 'n> {

    store: &'a AtlasStore,
    project: ProjectInstanceId,
    generation: IndexGeneration,
    base_generation: Option<IndexGeneration>,
    graphs: BTreeMap<&'g str, (&'g SymbolGraph, Option<&'g SourceSemanticFacts>)>,
    entities: &'g EntityProjection,
    packages: &'a PackageIndex,
    configured: &'a ConfiguredModuleResolution,
    sources: &'a mut SourceBindingCache<'n>,
    candidates: &'a mut ProjectResolutionRegistry,
    replaced: &'a BTreeSet<String>,
    loaded: Option<BTreeSet<CanonicalResolutionKey>>,
    context: BTreeMap<String, Arc<BindingSource<'g>>>,
    hydrated: BTreeMap<String, Option<GraphEntity>>,
    modules: ModuleInterner,
    queries: BTreeMap<BindingQuery, BTreeMap<usize, Arc<CallBindingResolution>>>,
    retained_bytes: u64,
    retained_limit: u64,
    control: &'a IndexWorkControl,
}

One operation’s source/query caches and existing repository resolution registry.

Fields

store: &'a AtlasStore

Existing read authority; no source parsing occurs inside a writer transaction.

project: ProjectInstanceId

Selected project and pending generation.

generation: IndexGeneration

Pending publication generation.

base_generation: Option<IndexGeneration>

Exact graph entity generation available before this publication.

graphs: BTreeMap<&'g str, (&'g SymbolGraph, Option<&'g SourceSemanticFacts>)>

Current source graphs paired with their own parser evidence.

entities: &'g EntityProjection

Existing admitted entities and projection keys.

packages: &'a PackageIndex

Existing package and configured-module owners.

configured: &'a ConfiguredModuleResolution

One validated configuration snapshot shared with ordinary resolution.

sources: &'a mut SourceBindingCache<'n>

Existing hash-checked, accounted source recovery owner.

candidates: &'a mut ProjectResolutionRegistry

Existing candidate lookup owner, extended only for explicitly requested keys.

replaced: &'a BTreeSet<String>

Paths replaced by the pending publication must not re-enter through old rows.

loaded: Option<BTreeSet<CanonicalResolutionKey>>

Complete candidate keys already fetched in an incremental operation.

context: BTreeMap<String, Arc<BindingSource<'g>>>

Captured source views, including borrowed fresh evidence.

hydrated: BTreeMap<String, Option<GraphEntity>>

Exact target hydration cached by stable identity, including absent owners.

modules: ModuleInterner

Canonical IDs and retained allocation witnesses for this resolver only.

queries: BTreeMap<BindingQuery, BTreeMap<usize, Arc<CallBindingResolution>>>

Finished outcomes shared by repeated identical binding queries.

retained_bytes: u64

Conservative bytes owned by this resolver’s additional indexes and outcomes.

retained_limit: u64

Existing staging ceiling, injectable per owner for deterministic boundary tests.

control: &'a IndexWorkControl

Shared indexing deadline, cancellation and work budget.

Implementations

impl<'g> BindingResolver<'_, 'g, '_>

fn query( &mut self, source: &str, reference: &ImportReference, member: Option<&str>, ) -> Result<BindingQuery, CliError>

Bind every query to this resolver’s IDs and reserve retained metadata atomically.

fn check_budget(&self) -> Result<(), CliError>

Include every simultaneously live owner in the staging memory boundary.

fn retained_staging_bytes(&self) -> u64

Sum accounted owners without changing their reservation state.

fn reserve_scratch(&mut self, bytes: u64) -> Result<(), CliError>

Admit a temporary owner before allocating, retaining prior accounting on refusal.

fn release_scratch(&mut self, bytes: u64) -> Result<(), CliError>

Release exactly one admitted temporary owner without erasing persistent state.

fn with_scratch<T>( &mut self, operation: impl FnOnce(&mut Self, &mut ResolverScratch) -> Result<(T, u64), CliError>, ) -> Result<T, CliError>

Release temporary construction on every exit and retain the completed owner once.

fn insert_cause( &mut self, causes: &mut CauseWorkspace<'_>, key: &CanonicalResolutionKey, ) -> Result<(), CliError>

Retain only a new key, checking both row and byte admission before cloning.

fn source(&mut self, path: &str) -> Result<Arc<BindingSource<'g>>, CliError>

Load one explicitly needed source, reusing fresh facts and captured bytes.

fn module_file( &mut self, keys: &[CanonicalResolutionKey], ) -> Result<Option<String>, CliError>

Fetch each additional canonical lookup once under the existing bounded API.

fn resolve( &mut self, query: BindingQuery, visited: &mut BTreeMap<BindingQuery, usize>, depth: usize, ) -> Result<Arc<CallBindingResolution>, CliError>

Follow explicit module slots; a cycle, ambiguity or unsupported value abstains.

fn target( &mut self, source: &BindingSource<'_>, index: usize, ) -> Result<Option<GraphEntity>, CliError>

Hydrate the exact existing canonical declaration selected by admitted source ordinals.