Struct rustc_metadata::rmeta::decoder::DecodeContext

pub(in rmeta) 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: usize

lazy_state: LazyState

alloc_decoding_session: Option<AllocDecodingSession<'a>>

Implementations

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

pub(in rmeta::decoder) fn tcx(
    &self
) -> TyCtxt<'tcx>

pub(in rmeta::decoder) fn cdata(
    &self
) -> CrateMetadataRef<'a>

pub(in rmeta::decoder) fn read_lazy_with_meta<T: ?Sized + LazyMeta>(
    &mut self,
    meta: T::Meta
) -> Result<Lazy<T>, Self::Error>

Trait Implementations

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

pub fn decode(
    __decoder: &mut DecodeContext<'__a, 'tcx>
) -> Result<Self, <DecodeContext<'__a, 'tcx> as Decoder>::Error>

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

pub fn decode(
    __decoder: &mut DecodeContext<'__a, 'tcx>
) -> Result<Self, <DecodeContext<'__a, 'tcx> as Decoder>::Error>

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

pub fn decode(
    __decoder: &mut DecodeContext<'__a, 'tcx>
) -> Result<Self, <DecodeContext<'__a, 'tcx> as Decoder>::Error>

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

pub fn decode(
    __decoder: &mut DecodeContext<'__a, 'tcx>
) -> Result<Self, <DecodeContext<'__a, 'tcx> as Decoder>::Error>

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

pub fn decode(
    __decoder: &mut DecodeContext<'__a, 'tcx>
) -> Result<Self, <DecodeContext<'__a, 'tcx> as Decoder>::Error>

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

pub fn decode(
    __decoder: &mut DecodeContext<'__a, 'tcx>
) -> Result<Self, <DecodeContext<'__a, 'tcx> as Decoder>::Error>

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

pub fn decode(
    __decoder: &mut DecodeContext<'__a, 'tcx>
) -> Result<Self, <DecodeContext<'__a, 'tcx> as Decoder>::Error>

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

pub fn decode(
    __decoder: &mut DecodeContext<'__a, 'tcx>
) -> Result<Self, <DecodeContext<'__a, 'tcx> as Decoder>::Error>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub 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]>

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

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

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

type Error = String

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub 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> FingerprintDecoder for DecodeContext<'a, 'tcx>

pub fn decode_fingerprint(&mut self) -> Result<Fingerprint, String>

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

pub const CLEAR_CROSS_CRATE: bool

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

pub fn peek_byte(&self) -> u8

pub fn position(&self) -> usize

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

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

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

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

pub fn positioned_at_shorthand(&self) -> bool