bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Add InterpretInterner to StableHashingContext for AllocId serialization

Browse source
This commit is contained in:
Oliver Schneider 2018-01-16 10:16:38 +01:00
parent e0045ab891
commit 7d2d4e3202
No known key found for this signature in database
GPG key ID: A69F8D225B3AD7D9
39 changed files with 618 additions and 528 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/librustc/dep_graph/dep_node.rs
View file

@ -661,7 +661,7 @@ trait DepNodeParams<'a, 'gcx: 'tcx + 'a, 'tcx: 'a> : fmt::Debug {
} }
impl<'a, 'gcx: 'tcx + 'a, 'tcx: 'a, T> DepNodeParams<'a, 'gcx, 'tcx> for T impl<'a, 'gcx: 'tcx + 'a, 'tcx: 'a, T> DepNodeParams<'a, 'gcx, 'tcx> for T
where T: HashStable<StableHashingContext<'gcx>> + fmt::Debug where T: HashStable<StableHashingContext<'a>> + fmt::Debug
{ {
default const CAN_RECONSTRUCT_QUERY_KEY: bool = false; default const CAN_RECONSTRUCT_QUERY_KEY: bool = false;

2
src/librustc/hir/map/collector.rs
View file

@ -529,7 +529,7 @@ struct HirItemLike<T> {
hash_bodies: bool, hash_bodies: bool,
} }
impl<'hir, T> HashStable<StableHashingContext<'hir>> for HirItemLike<T> impl<'a, 'hir, T> HashStable<StableHashingContext<'hir>> for HirItemLike<T>
where T: HashStable<StableHashingContext<'hir>> where T: HashStable<StableHashingContext<'hir>>
{ {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,

64
src/librustc/ich/hcx.rs
View file

@ -46,19 +46,19 @@ pub fn compute_ignored_attr_names() -> FxHashSet<Symbol> {
/// a reference to the TyCtxt) and it holds a few caches for speeding up various /// a reference to the TyCtxt) and it holds a few caches for speeding up various
/// things (e.g. each DefId/DefPath is only hashed once). /// things (e.g. each DefId/DefPath is only hashed once).
#[derive(Clone)] #[derive(Clone)]
pub struct StableHashingContext<'gcx> { pub struct StableHashingContext<'a> {
sess: &'gcx Session, sess: &'a Session,
definitions: &'gcx Definitions, definitions: &'a Definitions,
cstore: &'gcx dyn CrateStore, cstore: &'a dyn CrateStore,
body_resolver: BodyResolver<'gcx>, body_resolver: BodyResolver<'a>,
hash_spans: bool, hash_spans: bool,
hash_bodies: bool, hash_bodies: bool,
node_id_hashing_mode: NodeIdHashingMode, node_id_hashing_mode: NodeIdHashingMode,
// Very often, we are hashing something that does not need the // Very often, we are hashing something that does not need the
// CachingCodemapView, so we initialize it lazily. // CachingCodemapView, so we initialize it lazily.
raw_codemap: &'gcx CodeMap, raw_codemap: &'a CodeMap,
caching_codemap: Option<CachingCodemapView<'gcx>>, caching_codemap: Option<CachingCodemapView<'a>>,
} }
#[derive(PartialEq, Eq, Clone, Copy)] #[derive(PartialEq, Eq, Clone, Copy)]
@ -81,14 +81,14 @@ impl<'gcx> BodyResolver<'gcx> {
} }
} }
impl<'gcx> StableHashingContext<'gcx> { impl<'a> StableHashingContext<'a> {
// The `krate` here is only used for mapping BodyIds to Bodies. // The `krate` here is only used for mapping BodyIds to Bodies.
// Don't use it for anything else or you'll run the risk of // Don't use it for anything else or you'll run the risk of
// leaking data out of the tracking system. // leaking data out of the tracking system.
pub fn new(sess: &'gcx Session, pub fn new(sess: &'a Session,
krate: &'gcx hir::Crate, krate: &'a hir::Crate,
definitions: &'gcx Definitions, definitions: &'a Definitions,
cstore: &'gcx dyn CrateStore) cstore: &'a dyn CrateStore)
-> Self { -> Self {
let hash_spans_initial = !sess.opts.debugging_opts.incremental_ignore_spans; let hash_spans_initial = !sess.opts.debugging_opts.incremental_ignore_spans;
@ -106,7 +106,7 @@ impl<'gcx> StableHashingContext<'gcx> {
} }
#[inline] #[inline]
pub fn sess(&self) -> &'gcx Session { pub fn sess(&self) -> &'a Session {
self.sess self.sess
} }
@ -165,7 +165,7 @@ impl<'gcx> StableHashingContext<'gcx> {
} }
#[inline] #[inline]
pub fn codemap(&mut self) -> &mut CachingCodemapView<'gcx> { pub fn codemap(&mut self) -> &mut CachingCodemapView<'a> {
match self.caching_codemap { match self.caching_codemap {
Some(ref mut cm) => { Some(ref mut cm) => {
cm cm
@ -193,27 +193,27 @@ impl<'gcx> StableHashingContext<'gcx> {
} }
impl<'a, 'gcx, 'lcx> StableHashingContextProvider for TyCtxt<'a, 'gcx, 'lcx> { impl<'a, 'gcx, 'lcx> StableHashingContextProvider for TyCtxt<'a, 'gcx, 'lcx> {
type ContextType = StableHashingContext<'gcx>; type ContextType = StableHashingContext<'a>;
fn create_stable_hashing_context(&self) -> Self::ContextType { fn create_stable_hashing_context(&self) -> Self::ContextType {
(*self).create_stable_hashing_context() (*self).create_stable_hashing_context()
} }
} }
impl<'gcx> StableHashingContextProvider for StableHashingContext<'gcx> { impl<'a> StableHashingContextProvider for StableHashingContext<'a> {
type ContextType = StableHashingContext<'gcx>; type ContextType = StableHashingContext<'a>;
fn create_stable_hashing_context(&self) -> Self::ContextType { fn create_stable_hashing_context(&self) -> Self::ContextType {
self.clone() self.clone()
} }
} }
impl<'gcx> ::dep_graph::DepGraphSafe for StableHashingContext<'gcx> { impl<'a> ::dep_graph::DepGraphSafe for StableHashingContext<'a> {
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for hir::BodyId { impl<'a> HashStable<StableHashingContext<'a>> for hir::BodyId {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
if hcx.hash_bodies() { if hcx.hash_bodies() {
hcx.body_resolver.body(*self).hash_stable(hcx, hasher); hcx.body_resolver.body(*self).hash_stable(hcx, hasher);
@ -221,10 +221,10 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for hir::BodyId {
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for hir::HirId { impl<'a> HashStable<StableHashingContext<'a>> for hir::HirId {
#[inline] #[inline]
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
match hcx.node_id_hashing_mode { match hcx.node_id_hashing_mode {
NodeIdHashingMode::Ignore => { NodeIdHashingMode::Ignore => {
@ -243,21 +243,21 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for hir::HirId {
} }
} }
impl<'gcx> ToStableHashKey<StableHashingContext<'gcx>> for hir::HirId { impl<'a> ToStableHashKey<StableHashingContext<'a>> for hir::HirId {
type KeyType = (DefPathHash, hir::ItemLocalId); type KeyType = (DefPathHash, hir::ItemLocalId);
#[inline] #[inline]
fn to_stable_hash_key(&self, fn to_stable_hash_key(&self,
hcx: &StableHashingContext<'gcx>) hcx: &StableHashingContext<'a>)
-> (DefPathHash, hir::ItemLocalId) { -> (DefPathHash, hir::ItemLocalId) {
let def_path_hash = hcx.local_def_path_hash(self.owner); let def_path_hash = hcx.local_def_path_hash(self.owner);
(def_path_hash, self.local_id) (def_path_hash, self.local_id)
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for ast::NodeId { impl<'a> HashStable<StableHashingContext<'a>> for ast::NodeId {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
match hcx.node_id_hashing_mode { match hcx.node_id_hashing_mode {
NodeIdHashingMode::Ignore => { NodeIdHashingMode::Ignore => {
@ -270,18 +270,18 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for ast::NodeId {
} }
} }
impl<'gcx> ToStableHashKey<StableHashingContext<'gcx>> for ast::NodeId { impl<'a> ToStableHashKey<StableHashingContext<'a>> for ast::NodeId {
type KeyType = (DefPathHash, hir::ItemLocalId); type KeyType = (DefPathHash, hir::ItemLocalId);
#[inline] #[inline]
fn to_stable_hash_key(&self, fn to_stable_hash_key(&self,
hcx: &StableHashingContext<'gcx>) hcx: &StableHashingContext<'a>)
-> (DefPathHash, hir::ItemLocalId) { -> (DefPathHash, hir::ItemLocalId) {
hcx.definitions.node_to_hir_id(*self).to_stable_hash_key(hcx) hcx.definitions.node_to_hir_id(*self).to_stable_hash_key(hcx)
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for Span { impl<'a> HashStable<StableHashingContext<'a>> for Span {
// Hash a span in a stable way. We can't directly hash the span's BytePos // Hash a span in a stable way. We can't directly hash the span's BytePos
// fields (that would be similar to hashing pointers, since those are just // fields (that would be similar to hashing pointers, since those are just
@ -293,7 +293,7 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for Span {
// Also, hashing filenames is expensive so we avoid doing it twice when the // Also, hashing filenames is expensive so we avoid doing it twice when the
// span starts and ends in the same file, which is almost always the case. // span starts and ends in the same file, which is almost always the case.
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
const TAG_VALID_SPAN: u8 = 0; const TAG_VALID_SPAN: u8 = 0;
const TAG_INVALID_SPAN: u8 = 1; const TAG_INVALID_SPAN: u8 = 1;
@ -373,8 +373,8 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for Span {
} }
} }
pub fn hash_stable_trait_impls<'gcx, W, R>( pub fn hash_stable_trait_impls<'a, 'gcx, W, R>(
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>, hasher: &mut StableHasher<W>,
blanket_impls: &Vec<DefId>, blanket_impls: &Vec<DefId>,
non_blanket_impls: &HashMap<fast_reject::SimplifiedType, Vec<DefId>, R>) non_blanket_impls: &HashMap<fast_reject::SimplifiedType, Vec<DefId>, R>)

132
src/librustc/ich/impls_hir.rs
View file

@ -21,46 +21,46 @@ use std::mem;
use syntax::ast; use syntax::ast;
use syntax::attr; use syntax::attr;
impl<'gcx> HashStable<StableHashingContext<'gcx>> for DefId { impl<'a> HashStable<StableHashingContext<'a>> for DefId {
#[inline] #[inline]
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
hcx.def_path_hash(*self).hash_stable(hcx, hasher); hcx.def_path_hash(*self).hash_stable(hcx, hasher);
} }
} }
impl<'gcx> ToStableHashKey<StableHashingContext<'gcx>> for DefId { impl<'a> ToStableHashKey<StableHashingContext<'a>> for DefId {
type KeyType = DefPathHash; type KeyType = DefPathHash;
#[inline] #[inline]
fn to_stable_hash_key(&self, hcx: &StableHashingContext<'gcx>) -> DefPathHash { fn to_stable_hash_key(&self, hcx: &StableHashingContext<'a>) -> DefPathHash {
hcx.def_path_hash(*self) hcx.def_path_hash(*self)
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for LocalDefId { impl<'a> HashStable<StableHashingContext<'a>> for LocalDefId {
#[inline] #[inline]
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
hcx.def_path_hash(self.to_def_id()).hash_stable(hcx, hasher); hcx.def_path_hash(self.to_def_id()).hash_stable(hcx, hasher);
} }
} }
impl<'gcx> ToStableHashKey<StableHashingContext<'gcx>> for LocalDefId { impl<'a> ToStableHashKey<StableHashingContext<'a>> for LocalDefId {
type KeyType = DefPathHash; type KeyType = DefPathHash;
#[inline] #[inline]
fn to_stable_hash_key(&self, hcx: &StableHashingContext<'gcx>) -> DefPathHash { fn to_stable_hash_key(&self, hcx: &StableHashingContext<'a>) -> DefPathHash {
hcx.def_path_hash(self.to_def_id()) hcx.def_path_hash(self.to_def_id())
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for CrateNum { impl<'a> HashStable<StableHashingContext<'a>> for CrateNum {
#[inline] #[inline]
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
hcx.def_path_hash(DefId { hcx.def_path_hash(DefId {
krate: *self, krate: *self,
@ -69,11 +69,11 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for CrateNum {
} }
} }
impl<'gcx> ToStableHashKey<StableHashingContext<'gcx>> for CrateNum { impl<'a> ToStableHashKey<StableHashingContext<'a>> for CrateNum {
type KeyType = DefPathHash; type KeyType = DefPathHash;
#[inline] #[inline]
fn to_stable_hash_key(&self, hcx: &StableHashingContext<'gcx>) -> DefPathHash { fn to_stable_hash_key(&self, hcx: &StableHashingContext<'a>) -> DefPathHash {
let def_id = DefId { krate: *self, index: CRATE_DEF_INDEX }; let def_id = DefId { krate: *self, index: CRATE_DEF_INDEX };
def_id.to_stable_hash_key(hcx) def_id.to_stable_hash_key(hcx)
} }
@ -81,13 +81,13 @@ impl<'gcx> ToStableHashKey<StableHashingContext<'gcx>> for CrateNum {
impl_stable_hash_for!(tuple_struct hir::ItemLocalId { index }); impl_stable_hash_for!(tuple_struct hir::ItemLocalId { index });
impl<'gcx> ToStableHashKey<StableHashingContext<'gcx>> impl<'a> ToStableHashKey<StableHashingContext<'a>>
for hir::ItemLocalId { for hir::ItemLocalId {
type KeyType = hir::ItemLocalId; type KeyType = hir::ItemLocalId;
#[inline] #[inline]
fn to_stable_hash_key(&self, fn to_stable_hash_key(&self,
_: &StableHashingContext<'gcx>) _: &StableHashingContext<'a>)
-> hir::ItemLocalId { -> hir::ItemLocalId {
*self *self
} }
@ -100,9 +100,9 @@ for hir::ItemLocalId {
// want to pick up on a reference changing its target, so we hash the NodeIds // want to pick up on a reference changing its target, so we hash the NodeIds
// in "DefPath Mode". // in "DefPath Mode".
impl<'gcx> HashStable<StableHashingContext<'gcx>> for hir::ItemId { impl<'a> HashStable<StableHashingContext<'a>> for hir::ItemId {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let hir::ItemId { let hir::ItemId {
id id
@ -114,9 +114,9 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for hir::ItemId {
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for hir::TraitItemId { impl<'a> HashStable<StableHashingContext<'a>> for hir::TraitItemId {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let hir::TraitItemId { let hir::TraitItemId {
node_id node_id
@ -128,9 +128,9 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for hir::TraitItemId {
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for hir::ImplItemId { impl<'a> HashStable<StableHashingContext<'a>> for hir::ImplItemId {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let hir::ImplItemId { let hir::ImplItemId {
node_id node_id
@ -271,9 +271,9 @@ impl_stable_hash_for!(struct hir::TypeBinding {
span span
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> for hir::Ty { impl<'a> HashStable<StableHashingContext<'a>> for hir::Ty {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
hcx.while_hashing_hir_bodies(true, |hcx| { hcx.while_hashing_hir_bodies(true, |hcx| {
let hir::Ty { let hir::Ty {
@ -339,9 +339,9 @@ impl_stable_hash_for!(enum hir::FunctionRetTy {
Return(t) Return(t)
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> for hir::TraitRef { impl<'a> HashStable<StableHashingContext<'a>> for hir::TraitRef {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let hir::TraitRef { let hir::TraitRef {
ref path, ref path,
@ -376,9 +376,9 @@ impl_stable_hash_for!(struct hir::MacroDef {
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> for hir::Block { impl<'a> HashStable<StableHashingContext<'a>> for hir::Block {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let hir::Block { let hir::Block {
ref stmts, ref stmts,
@ -400,9 +400,9 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for hir::Block {
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for hir::Pat { impl<'a> HashStable<StableHashingContext<'a>> for hir::Pat {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let hir::Pat { let hir::Pat {
id: _, id: _,
@ -527,9 +527,9 @@ impl_stable_hash_for!(enum hir::UnsafeSource {
UserProvided UserProvided
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> for hir::Expr { impl<'a> HashStable<StableHashingContext<'a>> for hir::Expr {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
hcx.while_hashing_hir_bodies(true, |hcx| { hcx.while_hashing_hir_bodies(true, |hcx| {
let hir::Expr { let hir::Expr {
@ -591,9 +591,9 @@ impl_stable_hash_for!(enum hir::LoopSource {
ForLoop ForLoop
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> for hir::MatchSource { impl<'a> HashStable<StableHashingContext<'a>> for hir::MatchSource {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
use hir::MatchSource; use hir::MatchSource;
@ -647,9 +647,9 @@ impl_stable_hash_for!(enum hir::ScopeTarget {
Loop(loop_id_result) Loop(loop_id_result)
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> for ast::Ident { impl<'a> HashStable<StableHashingContext<'a>> for ast::Ident {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let ast::Ident { let ast::Ident {
ref name, ref name,
@ -660,9 +660,9 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for ast::Ident {
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for hir::TraitItem { impl<'a> HashStable<StableHashingContext<'a>> for hir::TraitItem {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let hir::TraitItem { let hir::TraitItem {
id: _, id: _,
@ -695,9 +695,9 @@ impl_stable_hash_for!(enum hir::TraitItemKind {
Type(bounds, rhs) Type(bounds, rhs)
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> for hir::ImplItem { impl<'a> HashStable<StableHashingContext<'a>> for hir::ImplItem {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let hir::ImplItem { let hir::ImplItem {
id: _, id: _,
@ -729,9 +729,9 @@ impl_stable_hash_for!(enum hir::ImplItemKind {
Type(t) Type(t)
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> for hir::Visibility { impl<'a> HashStable<StableHashingContext<'a>> for hir::Visibility {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
match *self { match *self {
@ -750,9 +750,9 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for hir::Visibility {
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for hir::Defaultness { impl<'a> HashStable<StableHashingContext<'a>> for hir::Defaultness {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
match *self { match *self {
@ -771,9 +771,9 @@ impl_stable_hash_for!(enum hir::ImplPolarity {
Negative Negative
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> for hir::Mod { impl<'a> HashStable<StableHashingContext<'a>> for hir::Mod {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let hir::Mod { let hir::Mod {
inner, inner,
@ -826,9 +826,9 @@ impl_stable_hash_for!(enum hir::VariantData {
Unit(id) Unit(id)
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> for hir::Item { impl<'a> HashStable<StableHashingContext<'a>> for hir::Item {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let hir::Item { let hir::Item {
name, name,
@ -885,10 +885,10 @@ impl_stable_hash_for!(struct hir::ImplItemRef {
defaultness defaultness
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> impl<'a> HashStable<StableHashingContext<'a>>
for hir::AssociatedItemKind { for hir::AssociatedItemKind {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
match *self { match *self {
@ -930,9 +930,9 @@ impl_stable_hash_for!(struct hir::Arg {
hir_id hir_id
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> for hir::Body { impl<'a> HashStable<StableHashingContext<'a>> for hir::Body {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let hir::Body { let hir::Body {
ref arguments, ref arguments,
@ -948,12 +948,12 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for hir::Body {
} }
} }
impl<'gcx> ToStableHashKey<StableHashingContext<'gcx>> for hir::BodyId { impl<'a> ToStableHashKey<StableHashingContext<'a>> for hir::BodyId {
type KeyType = (DefPathHash, hir::ItemLocalId); type KeyType = (DefPathHash, hir::ItemLocalId);
#[inline] #[inline]
fn to_stable_hash_key(&self, fn to_stable_hash_key(&self,
hcx: &StableHashingContext<'gcx>) hcx: &StableHashingContext<'a>)
-> (DefPathHash, hir::ItemLocalId) { -> (DefPathHash, hir::ItemLocalId) {
let hir::BodyId { node_id } = *self; let hir::BodyId { node_id } = *self;
node_id.to_stable_hash_key(hcx) node_id.to_stable_hash_key(hcx)
@ -966,9 +966,9 @@ impl_stable_hash_for!(struct hir::InlineAsmOutput {
is_indirect is_indirect
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> for hir::GlobalAsm { impl<'a> HashStable<StableHashingContext<'a>> for hir::GlobalAsm {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let hir::GlobalAsm { let hir::GlobalAsm {
asm, asm,
@ -979,9 +979,9 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for hir::GlobalAsm {
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for hir::InlineAsm { impl<'a> HashStable<StableHashingContext<'a>> for hir::InlineAsm {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let hir::InlineAsm { let hir::InlineAsm {
asm, asm,
@ -1062,22 +1062,22 @@ impl_stable_hash_for!(enum hir::Constness {
NotConst NotConst
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> impl<'a> HashStable<StableHashingContext<'a>>
for hir::def_id::DefIndex { for hir::def_id::DefIndex {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
hcx.local_def_path_hash(*self).hash_stable(hcx, hasher); hcx.local_def_path_hash(*self).hash_stable(hcx, hasher);
} }
} }
impl<'gcx> ToStableHashKey<StableHashingContext<'gcx>> impl<'a> ToStableHashKey<StableHashingContext<'a>>
for hir::def_id::DefIndex { for hir::def_id::DefIndex {
type KeyType = DefPathHash; type KeyType = DefPathHash;
#[inline] #[inline]
fn to_stable_hash_key(&self, hcx: &StableHashingContext<'gcx>) -> DefPathHash { fn to_stable_hash_key(&self, hcx: &StableHashingContext<'a>) -> DefPathHash {
hcx.local_def_path_hash(*self) hcx.local_def_path_hash(*self)
} }
} }
@ -1090,10 +1090,10 @@ impl_stable_hash_for!(struct hir::def::Export {
is_import is_import
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> impl<'a> HashStable<StableHashingContext<'a>>
for ::middle::lang_items::LangItem { for ::middle::lang_items::LangItem {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
_: &mut StableHashingContext<'gcx>, _: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
::std::hash::Hash::hash(self, hasher); ::std::hash::Hash::hash(self, hasher);
} }
@ -1104,10 +1104,10 @@ impl_stable_hash_for!(struct ::middle::lang_items::LanguageItems {
missing missing
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> impl<'a> HashStable<StableHashingContext<'a>>
for hir::TraitCandidate { for hir::TraitCandidate {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
hcx.with_node_id_hashing_mode(NodeIdHashingMode::HashDefPath, |hcx| { hcx.with_node_id_hashing_mode(NodeIdHashingMode::HashDefPath, |hcx| {
let hir::TraitCandidate { let hir::TraitCandidate {
@ -1121,11 +1121,11 @@ for hir::TraitCandidate {
} }
} }
impl<'gcx> ToStableHashKey<StableHashingContext<'gcx>> for hir::TraitCandidate { impl<'a> ToStableHashKey<StableHashingContext<'a>> for hir::TraitCandidate {
type KeyType = (DefPathHash, Option<(DefPathHash, hir::ItemLocalId)>); type KeyType = (DefPathHash, Option<(DefPathHash, hir::ItemLocalId)>);
fn to_stable_hash_key(&self, fn to_stable_hash_key(&self,
hcx: &StableHashingContext<'gcx>) hcx: &StableHashingContext<'a>)
-> Self::KeyType { -> Self::KeyType {
let hir::TraitCandidate { let hir::TraitCandidate {
def_id, def_id,

98
src/librustc/ich/impls_mir.rs
View file

@ -35,11 +35,11 @@ impl_stable_hash_for!(struct mir::BasicBlockData<'tcx> { statements, terminator,
impl_stable_hash_for!(struct mir::UnsafetyViolation { source_info, description, kind }); impl_stable_hash_for!(struct mir::UnsafetyViolation { source_info, description, kind });
impl_stable_hash_for!(struct mir::UnsafetyCheckResult { violations, unsafe_blocks }); impl_stable_hash_for!(struct mir::UnsafetyCheckResult { violations, unsafe_blocks });
impl<'gcx> HashStable<StableHashingContext<'gcx>> impl<'a> HashStable<StableHashingContext<'a>>
for mir::BorrowKind { for mir::BorrowKind {
#[inline] #[inline]
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
@ -54,11 +54,11 @@ for mir::BorrowKind {
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> impl<'a> HashStable<StableHashingContext<'a>>
for mir::UnsafetyViolationKind { for mir::UnsafetyViolationKind {
#[inline] #[inline]
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
@ -79,12 +79,12 @@ impl_stable_hash_for!(struct mir::Terminator<'tcx> {
source_info source_info
}); });
impl<'gcx, T> HashStable<StableHashingContext<'gcx>> for mir::ClearCrossCrate<T> impl<'a, 'gcx, T> HashStable<StableHashingContext<'a>> for mir::ClearCrossCrate<T>
where T: HashStable<StableHashingContext<'gcx>> where T: HashStable<StableHashingContext<'a>>
{ {
#[inline] #[inline]
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
match *self { match *self {
@ -96,61 +96,61 @@ impl<'gcx, T> HashStable<StableHashingContext<'gcx>> for mir::ClearCrossCrate<T>
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for mir::Local { impl<'a> HashStable<StableHashingContext<'a>> for mir::Local {
#[inline] #[inline]
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
use rustc_data_structures::indexed_vec::Idx; use rustc_data_structures::indexed_vec::Idx;
self.index().hash_stable(hcx, hasher); self.index().hash_stable(hcx, hasher);
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for mir::BasicBlock { impl<'a> HashStable<StableHashingContext<'a>> for mir::BasicBlock {
#[inline] #[inline]
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
use rustc_data_structures::indexed_vec::Idx; use rustc_data_structures::indexed_vec::Idx;
self.index().hash_stable(hcx, hasher); self.index().hash_stable(hcx, hasher);
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for mir::Field { impl<'a> HashStable<StableHashingContext<'a>> for mir::Field {
#[inline] #[inline]
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
use rustc_data_structures::indexed_vec::Idx; use rustc_data_structures::indexed_vec::Idx;
self.index().hash_stable(hcx, hasher); self.index().hash_stable(hcx, hasher);
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> impl<'a> HashStable<StableHashingContext<'a>>
for mir::VisibilityScope { for mir::VisibilityScope {
#[inline] #[inline]
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
use rustc_data_structures::indexed_vec::Idx; use rustc_data_structures::indexed_vec::Idx;
self.index().hash_stable(hcx, hasher); self.index().hash_stable(hcx, hasher);
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for mir::Promoted { impl<'a> HashStable<StableHashingContext<'a>> for mir::Promoted {
#[inline] #[inline]
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
use rustc_data_structures::indexed_vec::Idx; use rustc_data_structures::indexed_vec::Idx;
self.index().hash_stable(hcx, hasher); self.index().hash_stable(hcx, hasher);
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> impl<'a, 'gcx> HashStable<StableHashingContext<'a>>
for mir::TerminatorKind<'gcx> { for mir::TerminatorKind<'gcx> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
@ -227,10 +227,10 @@ for mir::TerminatorKind<'gcx> {
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> impl<'a, 'gcx> HashStable<StableHashingContext<'a>>
for mir::AssertMessage<'gcx> { for mir::AssertMessage<'gcx> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
@ -250,10 +250,10 @@ for mir::AssertMessage<'gcx> {
impl_stable_hash_for!(struct mir::Statement<'tcx> { source_info, kind }); impl_stable_hash_for!(struct mir::Statement<'tcx> { source_info, kind });
impl<'gcx> HashStable<StableHashingContext<'gcx>> impl<'a, 'gcx> HashStable<StableHashingContext<'a>>
for mir::StatementKind<'gcx> { for mir::StatementKind<'gcx> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
@ -287,12 +287,12 @@ for mir::StatementKind<'gcx> {
} }
} }
impl<'gcx, T> HashStable<StableHashingContext<'gcx>> impl<'a, 'gcx, T> HashStable<StableHashingContext<'a>>
for mir::ValidationOperand<'gcx, T> for mir::ValidationOperand<'gcx, T>
where T: HashStable<StableHashingContext<'gcx>> where T: HashStable<StableHashingContext<'a>>
{ {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) hasher: &mut StableHasher<W>)
{ {
self.place.hash_stable(hcx, hasher); self.place.hash_stable(hcx, hasher);
@ -304,9 +304,9 @@ impl<'gcx, T> HashStable<StableHashingContext<'gcx>>
impl_stable_hash_for!(enum mir::ValidationOp { Acquire, Release, Suspend(region_scope) }); impl_stable_hash_for!(enum mir::ValidationOp { Acquire, Release, Suspend(region_scope) });
impl<'gcx> HashStable<StableHashingContext<'gcx>> for mir::Place<'gcx> { impl<'a, 'gcx> HashStable<StableHashingContext<'a>> for mir::Place<'gcx> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
match *self { match *self {
@ -323,14 +323,14 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for mir::Place<'gcx> {
} }
} }
impl<'gcx, B, V, T> HashStable<StableHashingContext<'gcx>> impl<'a, 'gcx, B, V, T> HashStable<StableHashingContext<'a>>
for mir::Projection<'gcx, B, V, T> for mir::Projection<'gcx, B, V, T>
where B: HashStable<StableHashingContext<'gcx>>, where B: HashStable<StableHashingContext<'a>>,
V: HashStable<StableHashingContext<'gcx>>, V: HashStable<StableHashingContext<'a>>,
T: HashStable<StableHashingContext<'gcx>> T: HashStable<StableHashingContext<'a>>
{ {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let mir::Projection { let mir::Projection {
ref base, ref base,
@ -342,13 +342,13 @@ for mir::Projection<'gcx, B, V, T>
} }
} }
impl<'gcx, V, T> HashStable<StableHashingContext<'gcx>> impl<'a, 'gcx, V, T> HashStable<StableHashingContext<'a>>
for mir::ProjectionElem<'gcx, V, T> for mir::ProjectionElem<'gcx, V, T>
where V: HashStable<StableHashingContext<'gcx>>, where V: HashStable<StableHashingContext<'a>>,
T: HashStable<StableHashingContext<'gcx>> T: HashStable<StableHashingContext<'a>>
{ {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
match *self { match *self {
@ -382,9 +382,9 @@ impl_stable_hash_for!(struct mir::VisibilityScopeInfo {
lint_root, safety lint_root, safety
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> for mir::Safety { impl<'a> HashStable<StableHashingContext<'a>> for mir::Safety {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
@ -399,9 +399,9 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for mir::Safety {
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for mir::Operand<'gcx> { impl<'a, 'gcx> HashStable<StableHashingContext<'a>> for mir::Operand<'gcx> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
@ -419,9 +419,9 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for mir::Operand<'gcx> {
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for mir::Rvalue<'gcx> { impl<'a, 'gcx> HashStable<StableHashingContext<'a>> for mir::Rvalue<'gcx> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
@ -479,10 +479,10 @@ impl_stable_hash_for!(enum mir::CastKind {
Unsize Unsize
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> impl<'a, 'gcx> HashStable<StableHashingContext<'a>>
for mir::AggregateKind<'gcx> { for mir::AggregateKind<'gcx> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
match *self { match *self {
@ -541,9 +541,9 @@ impl_stable_hash_for!(enum mir::NullOp {
impl_stable_hash_for!(struct mir::Constant<'tcx> { span, ty, literal }); impl_stable_hash_for!(struct mir::Constant<'tcx> { span, ty, literal });
impl<'gcx> HashStable<StableHashingContext<'gcx>> for mir::Literal<'gcx> { impl<'a, 'gcx> HashStable<StableHashingContext<'a>> for mir::Literal<'gcx> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
match *self { match *self {
@ -570,9 +570,9 @@ impl_stable_hash_for!(struct mir::ClosureOutlivesRequirement<'tcx> {
blame_span blame_span
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> for mir::ClosureOutlivesSubject<'gcx> { impl<'a, 'gcx> HashStable<StableHashingContext<'a>> for mir::ClosureOutlivesSubject<'gcx> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
match *self { match *self {

48
src/librustc/ich/impls_syntax.rs
View file

@ -29,42 +29,42 @@ use rustc_data_structures::stable_hasher::{HashStable, ToStableHashKey,
StableHasher, StableHasherResult}; StableHasher, StableHasherResult};
use rustc_data_structures::accumulate_vec::AccumulateVec; use rustc_data_structures::accumulate_vec::AccumulateVec;
impl<'gcx> HashStable<StableHashingContext<'gcx>> for InternedString { impl<'a> HashStable<StableHashingContext<'a>> for InternedString {
#[inline] #[inline]
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let s: &str = &**self; let s: &str = &**self;
s.hash_stable(hcx, hasher); s.hash_stable(hcx, hasher);
} }
} }
impl<'gcx> ToStableHashKey<StableHashingContext<'gcx>> for InternedString { impl<'a> ToStableHashKey<StableHashingContext<'a>> for InternedString {
type KeyType = InternedString; type KeyType = InternedString;
#[inline] #[inline]
fn to_stable_hash_key(&self, fn to_stable_hash_key(&self,
_: &StableHashingContext<'gcx>) _: &StableHashingContext<'a>)
-> InternedString { -> InternedString {
self.clone() self.clone()
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for ast::Name { impl<'a> HashStable<StableHashingContext<'a>> for ast::Name {
#[inline] #[inline]
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
self.as_str().hash_stable(hcx, hasher); self.as_str().hash_stable(hcx, hasher);
} }
} }
impl<'gcx> ToStableHashKey<StableHashingContext<'gcx>> for ast::Name { impl<'a> ToStableHashKey<StableHashingContext<'a>> for ast::Name {
type KeyType = InternedString; type KeyType = InternedString;
#[inline] #[inline]
fn to_stable_hash_key(&self, fn to_stable_hash_key(&self,
_: &StableHashingContext<'gcx>) _: &StableHashingContext<'a>)
-> InternedString { -> InternedString {
self.as_str() self.as_str()
} }
@ -111,10 +111,10 @@ impl_stable_hash_for!(struct ::syntax::attr::Stability {
rustc_const_unstable rustc_const_unstable
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> impl<'a> HashStable<StableHashingContext<'a>>
for ::syntax::attr::StabilityLevel { for ::syntax::attr::StabilityLevel {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
match *self { match *self {
@ -166,9 +166,9 @@ impl_stable_hash_for!(struct ::syntax::ast::Lifetime { id, span, ident });
impl_stable_hash_for!(enum ::syntax::ast::StrStyle { Cooked, Raw(pounds) }); impl_stable_hash_for!(enum ::syntax::ast::StrStyle { Cooked, Raw(pounds) });
impl_stable_hash_for!(enum ::syntax::ast::AttrStyle { Outer, Inner }); impl_stable_hash_for!(enum ::syntax::ast::AttrStyle { Outer, Inner });
impl<'gcx> HashStable<StableHashingContext<'gcx>> for [ast::Attribute] { impl<'a> HashStable<StableHashingContext<'a>> for [ast::Attribute] {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
if self.len() == 0 { if self.len() == 0 {
self.len().hash_stable(hcx, hasher); self.len().hash_stable(hcx, hasher);
@ -191,9 +191,9 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for [ast::Attribute] {
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for ast::Attribute { impl<'a> HashStable<StableHashingContext<'a>> for ast::Attribute {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
// Make sure that these have been filtered out. // Make sure that these have been filtered out.
debug_assert!(self.name().map(|name| !hcx.is_ignored_attr(name)).unwrap_or(true)); debug_assert!(self.name().map(|name| !hcx.is_ignored_attr(name)).unwrap_or(true));
@ -220,10 +220,10 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for ast::Attribute {
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> impl<'a> HashStable<StableHashingContext<'a>>
for tokenstream::TokenTree { for tokenstream::TokenTree {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
match *self { match *self {
@ -242,10 +242,10 @@ for tokenstream::TokenTree {
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> impl<'a> HashStable<StableHashingContext<'a>>
for tokenstream::TokenStream { for tokenstream::TokenStream {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
for sub_tt in self.trees() { for sub_tt in self.trees() {
sub_tt.hash_stable(hcx, hasher); sub_tt.hash_stable(hcx, hasher);
@ -253,9 +253,11 @@ for tokenstream::TokenStream {
} }
} }
fn hash_token<'gcx, W: StableHasherResult>(token: &token::Token, fn hash_token<'a, 'gcx, W: StableHasherResult>(
hcx: &mut StableHashingContext<'gcx>, token: &token::Token,
hasher: &mut StableHasher<W>) { hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>,
) {
mem::discriminant(token).hash_stable(hcx, hasher); mem::discriminant(token).hash_stable(hcx, hasher);
match *token { match *token {
token::Token::Eq | token::Token::Eq |
@ -383,9 +385,9 @@ impl_stable_hash_for!(enum ::syntax_pos::FileName {
Custom(s) Custom(s)
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> for FileMap { impl<'a> HashStable<StableHashingContext<'a>> for FileMap {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let FileMap { let FileMap {
name: _, // We hash the smaller name_hash instead of this name: _, // We hash the smaller name_hash instead of this

206
src/librustc/ich/impls_ty.rs
View file

@ -23,11 +23,11 @@ use traits;
use ty; use ty;
use mir; use mir;
impl<'gcx, T> HashStable<StableHashingContext<'gcx>> impl<'a, 'gcx, T> HashStable<StableHashingContext<'a>>
for &'gcx ty::Slice<T> for &'gcx ty::Slice<T>
where T: HashStable<StableHashingContext<'gcx>> { where T: HashStable<StableHashingContext<'a>> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
thread_local! { thread_local! {
static CACHE: RefCell<FxHashMap<(usize, usize), Fingerprint>> = static CACHE: RefCell<FxHashMap<(usize, usize), Fingerprint>> =
@ -52,10 +52,10 @@ for &'gcx ty::Slice<T>
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> impl<'a, 'gcx> HashStable<StableHashingContext<'a>>
for ty::subst::Kind<'gcx> { for ty::subst::Kind<'gcx> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
self.unpack().hash_stable(hcx, hasher); self.unpack().hash_stable(hcx, hasher);
} }
@ -73,10 +73,10 @@ for ty::subst::UnpackedKind<'gcx> {
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> impl<'a> HashStable<StableHashingContext<'a>>
for ty::RegionKind { for ty::RegionKind {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
match *self { match *self {
@ -120,20 +120,20 @@ for ty::RegionKind {
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for ty::RegionVid { impl<'a> HashStable<StableHashingContext<'a>> for ty::RegionVid {
#[inline] #[inline]
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
use rustc_data_structures::indexed_vec::Idx; use rustc_data_structures::indexed_vec::Idx;
self.index().hash_stable(hcx, hasher); self.index().hash_stable(hcx, hasher);
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> impl<'a, 'gcx> HashStable<StableHashingContext<'a>>
for ty::adjustment::AutoBorrow<'gcx> { for ty::adjustment::AutoBorrow<'gcx> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
match *self { match *self {
@ -148,10 +148,10 @@ for ty::adjustment::AutoBorrow<'gcx> {
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> impl<'a, 'gcx> HashStable<StableHashingContext<'a>>
for ty::adjustment::Adjust<'gcx> { for ty::adjustment::Adjust<'gcx> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
match *self { match *self {
@ -197,10 +197,10 @@ impl_stable_hash_for!(enum ty::BorrowKind {
MutBorrow MutBorrow
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> impl<'a, 'gcx> HashStable<StableHashingContext<'a>>
for ty::UpvarCapture<'gcx> { for ty::UpvarCapture<'gcx> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
match *self { match *self {
@ -224,11 +224,11 @@ impl_stable_hash_for!(struct ty::FnSig<'tcx> {
abi abi
}); });
impl<'gcx, T> HashStable<StableHashingContext<'gcx>> for ty::Binder<T> impl<'a, 'gcx, T> HashStable<StableHashingContext<'a>> for ty::Binder<T>
where T: HashStable<StableHashingContext<'gcx>> where T: HashStable<StableHashingContext<'a>>
{ {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let ty::Binder(ref inner) = *self; let ty::Binder(ref inner) = *self;
inner.hash_stable(hcx, hasher); inner.hash_stable(hcx, hasher);
@ -247,13 +247,13 @@ impl_stable_hash_for!(struct ty::TraitRef<'tcx> { def_id, substs });
impl_stable_hash_for!(struct ty::TraitPredicate<'tcx> { trait_ref }); impl_stable_hash_for!(struct ty::TraitPredicate<'tcx> { trait_ref });
impl_stable_hash_for!(struct ty::SubtypePredicate<'tcx> { a_is_expected, a, b }); impl_stable_hash_for!(struct ty::SubtypePredicate<'tcx> { a_is_expected, a, b });
impl<'gcx, A, B> HashStable<StableHashingContext<'gcx>> impl<'a, 'gcx, A, B> HashStable<StableHashingContext<'a>>
for ty::OutlivesPredicate<A, B> for ty::OutlivesPredicate<A, B>
where A: HashStable<StableHashingContext<'gcx>>, where A: HashStable<StableHashingContext<'a>>,
B: HashStable<StableHashingContext<'gcx>>, B: HashStable<StableHashingContext<'a>>,
{ {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let ty::OutlivesPredicate(ref a, ref b) = *self; let ty::OutlivesPredicate(ref a, ref b) = *self;
a.hash_stable(hcx, hasher); a.hash_stable(hcx, hasher);
@ -265,9 +265,9 @@ impl_stable_hash_for!(struct ty::ProjectionPredicate<'tcx> { projection_ty, ty }
impl_stable_hash_for!(struct ty::ProjectionTy<'tcx> { substs, item_def_id }); impl_stable_hash_for!(struct ty::ProjectionTy<'tcx> { substs, item_def_id });
impl<'gcx> HashStable<StableHashingContext<'gcx>> for ty::Predicate<'gcx> { impl<'a, 'gcx> HashStable<StableHashingContext<'a>> for ty::Predicate<'gcx> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
match *self { match *self {
@ -305,9 +305,9 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for ty::Predicate<'gcx> {
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for ty::AdtFlags { impl<'a> HashStable<StableHashingContext<'a>> for ty::AdtFlags {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
_: &mut StableHashingContext<'gcx>, _: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
std_hash::Hash::hash(self, hasher); std_hash::Hash::hash(self, hasher);
} }
@ -332,10 +332,10 @@ impl_stable_hash_for!(struct ty::FieldDef {
vis vis
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> impl<'a, 'gcx> HashStable<StableHashingContext<'a>>
for ::middle::const_val::ConstVal<'gcx> { for ::middle::const_val::ConstVal<'gcx> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
use middle::const_val::ConstVal::*; use middle::const_val::ConstVal::*;
@ -368,7 +368,51 @@ impl_stable_hash_for!(struct mir::interpret::MemoryPointer {
offset offset
}); });
impl_stable_hash_for!(tuple_struct mir::interpret::AllocId{id}); impl<'a> HashStable<StableHashingContext<'a>> for mir::interpret::AllocId {
fn hash_stable<W: StableHasherResult>(
&self,
hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>,
) {
ty::tls::with_opt(|tcx| {
let tcx = tcx.expect("can't hash AllocIds during hir lowering");
let interner = tcx
.interpret_interner
.borrow();
if let Some(def_id) = interner.get_corresponding_static_def_id(*self) {
0.hash_stable(hcx, hasher);
// statics are unique via their DefId
def_id.hash_stable(hcx, hasher);
} else if let Some(alloc) = interner.get_alloc(*self) {
// not a static, can't be recursive, hash the allocation
1.hash_stable(hcx, hasher);
alloc.hash_stable(hcx, hasher);
} else if let Some(inst) = interner.get_fn(*self) {
2.hash_stable(hcx, hasher);
inst.hash_stable(hcx, hasher);
} else {
bug!("no allocation for {}", self);
}
});
}
}
impl<'a> HashStable<StableHashingContext<'a>> for mir::interpret::Allocation {
fn hash_stable<W: StableHasherResult>(
&self,
hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>,
) {
self.bytes.hash_stable(hcx, hasher);
for reloc in self.relocations.iter() {
reloc.hash_stable(hcx, hasher);
}
self.undef_mask.hash_stable(hcx, hasher);
self.align.hash_stable(hcx, hasher);
self.mutable.hash_stable(hcx, hasher);
}
}
impl_stable_hash_for!(struct mir::interpret::Pointer{primval}); impl_stable_hash_for!(struct mir::interpret::Pointer{primval});
impl_stable_hash_for!(enum mir::interpret::PrimVal { impl_stable_hash_for!(enum mir::interpret::PrimVal {
@ -387,10 +431,10 @@ impl_stable_hash_for!(struct ::middle::const_val::ConstEvalErr<'tcx> {
kind kind
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> impl<'a, 'gcx> HashStable<StableHashingContext<'a>>
for ::middle::const_val::ErrKind<'gcx> { for ::middle::const_val::ErrKind<'gcx> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
use middle::const_val::ErrKind::*; use middle::const_val::ErrKind::*;
@ -441,10 +485,10 @@ impl_stable_hash_for!(struct ty::GenericPredicates<'tcx> {
predicates predicates
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> impl<'a, 'gcx> HashStable<StableHashingContext<'a>>
for ::mir::interpret::EvalError<'gcx> { for ::mir::interpret::EvalError<'gcx> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
use mir::interpret::EvalErrorKind::*; use mir::interpret::EvalErrorKind::*;
@ -621,9 +665,9 @@ impl_stable_hash_for!(enum ty::adjustment::CustomCoerceUnsized {
Struct(index) Struct(index)
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> for ty::Generics { impl<'a> HashStable<StableHashingContext<'a>> for ty::Generics {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let ty::Generics { let ty::Generics {
parent, parent,
@ -649,10 +693,10 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for ty::Generics {
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> impl<'a> HashStable<StableHashingContext<'a>>
for ty::RegionParameterDef { for ty::RegionParameterDef {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let ty::RegionParameterDef { let ty::RegionParameterDef {
name, name,
@ -678,12 +722,12 @@ impl_stable_hash_for!(struct ty::TypeParameterDef {
synthetic synthetic
}); });
impl<'gcx, T> HashStable<StableHashingContext<'gcx>> impl<'a, 'gcx, T> HashStable<StableHashingContext<'a>>
for ::middle::resolve_lifetime::Set1<T> for ::middle::resolve_lifetime::Set1<T>
where T: HashStable<StableHashingContext<'gcx>> where T: HashStable<StableHashingContext<'a>>
{ {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
use middle::resolve_lifetime::Set1; use middle::resolve_lifetime::Set1;
@ -734,11 +778,11 @@ impl_stable_hash_for!(enum ty::cast::CastKind {
impl_stable_hash_for!(tuple_struct ::middle::region::FirstStatementIndex { idx }); impl_stable_hash_for!(tuple_struct ::middle::region::FirstStatementIndex { idx });
impl_stable_hash_for!(struct ::middle::region::Scope { id, code }); impl_stable_hash_for!(struct ::middle::region::Scope { id, code });
impl<'gcx> ToStableHashKey<StableHashingContext<'gcx>> for region::Scope { impl<'a> ToStableHashKey<StableHashingContext<'a>> for region::Scope {
type KeyType = region::Scope; type KeyType = region::Scope;
#[inline] #[inline]
fn to_stable_hash_key(&self, _: &StableHashingContext<'gcx>) -> region::Scope { fn to_stable_hash_key(&self, _: &StableHashingContext<'a>) -> region::Scope {
*self *self
} }
} }
@ -764,11 +808,11 @@ impl_stable_hash_for!(enum ty::BoundRegion {
BrEnv BrEnv
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> impl<'a, 'gcx> HashStable<StableHashingContext<'a>>
for ty::TypeVariants<'gcx> for ty::TypeVariants<'gcx>
{ {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
use ty::TypeVariants::*; use ty::TypeVariants::*;
@ -865,11 +909,11 @@ impl_stable_hash_for!(struct ty::TypeAndMut<'tcx> {
mutbl mutbl
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> impl<'a, 'gcx> HashStable<StableHashingContext<'a>>
for ty::ExistentialPredicate<'gcx> for ty::ExistentialPredicate<'gcx>
{ {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
match *self { match *self {
@ -902,9 +946,9 @@ impl_stable_hash_for!(struct ty::Instance<'tcx> {
substs substs
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> for ty::InstanceDef<'gcx> { impl<'a, 'gcx> HashStable<StableHashingContext<'a>> for ty::InstanceDef<'gcx> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
@ -938,9 +982,9 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for ty::InstanceDef<'gcx> {
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for ty::TraitDef { impl<'a> HashStable<StableHashingContext<'a>> for ty::TraitDef {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let ty::TraitDef { let ty::TraitDef {
// We already have the def_path_hash below, no need to hash it twice // We already have the def_path_hash below, no need to hash it twice
@ -968,9 +1012,9 @@ impl_stable_hash_for!(struct ty::DtorckConstraint<'tcx> {
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> for ty::CrateVariancesMap { impl<'a> HashStable<StableHashingContext<'a>> for ty::CrateVariancesMap {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let ty::CrateVariancesMap { let ty::CrateVariancesMap {
ref variances, ref variances,
@ -1004,12 +1048,12 @@ impl_stable_hash_for!(enum ty::AssociatedItemContainer {
}); });
impl<'gcx, T> HashStable<StableHashingContext<'gcx>> impl<'a, 'gcx, T> HashStable<StableHashingContext<'a>>
for ty::steal::Steal<T> for ty::steal::Steal<T>
where T: HashStable<StableHashingContext<'gcx>> where T: HashStable<StableHashingContext<'a>>
{ {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
self.borrow().hash_stable(hcx, hasher); self.borrow().hash_stable(hcx, hasher);
} }
@ -1032,10 +1076,10 @@ impl_stable_hash_for!(enum ::middle::privacy::AccessLevel {
Public Public
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> impl<'a> HashStable<StableHashingContext<'a>>
for ::middle::privacy::AccessLevels { for ::middle::privacy::AccessLevels {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
hcx.with_node_id_hashing_mode(NodeIdHashingMode::HashDefPath, |hcx| { hcx.with_node_id_hashing_mode(NodeIdHashingMode::HashDefPath, |hcx| {
let ::middle::privacy::AccessLevels { let ::middle::privacy::AccessLevels {
@ -1062,10 +1106,10 @@ impl_stable_hash_for!(tuple_struct ::middle::reachable::ReachableSet {
reachable_set reachable_set
}); });
impl<'gcx, N> HashStable<StableHashingContext<'gcx>> impl<'a, 'gcx, N> HashStable<StableHashingContext<'a>>
for traits::Vtable<'gcx, N> where N: HashStable<StableHashingContext<'gcx>> { for traits::Vtable<'gcx, N> where N: HashStable<StableHashingContext<'a>> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
use traits::Vtable::*; use traits::Vtable::*;
@ -1084,10 +1128,10 @@ for traits::Vtable<'gcx, N> where N: HashStable<StableHashingContext<'gcx>> {
} }
} }
impl<'gcx, N> HashStable<StableHashingContext<'gcx>> impl<'a, 'gcx, N> HashStable<StableHashingContext<'a>>
for traits::VtableImplData<'gcx, N> where N: HashStable<StableHashingContext<'gcx>> { for traits::VtableImplData<'gcx, N> where N: HashStable<StableHashingContext<'a>> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let traits::VtableImplData { let traits::VtableImplData {
impl_def_id, impl_def_id,
@ -1100,10 +1144,10 @@ for traits::VtableImplData<'gcx, N> where N: HashStable<StableHashingContext<'gc
} }
} }
impl<'gcx, N> HashStable<StableHashingContext<'gcx>> impl<'a, 'gcx, N> HashStable<StableHashingContext<'a>>
for traits::VtableAutoImplData<N> where N: HashStable<StableHashingContext<'gcx>> { for traits::VtableAutoImplData<N> where N: HashStable<StableHashingContext<'a>> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let traits::VtableAutoImplData { let traits::VtableAutoImplData {
trait_def_id, trait_def_id,
@ -1114,10 +1158,10 @@ for traits::VtableAutoImplData<N> where N: HashStable<StableHashingContext<'gcx>
} }
} }
impl<'gcx, N> HashStable<StableHashingContext<'gcx>> impl<'a, 'gcx, N> HashStable<StableHashingContext<'a>>
for traits::VtableObjectData<'gcx, N> where N: HashStable<StableHashingContext<'gcx>> { for traits::VtableObjectData<'gcx, N> where N: HashStable<StableHashingContext<'a>> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let traits::VtableObjectData { let traits::VtableObjectData {
upcast_trait_ref, upcast_trait_ref,
@ -1130,10 +1174,10 @@ for traits::VtableObjectData<'gcx, N> where N: HashStable<StableHashingContext<'
} }
} }
impl<'gcx, N> HashStable<StableHashingContext<'gcx>> impl<'a, 'gcx, N> HashStable<StableHashingContext<'a>>
for traits::VtableBuiltinData<N> where N: HashStable<StableHashingContext<'gcx>> { for traits::VtableBuiltinData<N> where N: HashStable<StableHashingContext<'a>> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let traits::VtableBuiltinData { let traits::VtableBuiltinData {
ref nested, ref nested,
@ -1142,10 +1186,10 @@ for traits::VtableBuiltinData<N> where N: HashStable<StableHashingContext<'gcx>>
} }
} }
impl<'gcx, N> HashStable<StableHashingContext<'gcx>> impl<'a, 'gcx, N> HashStable<StableHashingContext<'a>>
for traits::VtableClosureData<'gcx, N> where N: HashStable<StableHashingContext<'gcx>> { for traits::VtableClosureData<'gcx, N> where N: HashStable<StableHashingContext<'a>> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let traits::VtableClosureData { let traits::VtableClosureData {
closure_def_id, closure_def_id,
@ -1158,10 +1202,10 @@ for traits::VtableClosureData<'gcx, N> where N: HashStable<StableHashingContext<
} }
} }
impl<'gcx, N> HashStable<StableHashingContext<'gcx>> impl<'a, 'gcx, N> HashStable<StableHashingContext<'a>>
for traits::VtableFnPointerData<'gcx, N> where N: HashStable<StableHashingContext<'gcx>> { for traits::VtableFnPointerData<'gcx, N> where N: HashStable<StableHashingContext<'a>> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let traits::VtableFnPointerData { let traits::VtableFnPointerData {
fn_ty, fn_ty,
@ -1172,10 +1216,10 @@ for traits::VtableFnPointerData<'gcx, N> where N: HashStable<StableHashingContex
} }
} }
impl<'gcx, N> HashStable<StableHashingContext<'gcx>> impl<'a, 'gcx, N> HashStable<StableHashingContext<'a>>
for traits::VtableGeneratorData<'gcx, N> where N: HashStable<StableHashingContext<'gcx>> { for traits::VtableGeneratorData<'gcx, N> where N: HashStable<StableHashingContext<'a>> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let traits::VtableGeneratorData { let traits::VtableGeneratorData {
closure_def_id, closure_def_id,

4
src/librustc/lint/levels.rs
View file

@ -394,10 +394,10 @@ impl LintLevelMap {
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for LintLevelMap { impl<'a> HashStable<StableHashingContext<'a>> for LintLevelMap {
#[inline] #[inline]
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let LintLevelMap { let LintLevelMap {
ref sets, ref sets,

16
src/librustc/macros.rs
View file

@ -73,10 +73,10 @@ macro_rules! __impl_stable_hash_field {
#[macro_export] #[macro_export]
macro_rules! impl_stable_hash_for { macro_rules! impl_stable_hash_for {
(enum $enum_name:path { $( $variant:ident $( ( $($arg:ident),* ) )* ),* }) => { (enum $enum_name:path { $( $variant:ident $( ( $($arg:ident),* ) )* ),* }) => {
impl<'tcx> ::rustc_data_structures::stable_hasher::HashStable<$crate::ich::StableHashingContext<'tcx>> for $enum_name { impl<'a, 'tcx> ::rustc_data_structures::stable_hasher::HashStable<$crate::ich::StableHashingContext<'a>> for $enum_name {
#[inline] #[inline]
fn hash_stable<W: ::rustc_data_structures::stable_hasher::StableHasherResult>(&self, fn hash_stable<W: ::rustc_data_structures::stable_hasher::StableHasherResult>(&self,
__ctx: &mut $crate::ich::StableHashingContext<'tcx>, __ctx: &mut $crate::ich::StableHashingContext<'a>,
__hasher: &mut ::rustc_data_structures::stable_hasher::StableHasher<W>) { __hasher: &mut ::rustc_data_structures::stable_hasher::StableHasher<W>) {
use $enum_name::*; use $enum_name::*;
::std::mem::discriminant(self).hash_stable(__ctx, __hasher); ::std::mem::discriminant(self).hash_stable(__ctx, __hasher);
@ -92,10 +92,10 @@ macro_rules! impl_stable_hash_for {
} }
}; };
(struct $struct_name:path { $($field:ident),* }) => { (struct $struct_name:path { $($field:ident),* }) => {
impl<'tcx> ::rustc_data_structures::stable_hasher::HashStable<$crate::ich::StableHashingContext<'tcx>> for $struct_name { impl<'a, 'tcx> ::rustc_data_structures::stable_hasher::HashStable<$crate::ich::StableHashingContext<'a>> for $struct_name {
#[inline] #[inline]
fn hash_stable<W: ::rustc_data_structures::stable_hasher::StableHasherResult>(&self, fn hash_stable<W: ::rustc_data_structures::stable_hasher::StableHasherResult>(&self,
__ctx: &mut $crate::ich::StableHashingContext<'tcx>, __ctx: &mut $crate::ich::StableHashingContext<'a>,
__hasher: &mut ::rustc_data_structures::stable_hasher::StableHasher<W>) { __hasher: &mut ::rustc_data_structures::stable_hasher::StableHasher<W>) {
let $struct_name { let $struct_name {
$(ref $field),* $(ref $field),*
@ -106,10 +106,10 @@ macro_rules! impl_stable_hash_for {
} }
}; };
(tuple_struct $struct_name:path { $($field:ident),* }) => { (tuple_struct $struct_name:path { $($field:ident),* }) => {
impl<'tcx> ::rustc_data_structures::stable_hasher::HashStable<$crate::ich::StableHashingContext<'tcx>> for $struct_name { impl<'a, 'tcx> ::rustc_data_structures::stable_hasher::HashStable<$crate::ich::StableHashingContext<'a>> for $struct_name {
#[inline] #[inline]
fn hash_stable<W: ::rustc_data_structures::stable_hasher::StableHasherResult>(&self, fn hash_stable<W: ::rustc_data_structures::stable_hasher::StableHasherResult>(&self,
__ctx: &mut $crate::ich::StableHashingContext<'tcx>, __ctx: &mut $crate::ich::StableHashingContext<'a>,
__hasher: &mut ::rustc_data_structures::stable_hasher::StableHasher<W>) { __hasher: &mut ::rustc_data_structures::stable_hasher::StableHasher<W>) {
let $struct_name ( let $struct_name (
$(ref $field),* $(ref $field),*
@ -125,11 +125,11 @@ macro_rules! impl_stable_hash_for {
macro_rules! impl_stable_hash_for_spanned { macro_rules! impl_stable_hash_for_spanned {
($T:path) => ( ($T:path) => (
impl<'tcx> HashStable<StableHashingContext<'tcx>> for ::syntax::codemap::Spanned<$T> impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for ::syntax::codemap::Spanned<$T>
{ {
#[inline] #[inline]
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'tcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
self.node.hash_stable(hcx, hasher); self.node.hash_stable(hcx, hasher);
self.span.hash_stable(hcx, hasher); self.span.hash_stable(hcx, hasher);

4
src/librustc/middle/borrowck.rs
View file

@ -20,9 +20,9 @@ pub struct BorrowCheckResult {
pub used_mut_nodes: FxHashSet<HirId>, pub used_mut_nodes: FxHashSet<HirId>,
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for BorrowCheckResult { impl<'a> HashStable<StableHashingContext<'a>> for BorrowCheckResult {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let BorrowCheckResult { let BorrowCheckResult {
ref used_mut_nodes, ref used_mut_nodes,

4
src/librustc/middle/region.rs
View file

@ -1488,9 +1488,9 @@ pub fn provide(providers: &mut Providers) {
}; };
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for ScopeTree { impl<'a> HashStable<StableHashingContext<'a>> for ScopeTree {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let ScopeTree { let ScopeTree {
root_body, root_body,

4
src/librustc/mir/cache.rs
View file

@ -35,9 +35,9 @@ impl serialize::Decodable for Cache {
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for Cache { impl<'a> HashStable<StableHashingContext<'a>> for Cache {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
_: &mut StableHashingContext<'gcx>, _: &mut StableHashingContext<'a>,
_: &mut StableHasher<W>) { _: &mut StableHasher<W>) {
// do nothing // do nothing
} }

2
src/librustc/mir/interpret/mod.rs
View file

@ -200,6 +200,8 @@ pub struct UndefMask {
len: u64, len: u64,
} }
impl_stable_hash_for!(struct mir::interpret::UndefMask{blocks, len});
impl UndefMask { impl UndefMask {
pub fn new(size: u64) -> Self { pub fn new(size: u64) -> Self {
let mut m = UndefMask { let mut m = UndefMask {

2
src/librustc/mir/mod.rs
View file

@ -1877,7 +1877,7 @@ fn fmt_const_val<W: Write>(fmt: &mut W, const_val: &ty::Const) -> fmt::Result {
} }
} }
fn print_miri_value<W: Write>(value: Value, ty: Ty, f: &mut W) -> fmt::Result { pub fn print_miri_value<W: Write>(value: Value, ty: Ty, f: &mut W) -> fmt::Result {
use ty::TypeVariants::*; use ty::TypeVariants::*;
use rustc_const_math::ConstFloat; use rustc_const_math::ConstFloat;
match (value, &ty.sty) { match (value, &ty.sty) {

8
src/librustc/mir/mono.rs
View file

@ -41,9 +41,9 @@ impl<'tcx> MonoItem<'tcx> {
} }
} }
impl<'tcx> HashStable<StableHashingContext<'tcx>> for MonoItem<'tcx> { impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for MonoItem<'tcx> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'tcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
::std::mem::discriminant(self).hash_stable(hcx, hasher); ::std::mem::discriminant(self).hash_stable(hcx, hasher);
@ -171,9 +171,9 @@ impl<'tcx> CodegenUnit<'tcx> {
} }
} }
impl<'tcx> HashStable<StableHashingContext<'tcx>> for CodegenUnit<'tcx> { impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for CodegenUnit<'tcx> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'tcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let CodegenUnit { let CodegenUnit {
ref items, ref items,

4
src/librustc/session/config.rs
View file

@ -179,10 +179,10 @@ impl_stable_hash_for!(enum self::OutputType {
DepInfo DepInfo
}); });
impl<'tcx> ToStableHashKey<StableHashingContext<'tcx>> for OutputType { impl<'a, 'tcx> ToStableHashKey<StableHashingContext<'a>> for OutputType {
type KeyType = OutputType; type KeyType = OutputType;
#[inline] #[inline]
fn to_stable_hash_key(&self, _: &StableHashingContext<'tcx>) -> Self::KeyType { fn to_stable_hash_key(&self, _: &StableHashingContext<'a>) -> Self::KeyType {
*self *self
} }
} }

4
src/librustc/traits/specialize/specialization_graph.rs
View file

@ -391,9 +391,9 @@ pub fn ancestors(tcx: TyCtxt,
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for Children { impl<'a> HashStable<StableHashingContext<'a>> for Children {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let Children { let Children {
ref nonblanket_impls, ref nonblanket_impls,

6
src/librustc/ty/context.rs
View file

@ -676,9 +676,9 @@ impl<'tcx> TypeckTables<'tcx> {
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for TypeckTables<'gcx> { impl<'a, 'gcx> HashStable<StableHashingContext<'a>> for TypeckTables<'gcx> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let ty::TypeckTables { let ty::TypeckTables {
local_id_root, local_id_root,
@ -1366,7 +1366,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
self.cstore.crate_data_as_rc_any(cnum) self.cstore.crate_data_as_rc_any(cnum)
} }
pub fn create_stable_hashing_context(self) -> StableHashingContext<'gcx> { pub fn create_stable_hashing_context(self) -> StableHashingContext<'a> {
let krate = self.dep_graph.with_ignore(|| self.gcx.hir.krate()); let krate = self.dep_graph.with_ignore(|| self.gcx.hir.krate());
StableHashingContext::new(self.sess, StableHashingContext::new(self.sess,

6
src/librustc/ty/fast_reject.rs
View file

@ -154,12 +154,12 @@ impl<D: Copy + Debug + Ord + Eq + Hash> SimplifiedTypeGen<D> {
} }
} }
impl<'gcx, D> HashStable<StableHashingContext<'gcx>> for SimplifiedTypeGen<D> impl<'a, 'gcx, D> HashStable<StableHashingContext<'a>> for SimplifiedTypeGen<D>
where D: Copy + Debug + Ord + Eq + Hash + where D: Copy + Debug + Ord + Eq + Hash +
HashStable<StableHashingContext<'gcx>>, HashStable<StableHashingContext<'a>>,
{ {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
match *self { match *self {

20
src/librustc/ty/layout.rs
View file

@ -2369,9 +2369,9 @@ impl<'a, 'tcx> TyLayout<'tcx> {
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for Variants { impl<'a> HashStable<StableHashingContext<'a>> for Variants {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
use ty::layout::Variants::*; use ty::layout::Variants::*;
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
@ -2405,9 +2405,9 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for Variants {
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for FieldPlacement { impl<'a> HashStable<StableHashingContext<'a>> for FieldPlacement {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
use ty::layout::FieldPlacement::*; use ty::layout::FieldPlacement::*;
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
@ -2428,9 +2428,9 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for FieldPlacement {
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for Abi { impl<'a> HashStable<StableHashingContext<'a>> for Abi {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
use ty::layout::Abi::*; use ty::layout::Abi::*;
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
@ -2455,9 +2455,9 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for Abi {
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for Scalar { impl<'a> HashStable<StableHashingContext<'a>> for Scalar {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let Scalar { value, valid_range: RangeInclusive { start, end } } = *self; let Scalar { value, valid_range: RangeInclusive { start, end } } = *self;
value.hash_stable(hcx, hasher); value.hash_stable(hcx, hasher);
@ -2498,10 +2498,10 @@ impl_stable_hash_for!(struct ::ty::layout::Size {
raw raw
}); });
impl<'gcx> HashStable<StableHashingContext<'gcx>> for LayoutError<'gcx> impl<'a, 'gcx> HashStable<StableHashingContext<'a>> for LayoutError<'gcx>
{ {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
use ty::layout::LayoutError::*; use ty::layout::LayoutError::*;
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);

16
src/librustc/ty/mod.rs
View file

@ -80,7 +80,7 @@ pub use self::binding::BindingMode;
pub use self::binding::BindingMode::*; pub use self::binding::BindingMode::*;
pub use self::context::{TyCtxt, GlobalArenas, AllArenas, tls, keep_local}; pub use self::context::{TyCtxt, GlobalArenas, AllArenas, tls, keep_local};
pub use self::context::{Lift, TypeckTables}; pub use self::context::{Lift, TypeckTables, InterpretInterner};
pub use self::instance::{Instance, InstanceDef}; pub use self::instance::{Instance, InstanceDef};
@ -529,9 +529,9 @@ impl<'tcx> TyS<'tcx> {
} }
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for ty::TyS<'gcx> { impl<'a, 'gcx> HashStable<StableHashingContext<'a>> for ty::TyS<'gcx> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let ty::TyS { let ty::TyS {
ref sty, ref sty,
@ -1440,11 +1440,11 @@ impl<'tcx, T> ParamEnvAnd<'tcx, T> {
} }
} }
impl<'gcx, T> HashStable<StableHashingContext<'gcx>> for ParamEnvAnd<'gcx, T> impl<'a, 'gcx, T> HashStable<StableHashingContext<'a>> for ParamEnvAnd<'gcx, T>
where T: HashStable<StableHashingContext<'gcx>> where T: HashStable<StableHashingContext<'a>>
{ {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let ParamEnvAnd { let ParamEnvAnd {
ref param_env, ref param_env,
@ -1545,9 +1545,9 @@ impl<'tcx> serialize::UseSpecializedEncodable for &'tcx AdtDef {
impl<'tcx> serialize::UseSpecializedDecodable for &'tcx AdtDef {} impl<'tcx> serialize::UseSpecializedDecodable for &'tcx AdtDef {}
impl<'gcx> HashStable<StableHashingContext<'gcx>> for AdtDef { impl<'a> HashStable<StableHashingContext<'a>> for AdtDef {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
thread_local! { thread_local! {
static CACHE: RefCell<FxHashMap<usize, Fingerprint>> = static CACHE: RefCell<FxHashMap<usize, Fingerprint>> =

4
src/librustc/ty/trait_def.rs
View file

@ -186,9 +186,9 @@ pub(super) fn trait_impls_of_provider<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
}) })
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for TraitImpls { impl<'a> HashStable<StableHashingContext<'a>> for TraitImpls {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let TraitImpls { let TraitImpls {
ref blanket_impls, ref blanket_impls,

8
src/librustc_metadata/schema.rs
View file

@ -227,9 +227,9 @@ pub struct TraitImpls {
pub impls: LazySeq<DefIndex>, pub impls: LazySeq<DefIndex>,
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for TraitImpls { impl<'a, 'gcx> HashStable<StableHashingContext<'a>> for TraitImpls {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
let TraitImpls { let TraitImpls {
trait_id: (krate, def_index), trait_id: (krate, def_index),
@ -310,9 +310,9 @@ pub enum EntryKind<'tcx> {
AssociatedConst(AssociatedContainer, u8), AssociatedConst(AssociatedContainer, u8),
} }
impl<'gcx> HashStable<StableHashingContext<'gcx>> for EntryKind<'gcx> { impl<'a, 'gcx> HashStable<StableHashingContext<'a>> for EntryKind<'gcx> {
fn hash_stable<W: StableHasherResult>(&self, fn hash_stable<W: StableHasherResult>(&self,
hcx: &mut StableHashingContext<'gcx>, hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>) { hasher: &mut StableHasher<W>) {
mem::discriminant(self).hash_stable(hcx, hasher); mem::discriminant(self).hash_stable(hcx, hasher);
match *self { match *self {

144
src/librustc_mir/build/matches/test.rs
View file

@ -20,12 +20,10 @@ use build::matches::{Candidate, MatchPair, Test, TestKind};
use hair::*; use hair::*;
use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::bitvec::BitVector; use rustc_data_structures::bitvec::BitVector;
use rustc::middle::const_val::ConstVal;
use rustc::ty::{self, Ty}; use rustc::ty::{self, Ty};
use rustc::ty::util::IntTypeExt; use rustc::ty::util::IntTypeExt;
use rustc::mir::*; use rustc::mir::*;
use rustc::mir::interpret::{Value, PrimVal}; use rustc::hir::{RangeEnd, Mutability};
use rustc::hir::RangeEnd;
use syntax_pos::Span; use syntax_pos::Span;
use std::cmp::Ordering; use std::cmp::Ordering;
@ -297,76 +295,86 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
TestKind::Eq { value, ty } => { TestKind::Eq { value, ty } => {
let tcx = self.hir.tcx(); let tcx = self.hir.tcx();
let mut val = Operand::Copy(place.clone()); let mut val = Operand::Copy(place.clone());
let mut expect = self.literal_operand(test.span, ty, Literal::Value {
let bytes = match value.val { value
ConstVal::Value(Value::ByVal(PrimVal::Ptr(p))) => { });
let is_array_ptr = ty // Use PartialEq::eq instead of BinOp::Eq
.builtin_deref(true, ty::NoPreference) // (the binop can only handle primitives)
.and_then(|t| t.ty.builtin_index())
.map_or(false, |t| t == self.hir.tcx().types.u8);
if is_array_ptr {
self.hir
.tcx()
.interpret_interner
.borrow()
.get_alloc(p.alloc_id)
.map(|alloc| &alloc.bytes[..])
} else {
None
}
},
_ => None,
};
// If we're using b"..." as a pattern, we need to insert an
// unsizing coercion, as the byte string has the type &[u8; N].
//
// We want to do this even when the scrutinee is a reference to an
// array, so we can call `<[u8]>::eq` rather than having to find an
// `<[u8; N]>::eq`.
let expect = if let Some(bytes) = bytes {
let tcx = self.hir.tcx();
// Unsize the place to &[u8], too, if necessary.
if let ty::TyRef(region, mt) = ty.sty {
if let ty::TyArray(_, _) = mt.ty.sty {
ty = tcx.mk_imm_ref(region, tcx.mk_slice(tcx.types.u8));
let val_slice = self.temp(ty, test.span);
self.cfg.push_assign(block, source_info, &val_slice,
Rvalue::Cast(CastKind::Unsize, val, ty));
val = Operand::Move(val_slice);
}
}
assert!(ty.is_slice());
let array_ty = tcx.mk_array(tcx.types.u8, bytes.len() as u64);
let array_ref = tcx.mk_imm_ref(tcx.types.re_static, array_ty);
let array = self.literal_operand(test.span, array_ref, Literal::Value {
value
});
let val = self.to_slice_operand(block, source_info, val);
let slice = self.to_slice_operand(block, source_info, array);
(slice, val)
} else {
(self.literal_operand(test.span, ty, Literal::Value {
value
}), val)
};
// Use PartialEq::eq for &str and &[u8] slices, instead of BinOp::Eq.
let fail = self.cfg.start_new_block(); let fail = self.cfg.start_new_block();
let str_or_bytestr = ty if !ty.is_scalar() {
.builtin_deref(true, ty::NoPreference) // If we're using b"..." as a pattern, we need to insert an
.and_then(|tam| match tam.ty.sty { // unsizing coercion, as the byte string has the type &[u8; N].
ty::TyStr => Some(tam.ty), //
ty::TySlice(inner) if inner == self.hir.tcx().types.u8 => Some(tam.ty), // We want to do this even when the scrutinee is a reference to an
// array, so we can call `<[u8]>::eq` rather than having to find an
// `<[u8; N]>::eq`.
let unsize = |ty: Ty<'tcx>| match ty.sty {
ty::TyRef(region, tam) => match tam.ty.sty {
ty::TyArray(inner_ty, n) => Some((region, inner_ty, n)),
_ => None,
},
_ => None, _ => None,
}); };
if let Some(ty) = str_or_bytestr { let opt_ref_ty = unsize(ty);
let opt_ref_test_ty = unsize(value.ty);
let mut place = place.clone();
match (opt_ref_ty, opt_ref_test_ty) {
// nothing to do, neither is an array
(None, None) => {},
(Some((region, elem_ty, _)), _) |
(None, Some((region, elem_ty, _))) => {
let tcx = self.hir.tcx();
// make both a slice
ty = tcx.mk_imm_ref(region, tcx.mk_slice(elem_ty));
if opt_ref_ty.is_some() {
place = self.temp(ty, test.span);
self.cfg.push_assign(block, source_info, &place,
Rvalue::Cast(CastKind::Unsize, val, ty));
}
if opt_ref_test_ty.is_some() {
let array = self.literal_operand(
test.span,
value.ty,
Literal::Value {
value
},
);
let slice = self.temp(ty, test.span);
self.cfg.push_assign(block, source_info, &slice,
Rvalue::Cast(CastKind::Unsize, array, ty));
expect = Operand::Move(slice);
}
},
}
let eq_def_id = self.hir.tcx().lang_items().eq_trait().unwrap(); let eq_def_id = self.hir.tcx().lang_items().eq_trait().unwrap();
let (mty, method) = self.hir.trait_method(eq_def_id, "eq", ty, &[ty]); let (mty, method) = self.hir.trait_method(eq_def_id, "eq", ty, &[ty]);
// take the argument by reference
let region_scope = self.topmost_scope();
let region = self.hir.tcx().mk_region(ty::ReScope(region_scope));
let tam = ty::TypeAndMut {
ty,
mutbl: Mutability::MutImmutable,
};
let ref_ty = self.hir.tcx().mk_ref(region, tam);
// let lhs_ref_place = &lhs;
let ref_rvalue = Rvalue::Ref(region, BorrowKind::Shared, place.clone());
let lhs_ref_place = self.temp(ref_ty, test.span);
self.cfg.push_assign(block, source_info, &lhs_ref_place, ref_rvalue);
let val = Operand::Move(lhs_ref_place);
// let rhs_place = rhs;
let rhs_place = self.temp(ty, test.span);
self.cfg.push_assign(block, source_info, &rhs_place, Rvalue::Use(expect));
// let rhs_ref_place = &rhs_place;
let ref_rvalue = Rvalue::Ref(region, BorrowKind::Shared, rhs_place);
let rhs_ref_place = self.temp(ref_ty, test.span);
self.cfg.push_assign(block, source_info, &rhs_ref_place, ref_rvalue);
let expect = Operand::Move(rhs_ref_place);
let bool_ty = self.hir.bool_ty(); let bool_ty = self.hir.bool_ty();
let eq_result = self.temp(bool_ty, test.span); let eq_result = self.temp(bool_ty, test.span);
let eq_block = self.cfg.start_new_block(); let eq_block = self.cfg.start_new_block();

30
src/librustc_mir/diagnostics.rs
View file

@ -72,36 +72,6 @@ fn foo(x: Option<String>) {
``` ```
"##, "##,
E0003: r##"
#### Note: this error code is no longer emitted by the compiler.
Not-a-Number (NaN) values cannot be compared for equality and hence can never
match the input to a match expression. So, the following will not compile:
```compile_fail
const NAN: f32 = 0.0 / 0.0;
let number = 0.1f32;
match number {
NAN => { /* ... */ },
_ => {}
}
```
To match against NaN values, you should instead use the `is_nan()` method in a
guard, like so:
```
let number = 0.1f32;
match number {
x if x.is_nan() => { /* ... */ }
_ => {}
}
```
"##,
E0004: r##" E0004: r##"
This error indicates that the compiler cannot guarantee a matching pattern for This error indicates that the compiler cannot guarantee a matching pattern for
one or more possible inputs to a match expression. Guaranteed matches are one or more possible inputs to a match expression. Guaranteed matches are

9
src/librustc_mir/interpret/const_eval.rs
View file

@ -19,6 +19,7 @@ pub fn mk_borrowck_eval_cx<'a, 'mir, 'tcx>(
tcx: TyCtxt<'a, 'tcx, 'tcx>, tcx: TyCtxt<'a, 'tcx, 'tcx>,
instance: Instance<'tcx>, instance: Instance<'tcx>,
mir: &'mir mir::Mir<'tcx>, mir: &'mir mir::Mir<'tcx>,
span: Span,
) -> EvalResult<'tcx, EvalContext<'a, 'mir, 'tcx, CompileTimeEvaluator>> { ) -> EvalResult<'tcx, EvalContext<'a, 'mir, 'tcx, CompileTimeEvaluator>> {
debug!("mk_borrowck_eval_cx: {:?}", instance); debug!("mk_borrowck_eval_cx: {:?}", instance);
let param_env = tcx.param_env(instance.def_id()); let param_env = tcx.param_env(instance.def_id());
@ -27,7 +28,7 @@ pub fn mk_borrowck_eval_cx<'a, 'mir, 'tcx>(
// insert a stack frame so any queries have the correct substs // insert a stack frame so any queries have the correct substs
ecx.push_stack_frame( ecx.push_stack_frame(
instance, instance,
mir.span, span,
mir, mir,
Place::undef(), Place::undef(),
StackPopCleanup::None, StackPopCleanup::None,
@ -65,7 +66,7 @@ pub fn eval_body_with_mir<'a, 'mir, 'tcx>(
match res { match res {
Ok(val) => Some(val), Ok(val) => Some(val),
Err(mut err) => { Err(mut err) => {
ecx.report(&mut err, true); ecx.report(&mut err, true, None);
None None
} }
} }
@ -80,7 +81,7 @@ pub fn eval_body<'a, 'tcx>(
match res { match res {
Ok(val) => Some(val), Ok(val) => Some(val),
Err(mut err) => { Err(mut err) => {
ecx.report(&mut err, true); ecx.report(&mut err, true, None);
None None
} }
} }
@ -483,7 +484,7 @@ pub fn const_eval_provider<'a, 'tcx>(
}) })
}).map_err(|mut err| { }).map_err(|mut err| {
if tcx.is_static(def_id).is_some() { if tcx.is_static(def_id).is_some() {
ecx.report(&mut err, true); ecx.report(&mut err, true, None);
} }
ConstEvalErr { ConstEvalErr {
kind: err.into(), kind: err.into(),

14
src/librustc_mir/interpret/eval_context.rs
View file

@ -10,7 +10,7 @@ use rustc::ty::layout::{self, Size, Align, HasDataLayout, LayoutOf, TyLayout};
use rustc::ty::subst::{Subst, Substs}; use rustc::ty::subst::{Subst, Substs};
use rustc::ty::{self, Ty, TyCtxt}; use rustc::ty::{self, Ty, TyCtxt};
use rustc_data_structures::indexed_vec::Idx; use rustc_data_structures::indexed_vec::Idx;
use syntax::codemap::{self, DUMMY_SP}; use syntax::codemap::{self, DUMMY_SP, Span};
use syntax::ast::Mutability; use syntax::ast::Mutability;
use rustc::mir::interpret::{ use rustc::mir::interpret::{
GlobalId, Value, Pointer, PrimVal, PrimValKind, GlobalId, Value, Pointer, PrimVal, PrimValKind,
@ -464,7 +464,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
StackPopCleanup::MarkStatic(mutable) => { StackPopCleanup::MarkStatic(mutable) => {
if let Place::Ptr { ptr, .. } = frame.return_place { if let Place::Ptr { ptr, .. } = frame.return_place {
// FIXME: to_ptr()? might be too extreme here, static zsts might reach this under certain conditions // FIXME: to_ptr()? might be too extreme here, static zsts might reach this under certain conditions
self.memory.mark_static_initalized( self.memory.mark_static_initialized(
ptr.to_ptr()?.alloc_id, ptr.to_ptr()?.alloc_id,
mutable, mutable,
)? )?
@ -1572,7 +1572,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
Ok(()) Ok(())
} }
pub fn report(&self, e: &mut EvalError, as_err: bool) { pub fn report(&self, e: &mut EvalError, as_err: bool, explicit_span: Option<Span>) {
if let EvalErrorKind::TypeckError = e.kind { if let EvalErrorKind::TypeckError = e.kind {
return; return;
} }
@ -1608,11 +1608,12 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
} }
if let Some(frame) = self.stack().last() { if let Some(frame) = self.stack().last() {
let block = &frame.mir.basic_blocks()[frame.block]; let block = &frame.mir.basic_blocks()[frame.block];
let span = if frame.stmt < block.statements.len() { let span = explicit_span.unwrap_or_else(|| if frame.stmt < block.statements.len() {
block.statements[frame.stmt].source_info.span block.statements[frame.stmt].source_info.span
} else { } else {
block.terminator().source_info.span block.terminator().source_info.span
}; });
trace!("reporting const eval failure at {:?}", span);
let node_id = self let node_id = self
.stack() .stack()
.iter() .iter()
@ -1634,6 +1635,9 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
let mut last_span = None; let mut last_span = None;
for &Frame { instance, span, .. } in self.stack().iter().rev() { for &Frame { instance, span, .. } in self.stack().iter().rev() {
// make sure we don't emit frames that are duplicates of the previous // make sure we don't emit frames that are duplicates of the previous
if explicit_span == Some(span) {
continue;
}
if let Some(last) = last_span { if let Some(last) = last_span {
if last == span { if last == span {
continue; continue;

6
src/librustc_mir/interpret/memory.rs
View file

@ -520,18 +520,18 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'a, 'mir, 'tcx, M> {
// do not go into statics // do not go into statics
None => Ok(()), None => Ok(()),
// just locals and machine allocs // just locals and machine allocs
Some(_) => self.mark_static_initalized(alloc, mutability), Some(_) => self.mark_static_initialized(alloc, mutability),
} }
} }
/// mark an allocation as static and initialized, either mutable or not /// mark an allocation as static and initialized, either mutable or not
pub fn mark_static_initalized( pub fn mark_static_initialized(
&mut self, &mut self,
alloc_id: AllocId, alloc_id: AllocId,
mutability: Mutability, mutability: Mutability,
) -> EvalResult<'tcx> { ) -> EvalResult<'tcx> {
trace!( trace!(
"mark_static_initalized {:?}, mutability: {:?}", "mark_static_initialized {:?}, mutability: {:?}",
alloc_id, alloc_id,
mutability mutability
); );

2
src/librustc_mir/interpret/traits.rs
View file

@ -52,7 +52,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
} }
} }
self.memory.mark_static_initalized( self.memory.mark_static_initialized(
vtable.alloc_id, vtable.alloc_id,
Mutability::Immutable, Mutability::Immutable,
)?; )?;

54
src/librustc_mir/transform/instcombine.rs
View file

@ -23,7 +23,7 @@ use rustc_data_structures::indexed_vec::Idx;
use std::mem; use std::mem;
use std::collections::VecDeque; use std::collections::VecDeque;
use transform::{MirPass, MirSource}; use transform::{MirPass, MirSource};
use syntax::codemap::{Span, DUMMY_SP}; use syntax::codemap::Span;
use rustc_data_structures::control_flow_graph::ControlFlowGraph; use rustc_data_structures::control_flow_graph::ControlFlowGraph;
use rustc::ty::subst::Substs; use rustc::ty::subst::Substs;
@ -147,7 +147,7 @@ impl<'a, 'tcx> MutVisitor<'tcx> for InstCombineVisitor<'a, 'tcx> {
TerminatorKind::SwitchInt { discr: value, .. } | TerminatorKind::SwitchInt { discr: value, .. } |
TerminatorKind::Yield { value, .. } | TerminatorKind::Yield { value, .. } |
TerminatorKind::Assert { cond: value, .. } => { TerminatorKind::Assert { cond: value, .. } => {
if let Some((new, ty, span)) = self.optimizations.const_prop.remove(&location) { if let Some((new, ty, span)) = self.optimizations.terminators.remove(&block) {
let new = self.tcx.mk_const(ty::Const { let new = self.tcx.mk_const(ty::Const {
val: ConstVal::Value(new), val: ConstVal::Value(new),
ty, ty,
@ -190,13 +190,13 @@ impl<'b, 'a, 'tcx:'b> OptimizationFinder<'b, 'a, 'tcx> {
} }
} }
fn eval_constant(&mut self, c: &Constant<'tcx>, span: Span) -> Option<Const<'tcx>> { fn eval_constant(&mut self, c: &Constant<'tcx>) -> Option<Const<'tcx>> {
if let Some(&val) = self.optimizations.constants.get(c) { if let Some(&val) = self.optimizations.constants.get(c) {
return Some(val); return Some(val);
} }
match c.literal { match c.literal {
Literal::Value { value } => match value.val { Literal::Value { value } => match value.val {
ConstVal::Value(v) => Some((v, value.ty, span)), ConstVal::Value(v) => Some((v, value.ty, c.span)),
ConstVal::Unevaluated(did, substs) => { ConstVal::Unevaluated(did, substs) => {
let param_env = self.tcx.param_env(self.source.def_id); let param_env = self.tcx.param_env(self.source.def_id);
let span = self.tcx.def_span(did); let span = self.tcx.def_span(did);
@ -230,10 +230,9 @@ impl<'b, 'a, 'tcx:'b> OptimizationFinder<'b, 'a, 'tcx> {
instance, instance,
promoted: Some(index), promoted: Some(index),
}; };
let span = self.tcx.def_span(self.source.def_id);
let param_env = self.tcx.param_env(self.source.def_id); let param_env = self.tcx.param_env(self.source.def_id);
let (value, _, ty) = eval_body_with_mir(self.tcx, cid, self.mir, param_env)?; let (value, _, ty) = eval_body_with_mir(self.tcx, cid, self.mir, param_env)?;
let val = (value, ty, span); let val = (value, ty, c.span);
trace!("evaluated {:?} to {:?}", c, val); trace!("evaluated {:?} to {:?}", c, val);
self.optimizations.constants.insert(c.clone(), val); self.optimizations.constants.insert(c.clone(), val);
Some(val) Some(val)
@ -241,9 +240,9 @@ impl<'b, 'a, 'tcx:'b> OptimizationFinder<'b, 'a, 'tcx> {
} }
} }
fn eval_operand(&mut self, op: &Operand<'tcx>, span: Span) -> Option<Const<'tcx>> { fn eval_operand(&mut self, op: &Operand<'tcx>) -> Option<Const<'tcx>> {
match *op { match *op {
Operand::Constant(ref c) => self.eval_constant(c, span), Operand::Constant(ref c) => self.eval_constant(c),
Operand::Move(ref place) | Operand::Copy(ref place) => match *place { Operand::Move(ref place) | Operand::Copy(ref place) => match *place {
Place::Local(loc) => self.optimizations.places.get(&loc).cloned(), Place::Local(loc) => self.optimizations.places.get(&loc).cloned(),
// FIXME(oli-obk): field and index projections // FIXME(oli-obk): field and index projections
@ -253,13 +252,13 @@ impl<'b, 'a, 'tcx:'b> OptimizationFinder<'b, 'a, 'tcx> {
} }
} }
fn simplify_operand(&mut self, op: &Operand<'tcx>, span: Span) -> Option<Const<'tcx>> { fn simplify_operand(&mut self, op: &Operand<'tcx>) -> Option<Const<'tcx>> {
match *op { match *op {
Operand::Constant(ref c) => match c.literal { Operand::Constant(ref c) => match c.literal {
Literal::Value { .. } => None, Literal::Value { .. } => None,
_ => self.eval_operand(op, span), _ => self.eval_operand(op),
}, },
_ => self.eval_operand(op, span), _ => self.eval_operand(op),
} }
} }
@ -270,7 +269,7 @@ impl<'b, 'a, 'tcx:'b> OptimizationFinder<'b, 'a, 'tcx> {
span: Span, span: Span,
) -> Option<Const<'tcx>> { ) -> Option<Const<'tcx>> {
match *rvalue { match *rvalue {
Rvalue::Use(ref op) => self.simplify_operand(op, span), Rvalue::Use(ref op) => self.simplify_operand(op),
Rvalue::Repeat(..) | Rvalue::Repeat(..) |
Rvalue::Ref(..) | Rvalue::Ref(..) |
Rvalue::Cast(..) | Rvalue::Cast(..) |
@ -300,15 +299,15 @@ impl<'b, 'a, 'tcx:'b> OptimizationFinder<'b, 'a, 'tcx> {
} }
let substs = Substs::identity_for_item(self.tcx, self.source.def_id); let substs = Substs::identity_for_item(self.tcx, self.source.def_id);
let instance = Instance::new(self.source.def_id, substs); let instance = Instance::new(self.source.def_id, substs);
let ecx = mk_borrowck_eval_cx(self.tcx, instance, self.mir).unwrap(); let ecx = mk_borrowck_eval_cx(self.tcx, instance, self.mir, span).unwrap();
let val = self.eval_operand(arg, span)?; let val = self.eval_operand(arg)?;
let prim = ecx.value_to_primval(ValTy { value: val.0, ty: val.1 }).ok()?; let prim = ecx.value_to_primval(ValTy { value: val.0, ty: val.1 }).ok()?;
let kind = ecx.ty_to_primval_kind(val.1).ok()?; let kind = ecx.ty_to_primval_kind(val.1).ok()?;
match unary_op(op, prim, kind) { match unary_op(op, prim, kind) {
Ok(val) => Some((Value::ByVal(val), place_ty, span)), Ok(val) => Some((Value::ByVal(val), place_ty, span)),
Err(mut err) => { Err(mut err) => {
ecx.report(&mut err, false); ecx.report(&mut err, false, Some(span));
None None
}, },
} }
@ -316,8 +315,8 @@ impl<'b, 'a, 'tcx:'b> OptimizationFinder<'b, 'a, 'tcx> {
Rvalue::CheckedBinaryOp(op, ref left, ref right) | Rvalue::CheckedBinaryOp(op, ref left, ref right) |
Rvalue::BinaryOp(op, ref left, ref right) => { Rvalue::BinaryOp(op, ref left, ref right) => {
trace!("rvalue binop {:?} for {:?} and {:?}", op, left, right); trace!("rvalue binop {:?} for {:?} and {:?}", op, left, right);
let left = self.eval_operand(left, span)?; let left = self.eval_operand(left)?;
let right = self.eval_operand(right, span)?; let right = self.eval_operand(right)?;
let def_id = if self.tcx.is_closure(self.source.def_id) { let def_id = if self.tcx.is_closure(self.source.def_id) {
self.tcx.closure_base_def_id(self.source.def_id) self.tcx.closure_base_def_id(self.source.def_id)
} else { } else {
@ -331,7 +330,7 @@ impl<'b, 'a, 'tcx:'b> OptimizationFinder<'b, 'a, 'tcx> {
} }
let substs = Substs::identity_for_item(self.tcx, self.source.def_id); let substs = Substs::identity_for_item(self.tcx, self.source.def_id);
let instance = Instance::new(self.source.def_id, substs); let instance = Instance::new(self.source.def_id, substs);
let ecx = mk_borrowck_eval_cx(self.tcx, instance, self.mir).unwrap(); let ecx = mk_borrowck_eval_cx(self.tcx, instance, self.mir, span).unwrap();
let l = ecx.value_to_primval(ValTy { value: left.0, ty: left.1 }).ok()?; let l = ecx.value_to_primval(ValTy { value: left.0, ty: left.1 }).ok()?;
let r = ecx.value_to_primval(ValTy { value: right.0, ty: right.1 }).ok()?; let r = ecx.value_to_primval(ValTy { value: right.0, ty: right.1 }).ok()?;
@ -351,7 +350,7 @@ impl<'b, 'a, 'tcx:'b> OptimizationFinder<'b, 'a, 'tcx> {
kind: EvalErrorKind::OverflowingMath, kind: EvalErrorKind::OverflowingMath,
backtrace: None, backtrace: None,
}; };
ecx.report(&mut err, false); ecx.report(&mut err, false, Some(span));
return None; return None;
} }
Value::ByVal(val) Value::ByVal(val)
@ -359,7 +358,7 @@ impl<'b, 'a, 'tcx:'b> OptimizationFinder<'b, 'a, 'tcx> {
Some((val, place_ty, span)) Some((val, place_ty, span))
}, },
Err(mut err) => { Err(mut err) => {
ecx.report(&mut err, false); ecx.report(&mut err, false, Some(span));
None None
}, },
} }
@ -500,7 +499,7 @@ impl<'b, 'a, 'tcx> Visitor<'tcx> for OptimizationFinder<'b, 'a, 'tcx> {
) { ) {
trace!("visit_constant: {:?}", constant); trace!("visit_constant: {:?}", constant);
self.super_constant(constant, location); self.super_constant(constant, location);
self.eval_constant(constant, DUMMY_SP); self.eval_constant(constant);
} }
fn visit_statement( fn visit_statement(
@ -514,7 +513,7 @@ impl<'b, 'a, 'tcx> Visitor<'tcx> for OptimizationFinder<'b, 'a, 'tcx> {
let place_ty = place let place_ty = place
.ty(&self.mir.local_decls, self.tcx) .ty(&self.mir.local_decls, self.tcx)
.to_ty(self.tcx); .to_ty(self.tcx);
let span = self.mir.source_info(location).span; let span = statement.source_info.span;
if let Some(value) = self.const_prop(rval, place_ty, span) { if let Some(value) = self.const_prop(rval, place_ty, span) {
self.optimizations.const_prop.insert(location, value); self.optimizations.const_prop.insert(location, value);
if let Place::Local(local) = *place { if let Place::Local(local) = *place {
@ -554,17 +553,16 @@ impl<'b, 'a, 'tcx> Visitor<'tcx> for OptimizationFinder<'b, 'a, 'tcx> {
fn visit_terminator_kind( fn visit_terminator_kind(
&mut self, &mut self,
_block: BasicBlock, block: BasicBlock,
kind: &TerminatorKind<'tcx>, kind: &TerminatorKind<'tcx>,
location: Location, _location: Location,
) { ) {
let span = self.mir.source_info(location).span;
match kind { match kind {
TerminatorKind::SwitchInt { discr: value, .. } | TerminatorKind::SwitchInt { discr: value, .. } |
TerminatorKind::Yield { value, .. } | TerminatorKind::Yield { value, .. } |
TerminatorKind::Assert { cond: value, .. } => { TerminatorKind::Assert { cond: value, .. } => {
if let Some(value) = self.simplify_operand(value, span) { if let Some(value) = self.simplify_operand(value) {
self.optimizations.const_prop.insert(location, value); self.optimizations.terminators.insert(block, value);
} }
} }
// FIXME: do this optimization for function calls // FIXME: do this optimization for function calls
@ -578,6 +576,8 @@ struct OptimizationList<'tcx> {
and_stars: FxHashSet<Location>, and_stars: FxHashSet<Location>,
arrays_lengths: FxHashMap<Location, Constant<'tcx>>, arrays_lengths: FxHashMap<Location, Constant<'tcx>>,
const_prop: FxHashMap<Location, Const<'tcx>>, const_prop: FxHashMap<Location, Const<'tcx>>,
/// Terminators that get their Operand(s) turned into constants.
terminators: FxHashMap<BasicBlock, Const<'tcx>>,
places: FxHashMap<Local, Const<'tcx>>, places: FxHashMap<Local, Const<'tcx>>,
constants: FxHashMap<Constant<'tcx>, Const<'tcx>>, constants: FxHashMap<Constant<'tcx>, Const<'tcx>>,
} }

1
src/librustc_mir/transform/mod.rs
View file

@ -265,6 +265,7 @@ fn optimized_mir<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> &'tcx
generator::StateTransform, generator::StateTransform,
instcombine::InstCombine, instcombine::InstCombine,
simplify_branches::SimplifyBranches::new("after-const-prop"),
deaggregator::Deaggregator, deaggregator::Deaggregator,
copy_prop::CopyPropagation, copy_prop::CopyPropagation,
remove_noop_landing_pads::RemoveNoopLandingPads, remove_noop_landing_pads::RemoveNoopLandingPads,

2
src/librustc_trans/mir/analyze.rs
View file

@ -128,7 +128,7 @@ impl<'mir, 'a, 'tcx> Visitor<'tcx> for LocalAnalyzer<'mir, 'a, 'tcx> {
_ => None, _ => None,
}; };
if let Some((def_id, args)) = check { if let Some((def_id, args)) = check {
if Some(def_id) == self.cx.ccx.tcx().lang_items().box_free_fn() { if Some(def_id) == self.fx.cx.tcx.lang_items().box_free_fn() {
// box_free(x) shares with `drop x` the property that it // box_free(x) shares with `drop x` the property that it
// is not guaranteed to be statically dominated by the // is not guaranteed to be statically dominated by the
// definition of x, so x must always be in an alloca. // definition of x, so x must always be in an alloca.

2
src/librustc_trans/mir/block.rs
View file

@ -204,7 +204,7 @@ impl<'a, 'tcx> FunctionCx<'a, 'tcx> {
let (otherwise, targets) = targets.split_last().unwrap(); let (otherwise, targets) = targets.split_last().unwrap();
let switch = bx.switch(discr.immediate(), let switch = bx.switch(discr.immediate(),
llblock(self, *otherwise), values.len()); llblock(self, *otherwise), values.len());
let switch_llty = bcx.ccx.layout_of(switch_ty).immediate_llvm_type(bcx.ccx); let switch_llty = bx.cx.layout_of(switch_ty).immediate_llvm_type(bx.cx);
for (&value, target) in values.iter().zip(targets) { for (&value, target) in values.iter().zip(targets) {
let llval = C_uint_big(switch_llty, value); let llval = C_uint_big(switch_llty, value);
let llbb = llblock(self, *target); let llbb = llblock(self, *target);

100
src/librustc_trans/mir/constant.rs
View file

@ -29,7 +29,7 @@ use type_of::LayoutLlvmExt;
use type_::Type; use type_::Type;
use super::super::callee; use super::super::callee;
use super::MirContext; use super::FunctionCx;
fn to_const_int(value: ValueRef, t: Ty, tcx: TyCtxt) -> Option<ConstInt> { fn to_const_int(value: ValueRef, t: Ty, tcx: TyCtxt) -> Option<ConstInt> {
match t.sty { match t.sty {
@ -135,15 +135,15 @@ pub fn const_scalar_checked_binop<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
} }
} }
pub fn primval_to_llvm(ccx: &CrateContext, pub fn primval_to_llvm(cx: &CodegenCx,
cv: PrimVal, cv: PrimVal,
scalar: &Scalar, scalar: &Scalar,
llty: Type) -> ValueRef { llty: Type) -> ValueRef {
let bits = if scalar.is_bool() { 1 } else { scalar.value.size(ccx).bits() }; let bits = if scalar.is_bool() { 1 } else { scalar.value.size(cx).bits() };
match cv { match cv {
PrimVal::Undef => C_undef(Type::ix(ccx, bits)), PrimVal::Undef => C_undef(Type::ix(cx, bits)),
PrimVal::Bytes(b) => { PrimVal::Bytes(b) => {
let llval = C_uint_big(Type::ix(ccx, bits), b); let llval = C_uint_big(Type::ix(cx, bits), b);
if scalar.value == layout::Pointer { if scalar.value == layout::Pointer {
unsafe { llvm::LLVMConstIntToPtr(llval, llty.to_ref()) } unsafe { llvm::LLVMConstIntToPtr(llval, llty.to_ref()) }
} else { } else {
@ -151,28 +151,28 @@ pub fn primval_to_llvm(ccx: &CrateContext,
} }
}, },
PrimVal::Ptr(ptr) => { PrimVal::Ptr(ptr) => {
let interpret_interner = ccx.tcx().interpret_interner.borrow(); let interpret_interner = cx.tcx.interpret_interner.borrow();
if let Some(fn_instance) = interpret_interner.get_fn(ptr.alloc_id) { if let Some(fn_instance) = interpret_interner.get_fn(ptr.alloc_id) {
callee::get_fn(ccx, fn_instance) callee::get_fn(cx, fn_instance)
} else { } else {
let static_ = interpret_interner.get_corresponding_static_def_id(ptr.alloc_id); let static_ = interpret_interner.get_corresponding_static_def_id(ptr.alloc_id);
let base_addr = if let Some(def_id) = static_ { let base_addr = if let Some(def_id) = static_ {
assert!(ccx.tcx().is_static(def_id).is_some()); assert!(cx.tcx.is_static(def_id).is_some());
consts::get_static(ccx, def_id) consts::get_static(cx, def_id)
} else if let Some(alloc) = interpret_interner.get_alloc(ptr.alloc_id) { } else if let Some(alloc) = interpret_interner.get_alloc(ptr.alloc_id) {
let init = global_initializer(ccx, alloc); let init = global_initializer(cx, alloc);
if alloc.mutable { if alloc.mutable {
consts::addr_of_mut(ccx, init, alloc.align, "byte_str") consts::addr_of_mut(cx, init, alloc.align, "byte_str")
} else { } else {
consts::addr_of(ccx, init, alloc.align, "byte_str") consts::addr_of(cx, init, alloc.align, "byte_str")
} }
} else { } else {
bug!("missing allocation {:?}", ptr.alloc_id); bug!("missing allocation {:?}", ptr.alloc_id);
}; };
let llval = unsafe { llvm::LLVMConstInBoundsGEP( let llval = unsafe { llvm::LLVMConstInBoundsGEP(
consts::bitcast(base_addr, Type::i8p(ccx)), consts::bitcast(base_addr, Type::i8p(cx)),
&C_usize(ccx, ptr.offset), &C_usize(cx, ptr.offset),
1, 1,
) }; ) };
if scalar.value != layout::Pointer { if scalar.value != layout::Pointer {
@ -185,9 +185,9 @@ pub fn primval_to_llvm(ccx: &CrateContext,
} }
} }
pub fn global_initializer(ccx: &CrateContext, alloc: &Allocation) -> ValueRef { pub fn global_initializer(cx: &CodegenCx, alloc: &Allocation) -> ValueRef {
let mut llvals = Vec::with_capacity(alloc.relocations.len() + 1); let mut llvals = Vec::with_capacity(alloc.relocations.len() + 1);
let layout = ccx.data_layout(); let layout = cx.data_layout();
let pointer_size = layout.pointer_size.bytes() as usize; let pointer_size = layout.pointer_size.bytes() as usize;
let mut next_offset = 0; let mut next_offset = 0;
@ -195,28 +195,28 @@ pub fn global_initializer(ccx: &CrateContext, alloc: &Allocation) -> ValueRef {
assert_eq!(offset as usize as u64, offset); assert_eq!(offset as usize as u64, offset);
let offset = offset as usize; let offset = offset as usize;
if offset > next_offset { if offset > next_offset {
llvals.push(C_bytes(ccx, &alloc.bytes[next_offset..offset])); llvals.push(C_bytes(cx, &alloc.bytes[next_offset..offset]));
} }
let ptr_offset = read_target_uint( let ptr_offset = read_target_uint(
layout.endian, layout.endian,
&alloc.bytes[offset..(offset + pointer_size)], &alloc.bytes[offset..(offset + pointer_size)],
).expect("global_initializer: could not read relocation pointer") as u64; ).expect("global_initializer: could not read relocation pointer") as u64;
llvals.push(primval_to_llvm( llvals.push(primval_to_llvm(
ccx, cx,
PrimVal::Ptr(MemoryPointer { alloc_id, offset: ptr_offset }), PrimVal::Ptr(MemoryPointer { alloc_id, offset: ptr_offset }),
&Scalar { &Scalar {
value: layout::Primitive::Pointer, value: layout::Primitive::Pointer,
valid_range: 0..=!0 valid_range: 0..=!0
}, },
Type::i8p(ccx) Type::i8p(cx)
)); ));
next_offset = offset + pointer_size; next_offset = offset + pointer_size;
} }
if alloc.bytes.len() >= next_offset { if alloc.bytes.len() >= next_offset {
llvals.push(C_bytes(ccx, &alloc.bytes[next_offset ..])); llvals.push(C_bytes(cx, &alloc.bytes[next_offset ..]));
} }
C_struct(ccx, &llvals, true) C_struct(cx, &llvals, true)
} }
pub fn trans_static_initializer<'a, 'tcx>( pub fn trans_static_initializer<'a, 'tcx>(
@ -224,39 +224,39 @@ pub fn trans_static_initializer<'a, 'tcx>(
def_id: DefId) def_id: DefId)
-> Result<ValueRef, ConstEvalErr<'tcx>> -> Result<ValueRef, ConstEvalErr<'tcx>>
{ {
let instance = ty::Instance::mono(ccx.tcx(), def_id); let instance = ty::Instance::mono(cx.tcx, def_id);
let cid = GlobalId { let cid = GlobalId {
instance, instance,
promoted: None promoted: None
}; };
let param_env = ty::ParamEnv::empty(traits::Reveal::All); let param_env = ty::ParamEnv::empty(traits::Reveal::All);
ccx.tcx().const_eval(param_env.and(cid))?; cx.tcx.const_eval(param_env.and(cid))?;
let alloc_id = ccx let alloc_id = cx
.tcx() .tcx
.interpret_interner .interpret_interner
.borrow() .borrow()
.get_cached(def_id) .get_cached(def_id)
.expect("global not cached"); .expect("global not cached");
let alloc = ccx let alloc = cx
.tcx() .tcx
.interpret_interner .interpret_interner
.borrow() .borrow()
.get_alloc(alloc_id) .get_alloc(alloc_id)
.expect("miri allocation never successfully created"); .expect("miri allocation never successfully created");
Ok(global_initializer(ccx, alloc)) Ok(global_initializer(cx, alloc))
} }
impl<'a, 'tcx> FunctionCx<'a, 'tcx> { impl<'a, 'tcx> FunctionCx<'a, 'tcx> {
fn const_to_miri_value( fn const_to_miri_value(
&mut self, &mut self,
bcx: &Builder<'a, 'tcx>, bx: &Builder<'a, 'tcx>,
constant: &'tcx ty::Const<'tcx>, constant: &'tcx ty::Const<'tcx>,
) -> Result<MiriValue, ConstEvalErr<'tcx>> { ) -> Result<MiriValue, ConstEvalErr<'tcx>> {
match constant.val { match constant.val {
ConstVal::Unevaluated(def_id, ref substs) => { ConstVal::Unevaluated(def_id, ref substs) => {
let tcx = bcx.tcx(); let tcx = bx.tcx();
let param_env = ty::ParamEnv::empty(traits::Reveal::All); let param_env = ty::ParamEnv::empty(traits::Reveal::All);
let instance = ty::Instance::resolve(tcx, param_env, def_id, substs).unwrap(); let instance = ty::Instance::resolve(tcx, param_env, def_id, substs).unwrap();
let cid = GlobalId { let cid = GlobalId {
@ -264,7 +264,7 @@ impl<'a, 'tcx> FunctionCx<'a, 'tcx> {
promoted: None, promoted: None,
}; };
let c = tcx.const_eval(param_env.and(cid))?; let c = tcx.const_eval(param_env.and(cid))?;
self.const_to_miri_value(bcx, c) self.const_to_miri_value(bx, c)
}, },
ConstVal::Value(miri_val) => Ok(miri_val), ConstVal::Value(miri_val) => Ok(miri_val),
} }
@ -272,7 +272,7 @@ impl<'a, 'tcx> FunctionCx<'a, 'tcx> {
pub fn mir_constant_to_miri_value( pub fn mir_constant_to_miri_value(
&mut self, &mut self,
bcx: &Builder<'a, 'tcx>, bx: &Builder<'a, 'tcx>,
constant: &mir::Constant<'tcx>, constant: &mir::Constant<'tcx>,
) -> Result<MiriValue, ConstEvalErr<'tcx>> { ) -> Result<MiriValue, ConstEvalErr<'tcx>> {
match constant.literal { match constant.literal {
@ -282,22 +282,22 @@ impl<'a, 'tcx> FunctionCx<'a, 'tcx> {
instance: self.instance, instance: self.instance,
promoted: Some(index), promoted: Some(index),
}; };
bcx.tcx().const_eval(param_env.and(cid)) bx.tcx().const_eval(param_env.and(cid))
} }
mir::Literal::Value { value } => { mir::Literal::Value { value } => {
Ok(self.monomorphize(&value)) Ok(self.monomorphize(&value))
} }
}.and_then(|c| self.const_to_miri_value(bcx, c)) }.and_then(|c| self.const_to_miri_value(bx, c))
} }
// Old version of trans_constant now used just for SIMD shuffle // Old version of trans_constant now used just for SIMD shuffle
pub fn remove_me_shuffle_indices(&mut self, pub fn remove_me_shuffle_indices(&mut self,
bcx: &Builder<'a, 'tcx>, bx: &Builder<'a, 'tcx>,
constant: &mir::Constant<'tcx>) constant: &mir::Constant<'tcx>)
-> (ValueRef, Ty<'tcx>) -> (ValueRef, Ty<'tcx>)
{ {
let layout = bcx.ccx.layout_of(constant.ty); let layout = bx.cx.layout_of(constant.ty);
self.mir_constant_to_miri_value(bcx, constant) self.mir_constant_to_miri_value(bx, constant)
.and_then(|c| { .and_then(|c| {
let llval = match c { let llval = match c {
MiriValue::ByVal(val) => { MiriValue::ByVal(val) => {
@ -305,7 +305,7 @@ impl<'a, 'tcx> FunctionCx<'a, 'tcx> {
layout::Abi::Scalar(ref x) => x, layout::Abi::Scalar(ref x) => x,
_ => bug!("from_const: invalid ByVal layout: {:#?}", layout) _ => bug!("from_const: invalid ByVal layout: {:#?}", layout)
}; };
primval_to_llvm(bcx.ccx, val, scalar, layout.immediate_llvm_type(bcx.ccx)) primval_to_llvm(bx.cx, val, scalar, layout.immediate_llvm_type(bx.cx))
}, },
MiriValue::ByValPair(a_val, b_val) => { MiriValue::ByValPair(a_val, b_val) => {
let (a_scalar, b_scalar) = match layout.abi { let (a_scalar, b_scalar) = match layout.abi {
@ -313,18 +313,18 @@ impl<'a, 'tcx> FunctionCx<'a, 'tcx> {
_ => bug!("from_const: invalid ByValPair layout: {:#?}", layout) _ => bug!("from_const: invalid ByValPair layout: {:#?}", layout)
}; };
let a_llval = primval_to_llvm( let a_llval = primval_to_llvm(
bcx.ccx, bx.cx,
a_val, a_val,
a_scalar, a_scalar,
layout.scalar_pair_element_llvm_type(bcx.ccx, 0), layout.scalar_pair_element_llvm_type(bx.cx, 0),
); );
let b_llval = primval_to_llvm( let b_llval = primval_to_llvm(
bcx.ccx, bx.cx,
b_val, b_val,
b_scalar, b_scalar,
layout.scalar_pair_element_llvm_type(bcx.ccx, 1), layout.scalar_pair_element_llvm_type(bx.cx, 1),
); );
C_struct(bcx.ccx, &[a_llval, b_llval], false) C_struct(bx.cx, &[a_llval, b_llval], false)
}, },
MiriValue::ByRef(..) => { MiriValue::ByRef(..) => {
let field_ty = constant.ty.builtin_index().unwrap(); let field_ty = constant.ty.builtin_index().unwrap();
@ -334,7 +334,7 @@ impl<'a, 'tcx> FunctionCx<'a, 'tcx> {
}; };
let values: Result<Vec<ValueRef>, _> = (0..fields).map(|field| { let values: Result<Vec<ValueRef>, _> = (0..fields).map(|field| {
let field = const_val_field( let field = const_val_field(
bcx.tcx(), bx.tcx(),
ty::ParamEnv::empty(traits::Reveal::All), ty::ParamEnv::empty(traits::Reveal::All),
self.instance, self.instance,
None, None,
@ -344,29 +344,29 @@ impl<'a, 'tcx> FunctionCx<'a, 'tcx> {
)?; )?;
match field.val { match field.val {
ConstVal::Value(MiriValue::ByVal(prim)) => { ConstVal::Value(MiriValue::ByVal(prim)) => {
let layout = bcx.ccx.layout_of(field_ty); let layout = bx.cx.layout_of(field_ty);
let scalar = match layout.abi { let scalar = match layout.abi {
layout::Abi::Scalar(ref x) => x, layout::Abi::Scalar(ref x) => x,
_ => bug!("from_const: invalid ByVal layout: {:#?}", layout) _ => bug!("from_const: invalid ByVal layout: {:#?}", layout)
}; };
Ok(primval_to_llvm( Ok(primval_to_llvm(
bcx.ccx, prim, scalar, bx.cx, prim, scalar,
layout.immediate_llvm_type(bcx.ccx), layout.immediate_llvm_type(bx.cx),
)) ))
}, },
other => bug!("simd shuffle field {:?}, {}", other, constant.ty), other => bug!("simd shuffle field {:?}, {}", other, constant.ty),
} }
}).collect(); }).collect();
C_struct(bcx.ccx, &values?, false) C_struct(bx.cx, &values?, false)
}, },
}; };
Ok((llval, constant.ty)) Ok((llval, constant.ty))
}) })
.unwrap_or_else(|e| { .unwrap_or_else(|e| {
e.report(bcx.tcx(), constant.span, "shuffle_indices"); e.report(bx.tcx(), constant.span, "shuffle_indices");
// We've errored, so we don't have to produce working code. // We've errored, so we don't have to produce working code.
let ty = self.monomorphize(&constant.ty); let ty = self.monomorphize(&constant.ty);
let llty = bcx.ccx.layout_of(ty).llvm_type(bcx.ccx); let llty = bx.cx.layout_of(ty).llvm_type(bx.cx);
(C_undef(llty), ty) (C_undef(llty), ty)
}) })
} }

24
src/librustc_trans/mir/operand.rs
View file

@ -92,14 +92,14 @@ impl<'a, 'tcx> OperandRef<'tcx> {
} }
} }
pub fn from_const(bcx: &Builder<'a, 'tcx>, pub fn from_const(bx: &Builder<'a, 'tcx>,
miri_val: MiriValue, miri_val: MiriValue,
ty: ty::Ty<'tcx>) ty: ty::Ty<'tcx>)
-> Result<OperandRef<'tcx>, ConstEvalErr<'tcx>> { -> Result<OperandRef<'tcx>, ConstEvalErr<'tcx>> {
let layout = bcx.ccx.layout_of(ty); let layout = bx.cx.layout_of(ty);
if layout.is_zst() { if layout.is_zst() {
return Ok(OperandRef::new_zst(bcx.ccx, layout)); return Ok(OperandRef::new_zst(bx.cx, layout));
} }
let val = match miri_val { let val = match miri_val {
@ -109,10 +109,10 @@ impl<'a, 'tcx> OperandRef<'tcx> {
_ => bug!("from_const: invalid ByVal layout: {:#?}", layout) _ => bug!("from_const: invalid ByVal layout: {:#?}", layout)
}; };
let llval = primval_to_llvm( let llval = primval_to_llvm(
bcx.ccx, bx.cx,
x, x,
scalar, scalar,
layout.immediate_llvm_type(bcx.ccx), layout.immediate_llvm_type(bx.cx),
); );
OperandValue::Immediate(llval) OperandValue::Immediate(llval)
}, },
@ -122,16 +122,16 @@ impl<'a, 'tcx> OperandRef<'tcx> {
_ => bug!("from_const: invalid ByValPair layout: {:#?}", layout) _ => bug!("from_const: invalid ByValPair layout: {:#?}", layout)
}; };
let a_llval = primval_to_llvm( let a_llval = primval_to_llvm(
bcx.ccx, bx.cx,
a, a,
a_scalar, a_scalar,
layout.scalar_pair_element_llvm_type(bcx.ccx, 0), layout.scalar_pair_element_llvm_type(bx.cx, 0),
); );
let b_llval = primval_to_llvm( let b_llval = primval_to_llvm(
bcx.ccx, bx.cx,
b, b,
b_scalar, b_scalar,
layout.scalar_pair_element_llvm_type(bcx.ccx, 1), layout.scalar_pair_element_llvm_type(bx.cx, 1),
); );
OperandValue::Pair(a_llval, b_llval) OperandValue::Pair(a_llval, b_llval)
}, },
@ -141,12 +141,12 @@ impl<'a, 'tcx> OperandRef<'tcx> {
valid_range: 0..=!0 valid_range: 0..=!0
}; };
let ptr = primval_to_llvm( let ptr = primval_to_llvm(
bcx.ccx, bx.cx,
ptr.into_inner_primval(), ptr.into_inner_primval(),
&scalar, &scalar,
layout.llvm_type(bcx.ccx).ptr_to(), layout.llvm_type(bx.cx).ptr_to(),
); );
return Ok(PlaceRef::new_sized(ptr, layout, align).load(bcx)); return Ok(PlaceRef::new_sized(ptr, layout, align).load(bx));
}, },
}; };

53
src/librustdoc/clean/mod.rs
View file

@ -34,6 +34,7 @@ use rustc::middle::privacy::AccessLevels;
use rustc::middle::resolve_lifetime as rl; use rustc::middle::resolve_lifetime as rl;
use rustc::ty::fold::TypeFolder; use rustc::ty::fold::TypeFolder;
use rustc::middle::lang_items; use rustc::middle::lang_items;
use rustc::mir::interpret::GlobalId;
use rustc::hir::{self, HirVec}; use rustc::hir::{self, HirVec};
use rustc::hir::def::{self, Def, CtorKind}; use rustc::hir::def::{self, Def, CtorKind};
use rustc::hir::def_id::{CrateNum, DefId, DefIndex, CRATE_DEF_INDEX, LOCAL_CRATE}; use rustc::hir::def_id::{CrateNum, DefId, DefIndex, CRATE_DEF_INDEX, LOCAL_CRATE};
@ -2510,14 +2511,24 @@ impl Clean<Type> for hir::Ty {
ty: cx.tcx.types.usize ty: cx.tcx.types.usize
}) })
}); });
let n = if let ConstVal::Unevaluated(def_id, _) = n.val { let n = match n.val {
if let Some(node_id) = cx.tcx.hir.as_local_node_id(def_id) { ConstVal::Unevaluated(def_id, _) => {
print_const_expr(cx, cx.tcx.hir.body_owned_by(node_id)) if let Some(node_id) = cx.tcx.hir.as_local_node_id(def_id) {
} else { print_const_expr(cx, cx.tcx.hir.body_owned_by(node_id))
inline::print_inlined_const(cx, def_id) } else {
} inline::print_inlined_const(cx, def_id)
} else { }
format!("{:?}", n) },
ConstVal::Value(val) => {
let mut s = String::new();
::rustc::mir::print_miri_value(val, n.ty, &mut s).unwrap();
// array lengths are obviously usize
if s.ends_with("usize") {
let n = s.len() - "usize".len();
s.truncate(n);
}
s
},
}; };
Array(box ty.clean(cx), n) Array(box ty.clean(cx), n)
}, },
@ -2645,14 +2656,24 @@ impl<'tcx> Clean<Type> for Ty<'tcx> {
n = new_n; n = new_n;
} }
}; };
let n = if let ConstVal::Unevaluated(def_id, _) = n.val { let n = match n.val {
if let Some(node_id) = cx.tcx.hir.as_local_node_id(def_id) { ConstVal::Unevaluated(def_id, _) => {
print_const_expr(cx, cx.tcx.hir.body_owned_by(node_id)) if let Some(node_id) = cx.tcx.hir.as_local_node_id(def_id) {
} else { print_const_expr(cx, cx.tcx.hir.body_owned_by(node_id))
inline::print_inlined_const(cx, def_id) } else {
} inline::print_inlined_const(cx, def_id)
} else { }
format!("{:?}", n) },
ConstVal::Value(val) => {
let mut s = String::new();
::rustc::mir::print_miri_value(val, n.ty, &mut s).unwrap();
// array lengths are obviously usize
if s.ends_with("usize") {
let n = s.len() - "usize".len();
s.truncate(n);
}
s
},
}; };
Array(box ty.clean(cx), n) Array(box ty.clean(cx), n)
} }

4
src/test/compile-fail/const-err2.rs
View file

@ -19,10 +19,12 @@ fn black_box<T>(_: T) {
fn main() { fn main() {
let a = -std::i8::MIN; let a = -std::i8::MIN;
//~^ ERROR const_err //~^ ERROR const_err
//~| ERROR const_err
let b = 200u8 + 200u8 + 200u8; let b = 200u8 + 200u8 + 200u8;
//~^ ERROR const_err
let c = 200u8 * 4; let c = 200u8 * 4;
//~^ ERROR const_err
let d = 42u8 - (42u8 + 1); let d = 42u8 - (42u8 + 1);
//~^ ERROR const_err
let _e = [5u8][1]; let _e = [5u8][1];
black_box(a); black_box(a);
black_box(b); black_box(b);

3
src/test/compile-fail/const-err3.rs
View file

@ -18,9 +18,10 @@ fn black_box<T>(_: T) {
fn main() { fn main() {
let b = 200u8 + 200u8 + 200u8; let b = 200u8 + 200u8 + 200u8;
//~^ ERROR const_err //~^ ERROR const_err
//~| ERROR const_err
let c = 200u8 * 4; let c = 200u8 * 4;
//~^ ERROR const_err
let d = 42u8 - (42u8 + 1); let d = 42u8 - (42u8 + 1);
//~^ ERROR const_err
let _e = [5u8][1]; let _e = [5u8][1];
black_box(b); black_box(b);
black_box(c); black_box(c);

34
src/test/run-pass/ctfe/references.rs Normal file
View file

@ -0,0 +1,34 @@
// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
const FOO: &[u8] = b"foo";
const BAR: &[u8] = &[1, 2, 3];
const BOO: &i32 = &42;
fn main() {
match &[1u8, 2, 3] as &[u8] {
FOO => panic!("a"),
BAR => println!("b"),
_ => panic!("c"),
}
match b"foo" as &[u8] {
FOO => println!("a"),
BAR => panic!("b"),
_ => panic!("c"),
}
match &43 {
&42 => panic!(),
BOO => panic!(),
_ => println!("d"),
}
}