Struct rustc_middle::ty::query::on_disk_cache::OnDiskCache

pub struct OnDiskCache<'sess> {

    serialized_data: Vec<u8>,
    current_diagnostics: Lock<FxHashMap<DepNodeIndex, Vec<Diagnostic>>>,
    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_diagnostics_index: FxHashMap<SerializedDepNodeIndex, AbsoluteBytePos>,
    alloc_decoding_state: AllocDecodingState,
    syntax_contexts: FxHashMap<u32, AbsoluteBytePos>,
    expn_data: FxHashMap<u32, AbsoluteBytePos>,
    hygiene_context: HygieneDecodeContext,
    foreign_def_path_hashes: UnhashMap<DefPathHash, RawDefId>,
    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 diagnostics that have been emitted during a query.

Fields

serialized_data: Vec<u8>

current_diagnostics: Lock<FxHashMap<DepNodeIndex, Vec<Diagnostic>>>

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_diagnostics_index: FxHashMap<SerializedDepNodeIndex, AbsoluteBytePos>

alloc_decoding_state: AllocDecodingState

syntax_contexts: FxHashMap<u32, AbsoluteBytePos>

expn_data: FxHashMap<u32, AbsoluteBytePos>

hygiene_context: HygieneDecodeContext

foreign_def_path_hashes: UnhashMap<DefPathHash, RawDefId>

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 new(sess: &'sess Session, data: Vec<u8>, start_pos: usize) -> Self

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

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

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

pub fn load_diagnostics(
    &self,
    tcx: TyCtxt<'_>,
    dep_node_index: SerializedDepNodeIndex
) -> Vec<Diagnostic>

Loads a diagnostic emitted during the previous compilation session.

pub fn store_diagnostics(
    &self,
    dep_node_index: DepNodeIndex,
    diagnostics: ThinVec<Diagnostic>
)

Stores a diagnostic emitted during the current compilation session. Anything stored like this will be available via load_diagnostics 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(crate) fn store_foreign_def_id_hash(&self, def_id: DefId, hash: DefPathHash)

pub fn register_reused_dep_node<'tcx>(
    &self,
    tcx: TyCtxt<'tcx>,
    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.

Normally, store_foreign_def_id_hash can be called directly by the dependency graph when we construct a DepNode. However, when we re-use a deserialized DepNode from the previous compilation session, we only have the DefPathHash available. This method is used to that any DepNode that we re-use has a DefPathHash -> RawId written out for usage in the next compilation session.

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_diagnostics_for_anon_node(
    &self,
    dep_node_index: DepNodeIndex,
    diagnostics: ThinVec<Diagnostic>
)

Stores a diagnostic 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>

pub(crate) 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.

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