Struct rustc_metadata::rmeta::decoder::DecodeContext[−][src]

pub(super) struct DecodeContext<'a, 'tcx> {
    opaque: Decoder<'a>,
    cdata: Option<CrateMetadataRef<'a>>,
    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>>sess: Option<&'tcx Session>tcx: Option<TyCtxt<'tcx>>last_source_file_index: usizelazy_state: LazyStatealloc_decoding_session: Option<AllocDecodingSession<'a>>

Implementations

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

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

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>

Trait Implementations

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<'a, 'tcx> Decodable<DecodeContext<'a, 'tcx>> 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<'a, 'tcx>> for Lazy<T>

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

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

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

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

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

Auto Trait Implementations

impl<'a, 'tcx> !RefUnwindSafe for DecodeContext<'a, 'tcx>

impl<'a, 'tcx> !Send for DecodeContext<'a, 'tcx>

impl<'a, 'tcx> !Sync for DecodeContext<'a, 'tcx>

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

impl<'a, 'tcx> !UnwindSafe for DecodeContext<'a, 'tcx>

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized,

pub fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T where
    T: ?Sized,

pub fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T where
    T: ?Sized,

pub fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

pub fn from(t: T) -> T

Performs the conversion.

impl<T, U> Into<U> for T where
    U: From<T>,

pub fn into(self) -> U

Performs the conversion.

impl<T, U> TryFrom<U> for T where
    U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

impl<'a, T> Captures<'a> for T where
    T: ?Sized,

Layout

Note: Most layout information is completely unstable and may be different between compiler versions and platforms. 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: 96 bytes