Struct MetadataDecodeContext 

pub(super) struct MetadataDecodeContext<'a, 'tcx> {
    blob_decoder: BlobDecodeContext<'a>,
    cdata: CrateMetadataRef<'a>,
    tcx: TyCtxt<'tcx>,
    alloc_decoding_session: AllocDecodingSession<'a>,
}

This is the decode context used when crate metadata was already read. Decoding of some types, like Span require some information to already been read. Can be constructed from a TyCtxt and CrateMetadataRef (see the Metadata trait)

Fields

blob_decoder: BlobDecodeContext<'a>

cdata: CrateMetadataRef<'a>

tcx: TyCtxt<'tcx>

alloc_decoding_session: AllocDecodingSession<'a>

Implementations

impl<'a, 'tcx> MetadataDecodeContext<'a, 'tcx>

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

Methods from Deref<Target = BlobDecodeContext<'a>>

pub(crate) fn blob(&self) -> &'a MetadataBlob

fn decode_symbol_or_byte_symbol<S>( &mut self, new_from_index: impl Fn(u32) -> S, read_and_intern_str_or_byte_str_this: impl Fn(&mut Self) -> S, read_and_intern_str_or_byte_str_opaque: impl Fn(&mut MemDecoder<'a>) -> S, ) -> S

Trait Implementations

impl<'a, 'tcx> BlobDecoder for MetadataDecodeContext<'a, 'tcx>

fn decode_def_index(&mut self) -> DefIndex

fn decode_symbol(&mut self) -> Symbol

fn decode_byte_symbol(&mut self) -> ByteSymbol

impl<'a, 'tcx> Decodable<MetadataDecodeContext<'a, 'tcx>> for &'tcx [(Clause<'tcx>, Span)]

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

impl<'a, 'tcx> Decodable<MetadataDecodeContext<'a, 'tcx>> for ExpnIndex

fn decode(d: &mut MetadataDecodeContext<'a, 'tcx>) -> ExpnIndex

impl<'a, 'tcx> Decodable<MetadataDecodeContext<'a, 'tcx>> for SpanData

fn decode(decoder: &mut MetadataDecodeContext<'a, 'tcx>) -> SpanData

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

fn read_usize(&mut self) -> usize

fn read_u128(&mut self) -> u128

fn read_u64(&mut self) -> u64

fn read_u32(&mut self) -> u32

fn read_u16(&mut self) -> u16

fn read_u8(&mut self) -> u8

fn read_isize(&mut self) -> isize

fn read_i128(&mut self) -> i128

fn read_i64(&mut self) -> i64

fn read_i32(&mut self) -> i32

fn read_i16(&mut self) -> i16

fn read_raw_bytes(&mut self, len: usize) -> &[u8]

fn peek_byte(&self) -> u8

fn position(&self) -> usize

fn read_i8(&mut self) -> i8

fn read_bool(&mut self) -> bool

fn read_char(&mut self) -> char

fn read_str(&mut self) -> &str

fn read_byte_str(&mut self) -> &[u8]

impl<'a, 'tcx> Deref for MetadataDecodeContext<'a, 'tcx>

type Target = BlobDecodeContext<'a>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, 'tcx> DerefMut for MetadataDecodeContext<'a, 'tcx>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a, 'tcx> LazyDecoder for MetadataDecodeContext<'a, 'tcx>

fn set_lazy_state(&mut self, state: LazyState)

fn get_lazy_state(&self) -> LazyState

fn read_lazy<T>(&mut self) -> LazyValue<T>

fn read_lazy_array<T>(&mut self, len: usize) -> LazyArray<T>

fn read_lazy_table<I, T>(&mut self, width: usize, len: usize) -> LazyTable<I, T>

fn read_lazy_offset_then<T>(&mut self, f: impl Fn(NonZero<usize>) -> T) -> T

impl<'a, 'tcx> SpanDecoder for MetadataDecodeContext<'a, 'tcx>

fn decode_attr_id(&mut self) -> AttrId

fn decode_crate_num(&mut self) -> CrateNum

fn decode_def_id(&mut self) -> DefId

fn decode_syntax_context(&mut self) -> SyntaxContext

fn decode_expn_id(&mut self) -> ExpnId

fn decode_span(&mut self) -> Span

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

const CLEAR_CROSS_CRATE: bool = true

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

fn cached_ty_for_shorthand<F>( &mut self, shorthand: usize, or_insert_with: F, ) -> Ty<'tcx>

where F: FnOnce(&mut Self) -> Ty<'tcx>,

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

where F: FnOnce(&mut Self) -> R,

fn decode_alloc_id(&mut self) -> AllocId

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: 80 bytes