}
}
-impl<'gcx, T> HashStable<StableHashingContext<'gcx>> for mir::ClearOnDecode<T>
+impl<'gcx, T> HashStable<StableHashingContext<'gcx>> for mir::ClearCrossCrate<T>
where T: HashStable<StableHashingContext<'gcx>>
{
#[inline]
hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher);
match *self {
- mir::ClearOnDecode::Clear => {}
- mir::ClearOnDecode::Set(ref value) => {
+ mir::ClearCrossCrate::Clear => {}
+ mir::ClearCrossCrate::Set(ref value) => {
value.hash_stable(hcx, hasher);
}
}
/// Crate-local information for each visibility scope, that can't (and
/// needn't) be tracked across crates.
- pub visibility_scope_info: ClearOnDecode<IndexVec<VisibilityScope, VisibilityScopeInfo>>,
+ pub visibility_scope_info: ClearCrossCrate<IndexVec<VisibilityScope, VisibilityScopeInfo>>,
/// Rvalues promoted from this function, such as borrows of constants.
/// Each of them is the Mir of a constant with the fn's type parameters
impl<'tcx> Mir<'tcx> {
pub fn new(basic_blocks: IndexVec<BasicBlock, BasicBlockData<'tcx>>,
visibility_scopes: IndexVec<VisibilityScope, VisibilityScopeData>,
- visibility_scope_info: ClearOnDecode<IndexVec<VisibilityScope,
- VisibilityScopeInfo>>,
+ visibility_scope_info: ClearCrossCrate<IndexVec<VisibilityScope,
+ VisibilityScopeInfo>>,
promoted: IndexVec<Promoted, Mir<'tcx>>,
yield_ty: Option<Ty<'tcx>>,
local_decls: IndexVec<Local, LocalDecl<'tcx>>,
}
}
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, RustcEncodable, RustcDecodable)]
pub struct VisibilityScopeInfo {
/// A NodeId with lint levels equivalent to this scope's lint levels.
pub lint_root: ast::NodeId,
pub safety: Safety,
}
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, RustcEncodable, RustcDecodable)]
pub enum Safety {
Safe,
/// Unsafe because of a PushUnsafeBlock
}
#[derive(Clone, Debug)]
-pub enum ClearOnDecode<T> {
+pub enum ClearCrossCrate<T> {
Clear,
Set(T)
}
-impl<T> serialize::Encodable for ClearOnDecode<T> {
- fn encode<S: serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- serialize::Encodable::encode(&(), s)
- }
-}
-
-impl<T> serialize::Decodable for ClearOnDecode<T> {
- fn decode<D: serialize::Decoder>(d: &mut D) -> Result<Self, D::Error> {
- serialize::Decodable::decode(d).map(|()| ClearOnDecode::Clear)
- }
-}
+impl<T: serialize::Encodable> serialize::UseSpecializedEncodable for ClearCrossCrate<T> {}
+impl<T: serialize::Decodable> serialize::UseSpecializedDecodable for ClearCrossCrate<T> {}
/// Grouped information about the source code origin of a MIR entity.
/// Intended to be inspected by diagnostics and debuginfo.
RESERVED_FOR_INCR_COMP_CACHE, LOCAL_CRATE};
use hir::map::definitions::DefPathHash;
use middle::cstore::CrateStore;
+use mir;
use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::indexed_vec::{IndexVec, Idx};
use rustc_serialize::{Decodable, Decoder, Encodable, Encoder, opaque,
const PREV_DIAGNOSTICS_TAG: u64 = 0x1234_5678_A1A1_A1A1;
const QUERY_RESULT_INDEX_TAG: u64 = 0x1234_5678_C3C3_C3C3;
+const TAG_CLEAR_CROSS_CRATE_CLEAR: u8 = 0;
+const TAG_CLEAR_CROSS_CRATE_SET: u8 = 1;
+
/// `OnDiskCache` provides an interface to incr. comp. data cached from the
/// previous compilation session. This data will eventually include the results
/// of a few selected queries (like `typeck_tables_of` and `mir_optimized`) and
// NodeIds are not stable across compilation sessions, so we store them in their
// HirId representation. This allows use to map them to the current NodeId.
impl<'a, 'tcx, 'x> SpecializedDecoder<NodeId> for CacheDecoder<'a, 'tcx, 'x> {
+ #[inline]
fn specialized_decode(&mut self) -> Result<NodeId, Self::Error> {
let hir_id = hir::HirId::decode(self)?;
Ok(self.tcx().hir.hir_to_node_id(hir_id))
}
}
+impl<'a, 'tcx, 'x, T: Decodable> SpecializedDecoder<mir::ClearCrossCrate<T>>
+for CacheDecoder<'a, 'tcx, 'x> {
+ #[inline]
+ fn specialized_decode(&mut self) -> Result<mir::ClearCrossCrate<T>, Self::Error> {
+ let discr = u8::decode(self)?;
+
+ match discr {
+ TAG_CLEAR_CROSS_CRATE_CLEAR => Ok(mir::ClearCrossCrate::Clear),
+ TAG_CLEAR_CROSS_CRATE_SET => {
+ let val = T::decode(self)?;
+ Ok(mir::ClearCrossCrate::Set(val))
+ }
+ _ => {
+ unreachable!()
+ }
+ }
+ }
+}
+
//- ENCODING -------------------------------------------------------------------
struct CacheEncoder<'enc, 'a, 'tcx, E>
}
}
+impl<'enc, 'a, 'tcx, E, T> SpecializedEncoder<mir::ClearCrossCrate<T>>
+for CacheEncoder<'enc, 'a, 'tcx, E>
+ where E: 'enc + ty_codec::TyEncoder,
+ T: Encodable,
+{
+ #[inline]
+ fn specialized_encode(&mut self,
+ val: &mir::ClearCrossCrate<T>)
+ -> Result<(), Self::Error> {
+ match *val {
+ mir::ClearCrossCrate::Clear => {
+ TAG_CLEAR_CROSS_CRATE_CLEAR.encode(self)
+ }
+ mir::ClearCrossCrate::Set(ref val) => {
+ TAG_CLEAR_CROSS_CRATE_SET.encode(self)?;
+ val.encode(self)
+ }
+ }
+ }
+}
+
macro_rules! encoder_methods {
($($name:ident($ty:ty);)*) => {
$(fn $name(&mut self, value: $ty) -> Result<(), Self::Error> {
use rustc::hir::def_id::{CrateNum, DefId, DefIndex, CRATE_DEF_INDEX, LOCAL_CRATE};
use rustc::ich::Fingerprint;
use rustc::middle::lang_items;
+use rustc::mir;
use rustc::session::Session;
use rustc::ty::{self, Ty, TyCtxt};
use rustc::ty::codec::TyDecoder;
}
}
+impl<'a, 'tcx, T: Decodable> SpecializedDecoder<mir::ClearCrossCrate<T>>
+for DecodeContext<'a, 'tcx> {
+ #[inline]
+ fn specialized_decode(&mut self) -> Result<mir::ClearCrossCrate<T>, Self::Error> {
+ Ok(mir::ClearCrossCrate::Clear)
+ }
+}
+
implement_ty_decoder!( DecodeContext<'a, 'tcx> );
impl<'a, 'tcx> MetadataBlob {
}
}
+impl<'a, 'tcx, T: Encodable> SpecializedEncoder<mir::ClearCrossCrate<T>>
+for EncodeContext<'a, 'tcx> {
+ fn specialized_encode(&mut self,
+ _: &mir::ClearCrossCrate<T>)
+ -> Result<(), Self::Error> {
+ Ok(())
+ }
+}
+
impl<'a, 'tcx> TyEncoder for EncodeContext<'a, 'tcx> {
fn position(&self) -> usize {
self.opaque.position()
Mir::new(self.cfg.basic_blocks,
self.visibility_scopes,
- ClearOnDecode::Set(self.visibility_scope_info),
+ ClearCrossCrate::Set(self.visibility_scope_info),
IndexVec::new(),
yield_ty,
self.local_decls,
IndexVec::from_elem_n(
VisibilityScopeData { span: span, parent_scope: None }, 1
),
- ClearOnDecode::Clear,
+ ClearCrossCrate::Clear,
IndexVec::new(),
None,
local_decls_for_sig(&sig, span),
IndexVec::from_elem_n(
VisibilityScopeData { span: self.span, parent_scope: None }, 1
),
- ClearOnDecode::Clear,
+ ClearCrossCrate::Clear,
IndexVec::new(),
None,
self.local_decls,
IndexVec::from_elem_n(
VisibilityScopeData { span: span, parent_scope: None }, 1
),
- ClearOnDecode::Clear,
+ ClearCrossCrate::Clear,
IndexVec::new(),
None,
local_decls,
IndexVec::from_elem_n(
VisibilityScopeData { span: span, parent_scope: None }, 1
),
- ClearOnDecode::Clear,
+ ClearCrossCrate::Clear,
IndexVec::new(),
None,
local_decls,
let mir = &tcx.mir_built(def_id).borrow();
let visibility_scope_info = match mir.visibility_scope_info {
- ClearOnDecode::Set(ref data) => data,
- ClearOnDecode::Clear => {
+ ClearCrossCrate::Set(ref data) => data,
+ ClearCrossCrate::Clear => {
debug!("unsafety_violations: {:?} - remote, skipping", def_id);
return UnsafetyCheckResult {
violations: Rc::new([]),
projects / rust.git / commitdiff