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

pub 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 incremental compilation 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>

fn file_index_to_file(&self, index: SourceFileIndex) -> Lrc<SourceFile>

Trait Implementations

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

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

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

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

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

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

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

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

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

type Error = String

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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>

fn position(&self) -> usize

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

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

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

const CLEAR_CROSS_CRATE: bool

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

fn position(&self) -> usize

fn peek_byte(&self) -> u8

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

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

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

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

fn positioned_at_shorthand(&self) -> bool