Struct DefPathToIndexMap 

pub struct DefPathToIndexMap {
    pub before_parallel_alloc: DefPathHashMap,
    pub after_parallel_alloc: Option<SortedMap<Hash64, DefIndex>>,
}

Fields

before_parallel_alloc: DefPathHashMap

Stores mapping from local hash to def indices which are allocated when the order of their allocation is deterministic (see where commit_end_of_determinism is called, at the moment of writing it is after prefetch of hir_crate_items in run_required_analysis).

after_parallel_alloc: Option<SortedMap<Hash64, DefIndex>>

Stores the same mapping as previous map but is used after the allocation order of def indices is not deterministic, so when serializing metadata we have a ready to use sorted by stable local hash (which does not change between compiler invocations) mapping. We use it for relatively small number of definitions, so the majority of them would be stored in DefPathHashMap, which makes insertion and serialization costs of SortedMap acceptable.

Implementations

impl DefPathToIndexMap

pub fn get(&self, hash: Hash64) -> Option<DefIndex>

pub fn insert(&mut self, hash: Hash64, index: DefIndex) -> Option<DefIndex>

This insert function does not behave like regular insert of a HashMap, as the return value is used only for printing information about existing def index for local hash before panicking. So we can do not actually insert def index into det_part when we are in non-deterministic mode.

Trait Implementations

impl Debug for DefPathToIndexMap

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

Formats the value using the given formatter.

impl Default for DefPathToIndexMap

fn default() -> Self

Returns the “default value” for a type.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 40 bytes