Struct rustc_query_impl::on_disk_cache::CacheDecoder

pub struct CacheDecoder<'a, 'tcx> {
    tcx: TyCtxt<'tcx>,
    opaque: Decoder<'a>,
    source_map: &'a SourceMap,
    file_index_to_file: &'a Lock<FxHashMap<SourceFileIndex, Lrc<SourceFile>>>,
    file_index_to_stable_id: &'a FxHashMap<SourceFileIndex, EncodedSourceFileId>,
    alloc_decoding_session: AllocDecodingSession<'a>,
    syntax_contexts: &'a FxHashMap<u32, AbsoluteBytePos>,
    expn_data: &'a UnhashMap<ExpnHash, AbsoluteBytePos>,
    foreign_expn_data: &'a UnhashMap<ExpnHash, u32>,
    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

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

file_index_to_stable_id: &'a FxHashMap<SourceFileIndex, EncodedSourceFileId>

alloc_decoding_session: AllocDecodingSession<'a>

syntax_contexts: &'a FxHashMap<u32, AbsoluteBytePos>

expn_data: &'a UnhashMap<ExpnHash, AbsoluteBytePos>

foreign_expn_data: &'a UnhashMap<ExpnHash, u32>

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

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

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

fn decode(decoder: &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> Decodable<CacheDecoder<'a, 'tcx>> for ExpnId

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 read_raw_bytes_into(&mut self, bytes: &mut [u8]) -> Result<(), Self::Error>

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

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

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

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

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

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

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

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

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

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

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

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

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

fn read_map_elt_val<T, F>(&mut self, 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> 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 decode_alloc_id(&mut self) -> Result<AllocId, Self::Error>

fn positioned_at_shorthand(&self) -> bool

Layout

Note: Most layout information is completely unstable and may even differ between compilations. 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: 104 bytes