Struct rustc_query_impl::on_disk_cache::OnDiskCache

pub struct OnDiskCache<'sess> {

    serialized_data: Vec<u8>,
    current_side_effects: Lock<FxHashMap<DepNodeIndex, QuerySideEffects>>,
    cnum_map: OnceCell<UnhashMap<StableCrateId, CrateNum>>,
    source_map: &'sess SourceMap,
    file_index_to_stable_id: FxHashMap<SourceFileIndex, EncodedSourceFileId>,
    file_index_to_file: Lock<FxHashMap<SourceFileIndex, Lrc<SourceFile>>>,
    query_result_index: FxHashMap<SerializedDepNodeIndex, AbsoluteBytePos>,
    prev_side_effects_index: FxHashMap<SerializedDepNodeIndex, AbsoluteBytePos>,
    alloc_decoding_state: AllocDecodingState,
    syntax_contexts: FxHashMap<u32, AbsoluteBytePos>,
    expn_data: UnhashMap<ExpnHash, AbsoluteBytePos>,
    hygiene_context: HygieneDecodeContext,
    foreign_def_path_hashes: UnhashMap<DefPathHash, RawDefId>,
    foreign_expn_data: UnhashMap<ExpnHash, u32>,
    latest_foreign_def_path_hashes: Lock<UnhashMap<DefPathHash, RawDefId>>,
    def_path_hash_to_def_id_cache: Lock<UnhashMap<DefPathHash, Option<DefId>>>,
}

Provides an interface to incremental compilation data cached from the previous compilation session. This data will eventually include the results of a few selected queries (like typeck and mir_optimized) and any side effects that have been emitted during a query.

Fields

serialized_data: Vec<u8>

current_side_effects: Lock<FxHashMap<DepNodeIndex, QuerySideEffects>>

cnum_map: OnceCell<UnhashMap<StableCrateId, CrateNum>>

source_map: &'sess SourceMap

file_index_to_stable_id: FxHashMap<SourceFileIndex, EncodedSourceFileId>

file_index_to_file: Lock<FxHashMap<SourceFileIndex, Lrc<SourceFile>>>

query_result_index: FxHashMap<SerializedDepNodeIndex, AbsoluteBytePos>

prev_side_effects_index: FxHashMap<SerializedDepNodeIndex, AbsoluteBytePos>

alloc_decoding_state: AllocDecodingState

syntax_contexts: FxHashMap<u32, AbsoluteBytePos>

expn_data: UnhashMap<ExpnHash, AbsoluteBytePos>

hygiene_context: HygieneDecodeContext

foreign_def_path_hashes: UnhashMap<DefPathHash, RawDefId>

foreign_expn_data: UnhashMap<ExpnHash, u32>

latest_foreign_def_path_hashes: Lock<UnhashMap<DefPathHash, RawDefId>>

def_path_hash_to_def_id_cache: Lock<UnhashMap<DefPathHash, Option<DefId>>>

Implementations

impl<'sess> OnDiskCache<'sess>

pub fn as_dyn(&self) -> &dyn OnDiskCache<'sess>

pub fn load_side_effects(
    &self,
    tcx: TyCtxt<'_>,
    dep_node_index: SerializedDepNodeIndex
) -> QuerySideEffects

Loads a QuerySideEffects created during the previous compilation session.

pub fn store_side_effects(
    &self,
    dep_node_index: DepNodeIndex,
    side_effects: QuerySideEffects
)

Stores a QuerySideEffects emitted during the current compilation session. Anything stored like this will be available via load_side_effects in the next compilation session.

fn get_raw_def_id(&self, hash: &DefPathHash) -> Option<RawDefId>

fn try_remap_cnum(
    &self,
    tcx: TyCtxt<'_>,
    stable_crate_id: StableCrateId
) -> Option<CrateNum>

pub fn try_load_query_result<'tcx, T>(
    &self,
    tcx: TyCtxt<'tcx>,
    dep_node_index: SerializedDepNodeIndex
) -> Option<T> where
    T: for<'a> Decodable<CacheDecoder<'a, 'tcx>>, 

Returns the cached query result if there is something in the cache for the given SerializedDepNodeIndex; otherwise returns None.

pub fn store_side_effects_for_anon_node(
    &self,
    dep_node_index: DepNodeIndex,
    side_effects: QuerySideEffects
)

Stores side effect emitted during computation of an anonymous query. Since many anonymous queries can share the same DepNode, we aggregate them – as opposed to regular queries where we assume that there is a 1:1 relationship between query-key and DepNode.

fn load_indexed<'tcx, T>(
    &self,
    tcx: TyCtxt<'tcx>,
    dep_node_index: SerializedDepNodeIndex,
    index: &FxHashMap<SerializedDepNodeIndex, AbsoluteBytePos>,
    debug_tag: &'static str
) -> Option<T> where
    T: for<'a> Decodable<CacheDecoder<'a, 'tcx>>, 

fn with_decoder<'a, 'tcx, T, F: FnOnce(&mut CacheDecoder<'sess, 'tcx>) -> T>(
    &'sess self,
    tcx: TyCtxt<'tcx>,
    pos: AbsoluteBytePos,
    f: F
) -> T where
    T: Decodable<CacheDecoder<'a, 'tcx>>, 

fn compute_cnum_map(tcx: TyCtxt<'_>) -> UnhashMap<StableCrateId, CrateNum>

Trait Implementations

impl<'sess> OnDiskCache<'sess> for OnDiskCache<'sess>

fn new(sess: &'sess Session, data: Vec<u8>, start_pos: usize) -> Self

Creates a new OnDiskCache instance from the serialized data in data.

fn new_empty(source_map: &'sess SourceMap) -> Self

fn serialize(
    &self,
    tcx: TyCtxt<'sess>,
    encoder: &mut FileEncoder
) -> FileEncodeResult

fn def_path_hash_to_def_id<'tcx>(
    &self,
    tcx: TyCtxt<'tcx>,
    hash: DefPathHash
) -> Option<DefId>

Converts a DefPathHash to its corresponding DefId in the current compilation session, if it still exists. This is used during incremental compilation to turn a deserialized DefPathHash into its current DefId.

fn register_reused_dep_node(&self, tcx: TyCtxt<'sess>, dep_node: &DepNode)

If the given dep_node’s hash still exists in the current compilation, and its current DefId is foreign, calls store_foreign_def_id with it.

fn store_foreign_def_id_hash(&self, def_id: DefId, hash: DefPathHash)

Layout

Note: Most layout information is completely unstable and may be different between compiler versions and platforms. 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: 528 bytes