Struct rustc_metadata::rmeta::decoder::DecodeContext

pub(super) struct DecodeContext<'a, 'tcx> {
    opaque: Decoder<'a>,
    cdata: Option<CrateMetadataRef<'a>>,
    blob: &'a MetadataBlob,
    sess: Option<&'tcx Session>,
    tcx: Option<TyCtxt<'tcx>>,
    last_source_file_index: usize,
    lazy_state: LazyState,
    alloc_decoding_session: Option<AllocDecodingSession<'a>>,
}

Fields

opaque: Decoder<'a>

cdata: Option<CrateMetadataRef<'a>>

blob: &'a MetadataBlob

sess: Option<&'tcx Session>

tcx: Option<TyCtxt<'tcx>>

last_source_file_index: usize

lazy_state: LazyState

alloc_decoding_session: Option<AllocDecodingSession<'a>>

Implementations

impl<'a, 'tcx> DecodeContext<'a, 'tcx>

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

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

pub fn cdata(&self) -> CrateMetadataRef<'a>

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

fn read_lazy_with_meta<T: ?Sized + LazyMeta>(
    &mut self,
    meta: T::Meta
) -> Result<Lazy<T>, String>

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

Trait Implementations

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

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

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

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

impl<'a, 'tcx, I: Idx, T: Decodable<DecodeContext<'a, 'tcx>>> Decodable<DecodeContext> for Lazy<Table<I, T>> where
    Option<T>: FixedSizeEncoding, 

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

impl<'a, 'tcx> Decodable<DecodeContext> for DefPathHashMapRef<'static>

fn decode(
    d: &mut DecodeContext<'a, 'tcx>
) -> Result<DefPathHashMapRef<'static>, String>

impl<'tcx, '__a> Decodable<DecodeContext> for ProcMacroData

fn decode(__decoder: &mut DecodeContext<'__a, 'tcx>) -> Result<Self, String>

impl<'tcx, '__a> Decodable<DecodeContext> for CrateRoot<'tcx>

fn decode(__decoder: &mut DecodeContext<'__a, 'tcx>) -> Result<Self, String>

impl<'tcx, '__a> Decodable<DecodeContext> for TraitImpls

fn decode(__decoder: &mut DecodeContext<'__a, 'tcx>) -> Result<Self, String>

impl<'tcx, '__a> Decodable<DecodeContext> for LazyTables<'tcx>

fn decode(__decoder: &mut DecodeContext<'__a, 'tcx>) -> Result<Self, String>

impl<'tcx, '__a> Decodable<DecodeContext> for EntryKind

fn decode(__decoder: &mut DecodeContext<'__a, 'tcx>) -> Result<Self, String>

impl<'tcx, '__a> Decodable<DecodeContext> for FnData

fn decode(__decoder: &mut DecodeContext<'__a, 'tcx>) -> Result<Self, String>

impl<'tcx, '__a> Decodable<DecodeContext> for AssocFnData

fn decode(__decoder: &mut DecodeContext<'__a, 'tcx>) -> Result<Self, String>

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, 'tcx, T: Decodable<DecodeContext<'a, 'tcx>>> Decodable<DecodeContext> for Lazy<T>

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

impl<'a, 'tcx, T: Decodable<DecodeContext<'a, 'tcx>>> Decodable<DecodeContext> for Lazy<[T]>

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

impl<'a, 'tcx> Decoder for DecodeContext<'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> TyDecoder<'tcx> for DecodeContext<'a, 'tcx>

const CLEAR_CROSS_CRATE: bool

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

fn peek_byte(&self) -> u8

fn position(&self) -> usize

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