Struct rustc_middle::ty::query::on_disk_cache::CacheEncoder

pub(in ty::query::on_disk_cache) struct CacheEncoder<'a, 'tcx, E: OpaqueEncoder> {
    tcx: TyCtxt<'tcx>,
    encoder: &'a mut E,
    type_shorthands: FxHashMap<Ty<'tcx>, usize>,
    predicate_shorthands: FxHashMap<Predicate<'tcx>, usize>,
    interpret_allocs: FxIndexSet<AllocId>,
    source_map: CachingSourceMapView<'tcx>,
    file_to_file_index: FxHashMap<*const SourceFile, SourceFileIndex>,
    hygiene_context: &'a HygieneEncodeContext,
}

An encoder that can write the incr. comp. cache.

Fields

tcx: TyCtxt<'tcx>

encoder: &'a mut E

type_shorthands: FxHashMap<Ty<'tcx>, usize>

predicate_shorthands: FxHashMap<Predicate<'tcx>, usize>

interpret_allocs: FxIndexSet<AllocId>

source_map: CachingSourceMapView<'tcx>

file_to_file_index: FxHashMap<*const SourceFile, SourceFileIndex>

hygiene_context: &'a HygieneEncodeContext

Implementations

impl<'a, 'tcx, E> CacheEncoder<'a, 'tcx, E> where
    E: 'a + OpaqueEncoder, 

pub(in ty::query::on_disk_cache) fn source_file_index(
    &mut self,
    source_file: Lrc<SourceFile>
) -> SourceFileIndex

pub(in ty::query::on_disk_cache) fn encode_tagged<T: Encodable<Self>, V: Encodable<Self>>(
    &mut self,
    tag: T,
    value: &V
) -> Result<(), E::Error>

Encode something with additional information that allows to do some sanity checks when decoding the data again. This method will first encode the specified tag, then the given value, then the number of bytes taken up by tag and value. On decoding, we can then verify that we get the expected tag and read the expected number of bytes.

Trait Implementations

impl<'a, 'tcx, E> Encodable<CacheEncoder<'a, 'tcx, E>> for SyntaxContext where
    E: 'a + OpaqueEncoder, 

pub fn encode(&self, s: &mut CacheEncoder<'a, 'tcx, E>) -> Result<(), E::Error>

impl<'a, 'tcx, E> Encodable<CacheEncoder<'a, 'tcx, E>> for ExpnId where
    E: 'a + OpaqueEncoder, 

pub fn encode(&self, s: &mut CacheEncoder<'a, 'tcx, E>) -> Result<(), E::Error>

impl<'a, 'tcx, E> Encodable<CacheEncoder<'a, 'tcx, E>> for Span where
    E: 'a + OpaqueEncoder, 

pub fn encode(&self, s: &mut CacheEncoder<'a, 'tcx, E>) -> Result<(), E::Error>

impl<'a, 'tcx, E> Encodable<CacheEncoder<'a, 'tcx, E>> for DefId where
    E: 'a + OpaqueEncoder, 

pub fn encode(&self, s: &mut CacheEncoder<'a, 'tcx, E>) -> Result<(), E::Error>

impl<'a, 'tcx, E> Encodable<CacheEncoder<'a, 'tcx, E>> for DefIndex where
    E: 'a + OpaqueEncoder, 

pub fn encode(&self, _: &mut CacheEncoder<'a, 'tcx, E>) -> Result<(), E::Error>

impl<'a, 'tcx, E> Encoder for CacheEncoder<'a, 'tcx, E> where
    E: 'a + OpaqueEncoder, 

type Error = E::Error

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn emit_str(&mut self, value: &str) -> Result<(), Self::Error>

pub fn emit_enum<F>(&mut self, _name: &str, f: F) -> Result<(), Self::Error> where
    F: FnOnce(&mut Self) -> Result<(), Self::Error>, 

pub fn emit_enum_variant<F>(
    &mut self,
    _v_name: &str,
    v_id: usize,
    _len: usize,
    f: F
) -> Result<(), Self::Error> where
    F: FnOnce(&mut Self) -> Result<(), Self::Error>, 

pub fn emit_enum_variant_arg<F>(
    &mut self,
    _a_idx: usize,
    f: F
) -> Result<(), Self::Error> where
    F: FnOnce(&mut Self) -> Result<(), Self::Error>, 

pub fn emit_enum_struct_variant<F>(
    &mut self,
    v_name: &str,
    v_id: usize,
    len: usize,
    f: F
) -> Result<(), Self::Error> where
    F: FnOnce(&mut Self) -> Result<(), Self::Error>, 

pub fn emit_enum_struct_variant_field<F>(
    &mut self,
    _f_name: &str,
    f_idx: usize,
    f: F
) -> Result<(), Self::Error> where
    F: FnOnce(&mut Self) -> Result<(), Self::Error>, 

pub fn emit_struct<F>(
    &mut self,
    _name: &str,
    _len: usize,
    f: F
) -> Result<(), Self::Error> where
    F: FnOnce(&mut Self) -> Result<(), Self::Error>, 

pub fn emit_struct_field<F>(
    &mut self,
    _f_name: &str,
    _f_idx: usize,
    f: F
) -> Result<(), Self::Error> where
    F: FnOnce(&mut Self) -> Result<(), Self::Error>, 

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

pub fn emit_tuple_arg<F>(
    &mut self,
    _idx: usize,
    f: F
) -> Result<(), Self::Error> where
    F: FnOnce(&mut Self) -> Result<(), Self::Error>, 

pub fn emit_tuple_struct<F>(
    &mut self,
    _name: &str,
    len: usize,
    f: F
) -> Result<(), Self::Error> where
    F: FnOnce(&mut Self) -> Result<(), Self::Error>, 

pub fn emit_tuple_struct_arg<F>(
    &mut self,
    f_idx: usize,
    f: F
) -> Result<(), Self::Error> where
    F: FnOnce(&mut Self) -> Result<(), Self::Error>, 

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

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

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

pub fn emit_seq<F>(&mut self, len: usize, f: F) -> Result<(), Self::Error> where
    F: FnOnce(&mut Self) -> Result<(), Self::Error>, 

pub fn emit_seq_elt<F>(&mut self, _idx: usize, f: F) -> Result<(), Self::Error> where
    F: FnOnce(&mut Self) -> Result<(), Self::Error>, 

pub fn emit_map<F>(&mut self, len: usize, f: F) -> Result<(), Self::Error> where
    F: FnOnce(&mut Self) -> Result<(), Self::Error>, 

pub fn emit_map_elt_key<F>(
    &mut self,
    _idx: usize,
    f: F
) -> Result<(), Self::Error> where
    F: FnOnce(&mut Self) -> Result<(), Self::Error>, 

pub fn emit_map_elt_val<F>(
    &mut self,
    _idx: usize,
    f: F
) -> Result<(), Self::Error> where
    F: FnOnce(&mut Self) -> Result<(), Self::Error>, 

impl<'a, 'tcx> FingerprintEncoder for CacheEncoder<'a, 'tcx, Encoder>

pub fn encode_fingerprint(&mut self, f: &Fingerprint) -> EncodeResult

impl<'a, 'tcx, E> TyEncoder<'tcx> for CacheEncoder<'a, 'tcx, E> where
    E: 'a + OpaqueEncoder, 

pub const CLEAR_CROSS_CRATE: bool

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

pub fn position(&self) -> usize

pub fn type_shorthands(&mut self) -> &mut FxHashMap<Ty<'tcx>, usize>

pub fn predicate_shorthands(&mut self) -> &mut FxHashMap<Predicate<'tcx>, usize>

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