Struct rustc_middle::ty::query::on_disk_cache::CacheDecoder

pub(crate) struct CacheDecoder<'a, 'tcx> {
    tcx: TyCtxt<'tcx>,
    opaque: Decoder<'a>,
    source_map: &'a SourceMap,
    cnum_map: &'a IndexVec<CrateNum, Option<CrateNum>>,
    file_index_to_file: &'a Lock<FxHashMap<SourceFileIndex, Lrc<SourceFile>>>,
    file_index_to_stable_id: &'a FxHashMap<SourceFileIndex, StableSourceFileId>,
    alloc_decoding_session: AllocDecodingSession<'a>,
    syntax_contexts: &'a FxHashMap<u32, AbsoluteBytePos>,
    expn_data: &'a FxHashMap<u32, AbsoluteBytePos>,
    hygiene_context: &'a HygieneDecodeContext,
}

A decoder that can read from the incr. comp. cache. It is similar to the one we use for crate metadata decoding in that it can rebase spans and eventually will also handle things that contain Ty instances.

Fields

tcx: TyCtxt<'tcx>

opaque: Decoder<'a>

source_map: &'a SourceMap

cnum_map: &'a IndexVec<CrateNum, Option<CrateNum>>

file_index_to_file: &'a Lock<FxHashMap<SourceFileIndex, Lrc<SourceFile>>>

file_index_to_stable_id: &'a FxHashMap<SourceFileIndex, StableSourceFileId>

alloc_decoding_session: AllocDecodingSession<'a>

syntax_contexts: &'a FxHashMap<u32, AbsoluteBytePos>

expn_data: &'a FxHashMap<u32, AbsoluteBytePos>

hygiene_context: &'a HygieneDecodeContext

Implementations

impl<'a, 'tcx> CacheDecoder<'a, 'tcx>

pub(in ty::query::on_disk_cache) fn file_index_to_file(
    &self,
    index: SourceFileIndex
) -> Lrc<SourceFile>

Trait Implementations

impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for SyntaxContext

pub fn decode(decoder: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String>

impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for ExpnId

pub fn decode(decoder: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String>

impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for &'tcx [InlineAsmTemplatePiece]

pub fn decode(d: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String>

impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for &'tcx [Span]

pub fn decode(d: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String>

impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for Span

pub fn decode(decoder: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String>

impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for CrateNum

pub fn decode(d: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String>

impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for DefIndex

pub fn decode(d: &mut CacheDecoder<'a, 'tcx>) -> Result<DefIndex, String>

impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for DefId

pub fn decode(d: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String>

impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for &'tcx FxHashSet<LocalDefId>

pub fn decode(d: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String>

impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for &'tcx IndexVec<Promoted, Body<'tcx>>

pub fn decode(d: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String>

impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for &'tcx [Node<'tcx>]

pub fn decode(d: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String>

impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for &'tcx [(Predicate<'tcx>, Span)]

pub fn decode(d: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String>

impl<'a, 'tcx> Decoder for CacheDecoder<'a, 'tcx>

type Error = String

pub fn read_nil(&mut self) -> Result<(), Self::Error>

pub fn read_u128(&mut self) -> Result<u128, Self::Error>

pub fn read_u64(&mut self) -> Result<u64, Self::Error>

pub fn read_u32(&mut self) -> Result<u32, Self::Error>

pub fn read_u16(&mut self) -> Result<u16, Self::Error>

pub fn read_u8(&mut self) -> Result<u8, Self::Error>

pub fn read_usize(&mut self) -> Result<usize, Self::Error>

pub fn read_i128(&mut self) -> Result<i128, Self::Error>

pub fn read_i64(&mut self) -> Result<i64, Self::Error>

pub fn read_i32(&mut self) -> Result<i32, Self::Error>

pub fn read_i16(&mut self) -> Result<i16, Self::Error>

pub fn read_i8(&mut self) -> Result<i8, Self::Error>

pub fn read_isize(&mut self) -> Result<isize, Self::Error>

pub fn read_bool(&mut self) -> Result<bool, Self::Error>

pub fn read_f64(&mut self) -> Result<f64, Self::Error>

pub fn read_f32(&mut self) -> Result<f32, Self::Error>

pub fn read_char(&mut self) -> Result<char, Self::Error>

pub fn read_str(&mut self) -> Result<Cow<'_, str>, Self::Error>

pub fn error(&mut self, err: &str) -> Self::Error

pub fn read_enum<T, F>(&mut self, _name: &str, f: F) -> Result<T, Self::Error> where
    F: FnOnce(&mut Self) -> Result<T, Self::Error>, 

pub fn read_enum_variant<T, F>(
    &mut self,
    _names: &[&str],
    f: F
) -> Result<T, Self::Error> where
    F: FnMut(&mut Self, usize) -> Result<T, Self::Error>, 

pub fn read_enum_variant_arg<T, F>(
    &mut self,
    _a_idx: usize,
    f: F
) -> Result<T, Self::Error> where
    F: FnOnce(&mut Self) -> Result<T, Self::Error>, 

pub fn read_enum_struct_variant<T, F>(
    &mut self,
    names: &[&str],
    f: F
) -> Result<T, Self::Error> where
    F: FnMut(&mut Self, usize) -> Result<T, Self::Error>, 

pub fn read_enum_struct_variant_field<T, F>(
    &mut self,
    _f_name: &str,
    f_idx: usize,
    f: F
) -> Result<T, Self::Error> where
    F: FnOnce(&mut Self) -> Result<T, Self::Error>, 

pub fn read_struct<T, F>(
    &mut self,
    _s_name: &str,
    _len: usize,
    f: F
) -> Result<T, Self::Error> where
    F: FnOnce(&mut Self) -> Result<T, Self::Error>, 

pub fn read_struct_field<T, F>(
    &mut self,
    _f_name: &str,
    _f_idx: usize,
    f: F
) -> Result<T, Self::Error> where
    F: FnOnce(&mut Self) -> Result<T, Self::Error>, 

pub fn read_tuple<T, F>(&mut self, _len: usize, f: F) -> Result<T, Self::Error> where
    F: FnOnce(&mut Self) -> Result<T, Self::Error>, 

pub fn read_tuple_arg<T, F>(
    &mut self,
    _a_idx: usize,
    f: F
) -> Result<T, Self::Error> where
    F: FnOnce(&mut Self) -> Result<T, Self::Error>, 

pub fn read_tuple_struct<T, F>(
    &mut self,
    _s_name: &str,
    len: usize,
    f: F
) -> Result<T, Self::Error> where
    F: FnOnce(&mut Self) -> Result<T, Self::Error>, 

pub fn read_tuple_struct_arg<T, F>(
    &mut self,
    a_idx: usize,
    f: F
) -> Result<T, Self::Error> where
    F: FnOnce(&mut Self) -> Result<T, Self::Error>, 

pub fn read_option<T, F>(&mut self, f: F) -> Result<T, Self::Error> where
    F: FnMut(&mut Self, bool) -> Result<T, Self::Error>, 

pub fn read_seq<T, F>(&mut self, f: F) -> Result<T, Self::Error> where
    F: FnOnce(&mut Self, usize) -> Result<T, Self::Error>, 

pub fn read_seq_elt<T, F>(
    &mut self,
    _idx: usize,
    f: F
) -> Result<T, Self::Error> where
    F: FnOnce(&mut Self) -> Result<T, Self::Error>, 

pub fn read_map<T, F>(&mut self, f: F) -> Result<T, Self::Error> where
    F: FnOnce(&mut Self, usize) -> Result<T, Self::Error>, 

pub fn read_map_elt_key<T, F>(
    &mut self,
    _idx: usize,
    f: F
) -> Result<T, Self::Error> where
    F: FnOnce(&mut Self) -> Result<T, Self::Error>, 

pub fn read_map_elt_val<T, F>(
    &mut self,
    _idx: usize,
    f: F
) -> Result<T, Self::Error> where
    F: FnOnce(&mut Self) -> Result<T, Self::Error>, 

impl<'a, 'tcx> DecoderWithPosition for CacheDecoder<'a, 'tcx>

pub(in ty::query::on_disk_cache) fn position(
    &self
) -> usize

impl<'a, 'tcx> FingerprintDecoder for CacheDecoder<'a, 'tcx>

pub fn decode_fingerprint(&mut self) -> Result<Fingerprint, Self::Error>

impl<'a, 'tcx> TyDecoder<'tcx> for CacheDecoder<'a, 'tcx>

pub const CLEAR_CROSS_CRATE: bool

pub fn tcx(&self) -> TyCtxt<'tcx>

pub fn position(&self) -> usize

pub fn peek_byte(&self) -> u8

pub fn cached_ty_for_shorthand<F>(
    &mut self,
    shorthand: usize,
    or_insert_with: F
) -> Result<Ty<'tcx>, Self::Error> where
    F: FnOnce(&mut Self) -> Result<Ty<'tcx>, Self::Error>, 

pub fn with_position<F, R>(&mut self, pos: usize, f: F) -> R where
    F: FnOnce(&mut Self) -> R, 

pub fn map_encoded_cnum_to_current(&self, cnum: CrateNum) -> CrateNum

pub fn decode_alloc_id(&mut self) -> Result<AllocId, Self::Error>

pub fn positioned_at_shorthand(&self) -> bool