Struct rustc_middle::ty::query::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,
}

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

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, E>(
    &self,
    tcx: TyCtxt<'tcx>,
    encoder: &mut E
) -> Result<(), E::Error> where
    E: OpaqueEncoder, 

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.

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

pub(in ty::query::on_disk_cache) 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>>, 

pub(in ty::query::on_disk_cache) 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>>, 

pub(in ty::query::on_disk_cache) fn compute_cnum_map(
    tcx: TyCtxt<'_>,
    prev_cnums: &[(u32, String, CrateDisambiguator)]
) -> IndexVec<CrateNum, Option<CrateNum>>