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

pub struct OnDiskCache<'sess> {
    serialized_data: Vec<u8>,
    current_diagnostics: Lock<FxHashMap<DepNodeIndex, Vec<Diagnostic>>>,
    prev_cnums: Vec<(u32, String, CrateDisambiguator)>,
    cnum_map: OnceCell<IndexVec<CrateNum, Option<CrateNum>>>,
    source_map: &'sess SourceMap,
    file_index_to_stable_id: FxHashMap<SourceFileIndex, StableSourceFileId>,
    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>>,
    local_def_path_hash_to_def_id: UnhashMap<DefPathHash, LocalDefId>,
    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>>>

prev_cnums: Vec<(u32, String, CrateDisambiguator)>

cnum_map: OnceCell<IndexVec<CrateNum, Option<CrateNum>>>

source_map: &'sess SourceMap

file_index_to_stable_id: FxHashMap<SourceFileIndex, StableSourceFileId>

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>>

local_def_path_hash_to_def_id: UnhashMap<DefPathHash, LocalDefId>

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,
    definitions: &Definitions
) -> 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<'_>, cnum: u32) -> 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<'_>,
    prev_cnums: &[(u32, String, CrateDisambiguator)]
) -> IndexVec<CrateNum, Option<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.