@@ -1,49 +1,68 @@
-// 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.
-
 //! This module contains `HashStable` implementations for various data types
 //! from rustc::ty in no particular order.
 
-use ich::{self, StableHashingContext, NodeIdHashingMode};
-use rustc_data_structures::stable_hasher::{HashStable, StableHasher,
-                                           StableHasherResult};
-use std::hash as std_hash;
+use crate::ich::{Fingerprint, StableHashingContext, NodeIdHashingMode};
+use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::stable_hasher::{HashStable, ToStableHashKey, StableHasher};
+use std::cell::RefCell;
 use std::mem;
-use syntax_pos::symbol::InternedString;
-use ty;
-
-impl_stable_hash_for!(struct ty::ItemSubsts<'tcx> { substs });
-
-impl<'a, 'tcx, T> HashStable<StableHashingContext<'a, 'tcx>> for &'tcx ty::Slice<T>
-    where T: HashStable<StableHashingContext<'a, 'tcx>> {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a, 'tcx>,
-                                          hasher: &mut StableHasher<W>) {
-        (&self[..]).hash_stable(hcx, hasher);
-    }
-}
-
-impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ty::subst::Kind<'tcx> {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a, 'tcx>,
-                                          hasher: &mut StableHasher<W>) {
-        self.as_type().hash_stable(hcx, hasher);
-        self.as_region().hash_stable(hcx, hasher);
-    }
-}
-
-impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ty::RegionKind {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a, 'tcx>,
-                                          hasher: &mut StableHasher<W>) {
+use crate::middle::region;
+use crate::ty;
+use crate::mir;
+
+impl<'a, 'tcx, T> HashStable<StableHashingContext<'a>> for &'tcx ty::List<T>
+where
+    T: HashStable<StableHashingContext<'a>>,
+{
+    fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) {
+        thread_local! {
+            static CACHE: RefCell<FxHashMap<(usize, usize), Fingerprint>> =
+                RefCell::new(Default::default());
+        }
+
+        let hash = CACHE.with(|cache| {
+            let key = (self.as_ptr() as usize, self.len());
+            if let Some(&hash) = cache.borrow().get(&key) {
+                return hash;
+            }
+
+            let mut hasher = StableHasher::new();
+            (&self[..]).hash_stable(hcx, &mut hasher);
+
+            let hash: Fingerprint = hasher.finish();
+            cache.borrow_mut().insert(key, hash);
+            hash
+        });
+
+        hash.hash_stable(hcx, hasher);
+    }
+}
+
+impl<'a, 'tcx, T> ToStableHashKey<StableHashingContext<'a>> for &'tcx ty::List<T>
+where
+    T: HashStable<StableHashingContext<'a>>,
+{
+    type KeyType = Fingerprint;
+
+    #[inline]
+    fn to_stable_hash_key(&self, hcx: &StableHashingContext<'a>) -> Fingerprint {
+        let mut hasher = StableHasher::new();
+        let mut hcx: StableHashingContext<'a> = hcx.clone();
+        self.hash_stable(&mut hcx, &mut hasher);
+        hasher.finish()
+    }
+}
+
+impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for ty::subst::GenericArg<'tcx> {
+    fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) {
+        self.unpack().hash_stable(hcx, hasher);
+    }
+}
+
+impl<'a> HashStable<StableHashingContext<'a>>
+for ty::RegionKind {
+    fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) {
         mem::discriminant(self).hash_stable(hcx, hasher);
         match *self {
             ty::ReErased |
             ty::ReStatic |
@@ -50,616 +69,147 @@
             ty::ReEmpty => {
                 // No variant fields to hash for these ...
             }
             ty::ReLateBound(db, ty::BrAnon(i)) => {
-                db.depth.hash_stable(hcx, hasher);
+                db.hash_stable(hcx, hasher);
                 i.hash_stable(hcx, hasher);
+            }
+            ty::ReLateBound(db, ty::BrNamed(def_id, name)) => {
+                db.hash_stable(hcx, hasher);
+                def_id.hash_stable(hcx, hasher);
+                name.hash_stable(hcx, hasher);
+            }
+            ty::ReLateBound(db, ty::BrEnv) => {
+                db.hash_stable(hcx, hasher);
             }
             ty::ReEarlyBound(ty::EarlyBoundRegion { def_id, index, name }) => {
                 def_id.hash_stable(hcx, hasher);
                 index.hash_stable(hcx, hasher);
                 name.hash_stable(hcx, hasher);
             }
-            ty::ReScope(code_extent) => {
-                code_extent.hash_stable(hcx, hasher);
+            ty::ReScope(scope) => {
+                scope.hash_stable(hcx, hasher);
             }
             ty::ReFree(ref free_region) => {
                 free_region.hash_stable(hcx, hasher);
             }
-            ty::ReLateBound(..) |
-            ty::ReVar(..) |
-            ty::ReSkolemized(..) => {
-                bug!("TypeIdHasher: unexpected region {:?}", *self)
+            ty::ReClosureBound(vid) => {
+                vid.hash_stable(hcx, hasher);
             }
-        }
-    }
-}
-
-impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ty::adjustment::AutoBorrow<'tcx> {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a, 'tcx>,
-                                          hasher: &mut StableHasher<W>) {
-        mem::discriminant(self).hash_stable(hcx, hasher);
-        match *self {
-            ty::adjustment::AutoBorrow::Ref(ref region, mutability) => {
-                region.hash_stable(hcx, hasher);
-                mutability.hash_stable(hcx, hasher);
-            }
-            ty::adjustment::AutoBorrow::RawPtr(mutability) => {
-                mutability.hash_stable(hcx, hasher);
+            ty::ReVar(..) |
+            ty::RePlaceholder(..) => {
+                bug!("StableHasher: unexpected region {:?}", *self)
             }
         }
     }
 }
 
-impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ty::adjustment::Adjust<'tcx> {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a, 'tcx>,
-                                          hasher: &mut StableHasher<W>) {
-        mem::discriminant(self).hash_stable(hcx, hasher);
-        match *self {
-            ty::adjustment::Adjust::NeverToAny |
-            ty::adjustment::Adjust::ReifyFnPointer |
-            ty::adjustment::Adjust::UnsafeFnPointer |
-            ty::adjustment::Adjust::ClosureFnPointer |
-            ty::adjustment::Adjust::MutToConstPointer => {}
-            ty::adjustment::Adjust::DerefRef { autoderefs, ref autoref, unsize } => {
-                autoderefs.hash_stable(hcx, hasher);
-                autoref.hash_stable(hcx, hasher);
-                unsize.hash_stable(hcx, hasher);
-            }
-        }
+impl<'a> HashStable<StableHashingContext<'a>> for ty::RegionVid {
+    #[inline]
+    fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) {
+        self.index().hash_stable(hcx, hasher);
+    }
+}
+
+impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for ty::ConstVid<'tcx> {
+    #[inline]
+    fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) {
+        self.index.hash_stable(hcx, hasher);
+    }
+}
+
+impl<'tcx> HashStable<StableHashingContext<'tcx>> for ty::BoundVar {
+    #[inline]
+    fn hash_stable(&self, hcx: &mut StableHashingContext<'tcx>, hasher: &mut StableHasher) {
+        self.index().hash_stable(hcx, hasher);
+    }
+}
+
+impl<'a, T> HashStable<StableHashingContext<'a>> for ty::Binder<T>
+where
+    T: HashStable<StableHashingContext<'a>>,
+{
+    fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) {
+        self.skip_binder().hash_stable(hcx, hasher);
     }
 }
 
-impl_stable_hash_for!(struct ty::adjustment::Adjustment<'tcx> { kind, target });
-impl_stable_hash_for!(struct ty::MethodCall { expr_id, autoderef });
-impl_stable_hash_for!(struct ty::MethodCallee<'tcx> { def_id, ty, substs });
-impl_stable_hash_for!(struct ty::UpvarId { var_id, closure_expr_id });
-impl_stable_hash_for!(struct ty::UpvarBorrow<'tcx> { kind, region });
-
-impl_stable_hash_for!(enum ty::BorrowKind {
-    ImmBorrow,
-    UniqueImmBorrow,
-    MutBorrow
-});
-
-impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ty::UpvarCapture<'tcx> {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a, 'tcx>,
-                                          hasher: &mut StableHasher<W>) {
-        mem::discriminant(self).hash_stable(hcx, hasher);
-        match *self {
-            ty::UpvarCapture::ByValue => {}
-            ty::UpvarCapture::ByRef(ref up_var_borrow) => {
-                up_var_borrow.hash_stable(hcx, hasher);
-            }
-        }
+// AllocIds get resolved to whatever they point to (to be stable)
+impl<'a> HashStable<StableHashingContext<'a>> for mir::interpret::AllocId {
+    fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) {
+        ty::tls::with_opt(|tcx| {
+            trace!("hashing {:?}", *self);
+            let tcx = tcx.expect("can't hash AllocIds during hir lowering");
+            let alloc_kind = tcx.alloc_map.lock().get(*self);
+            alloc_kind.hash_stable(hcx, hasher);
+        });
     }
 }
 
-impl_stable_hash_for!(struct ty::FnSig<'tcx> {
-    inputs_and_output,
-    variadic,
-    unsafety,
-    abi
-});
-
-impl<'a, 'tcx, T> HashStable<StableHashingContext<'a, 'tcx>> for ty::Binder<T>
-    where T: HashStable<StableHashingContext<'a, 'tcx>> + ty::fold::TypeFoldable<'tcx>
+// `Relocations` with default type parameters is a sorted map.
+impl<'a, Tag> HashStable<StableHashingContext<'a>>
+for mir::interpret::Relocations<Tag>
+where
+    Tag: HashStable<StableHashingContext<'a>>,
 {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a, 'tcx>,
-                                          hasher: &mut StableHasher<W>) {
-        hcx.tcx().anonymize_late_bound_regions(self).0.hash_stable(hcx, hasher);
-    }
-}
-
-impl_stable_hash_for!(enum ty::ClosureKind { Fn, FnMut, FnOnce });
-
-impl_stable_hash_for!(enum ty::Visibility {
-    Public,
-    Restricted(def_id),
-    Invisible
-});
-
-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!(tuple_struct ty::EquatePredicate<'tcx> { t1, t2 });
-impl_stable_hash_for!(struct ty::SubtypePredicate<'tcx> { a_is_expected, a, b });
-
-impl<'a, 'tcx, A, B> HashStable<StableHashingContext<'a, 'tcx>> for ty::OutlivesPredicate<A, B>
-    where A: HashStable<StableHashingContext<'a, 'tcx>>,
-          B: HashStable<StableHashingContext<'a, 'tcx>>,
-{
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a, 'tcx>,
-                                          hasher: &mut StableHasher<W>) {
-        let ty::OutlivesPredicate(ref a, ref b) = *self;
-        a.hash_stable(hcx, hasher);
-        b.hash_stable(hcx, hasher);
-    }
-}
-
-impl_stable_hash_for!(struct ty::ProjectionPredicate<'tcx> { projection_ty, ty });
-impl_stable_hash_for!(struct ty::ProjectionTy<'tcx> { trait_ref, item_name });
-
-
-impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ty::Predicate<'tcx> {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a, 'tcx>,
-                                          hasher: &mut StableHasher<W>) {
-        mem::discriminant(self).hash_stable(hcx, hasher);
-        match *self {
-            ty::Predicate::Trait(ref pred) => {
-                pred.hash_stable(hcx, hasher);
-            }
-            ty::Predicate::Equate(ref pred) => {
-                pred.hash_stable(hcx, hasher);
-            }
-            ty::Predicate::Subtype(ref pred) => {
-                pred.hash_stable(hcx, hasher);
-            }
-            ty::Predicate::RegionOutlives(ref pred) => {
-                pred.hash_stable(hcx, hasher);
-            }
-            ty::Predicate::TypeOutlives(ref pred) => {
-                pred.hash_stable(hcx, hasher);
-            }
-            ty::Predicate::Projection(ref pred) => {
-                pred.hash_stable(hcx, hasher);
-            }
-            ty::Predicate::WellFormed(ty) => {
-                ty.hash_stable(hcx, hasher);
-            }
-            ty::Predicate::ObjectSafe(def_id) => {
-                def_id.hash_stable(hcx, hasher);
-            }
-            ty::Predicate::ClosureKind(def_id, closure_kind) => {
-                def_id.hash_stable(hcx, hasher);
-                closure_kind.hash_stable(hcx, hasher);
-            }
+    fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) {
+        self.len().hash_stable(hcx, hasher);
+        for reloc in self.iter() {
+            reloc.hash_stable(hcx, hasher);
         }
     }
 }
 
-impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ty::AdtFlags {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          _: &mut StableHashingContext<'a, 'tcx>,
-                                          hasher: &mut StableHasher<W>) {
-        std_hash::Hash::hash(self, hasher);
+impl<'a> ToStableHashKey<StableHashingContext<'a>> for region::Scope {
+    type KeyType = region::Scope;
+
+    #[inline]
+    fn to_stable_hash_key(&self, _: &StableHashingContext<'a>) -> region::Scope {
+        *self
+    }
+}
+
+impl<'a> HashStable<StableHashingContext<'a>> for ty::TyVid {
+    fn hash_stable(&self, _hcx: &mut StableHashingContext<'a>, _hasher: &mut StableHasher) {
+        // `TyVid` values are confined to an inference context and hence
+        // should not be hashed.
+        bug!("ty::TyKind::hash_stable() - can't hash a TyVid {:?}.", *self)
+    }
+}
+
+impl<'a> HashStable<StableHashingContext<'a>> for ty::IntVid {
+    fn hash_stable(&self, _hcx: &mut StableHashingContext<'a>, _hasher: &mut StableHasher) {
+        // `IntVid` values are confined to an inference context and hence
+        // should not be hashed.
+        bug!("ty::TyKind::hash_stable() - can't hash an IntVid {:?}.", *self)
+    }
+}
+
+impl<'a> HashStable<StableHashingContext<'a>> for ty::FloatVid {
+    fn hash_stable(&self, _hcx: &mut StableHashingContext<'a>, _hasher: &mut StableHasher) {
+        // `FloatVid` values are confined to an inference context and hence
+        // should not be hashed.
+        bug!("ty::TyKind::hash_stable() - can't hash a FloatVid {:?}.", *self)
     }
 }
 
-impl_stable_hash_for!(struct ty::VariantDef {
-    did,
-    name,
-    discr,
-    fields,
-    ctor_kind
-});
-
-impl_stable_hash_for!(enum ty::VariantDiscr {
-    Explicit(def_id),
-    Relative(distance)
-});
-
-impl_stable_hash_for!(struct ty::FieldDef {
-    did,
-    name,
-    vis
-});
-
-impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>>
-for ::middle::const_val::ConstVal<'tcx> {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a, 'tcx>,
-                                          hasher: &mut StableHasher<W>) {
-        use middle::const_val::ConstVal;
-
-        mem::discriminant(self).hash_stable(hcx, hasher);
-
-        match *self {
-            ConstVal::Float(ref value) => {
-                value.hash_stable(hcx, hasher);
-            }
-            ConstVal::Integral(ref value) => {
-                value.hash_stable(hcx, hasher);
-            }
-            ConstVal::Str(ref value) => {
-                value.hash_stable(hcx, hasher);
-            }
-            ConstVal::ByteStr(ref value) => {
-                value.hash_stable(hcx, hasher);
-            }
-            ConstVal::Bool(value) => {
-                value.hash_stable(hcx, hasher);
-            }
-            ConstVal::Char(value) => {
-                value.hash_stable(hcx, hasher);
-            }
-            ConstVal::Variant(def_id) => {
-                def_id.hash_stable(hcx, hasher);
-            }
-            ConstVal::Function(def_id, substs) => {
-                def_id.hash_stable(hcx, hasher);
-                substs.hash_stable(hcx, hasher);
-            }
-            ConstVal::Struct(ref name_value_map) => {
-                let mut values: Vec<(InternedString, &ConstVal)> =
-                    name_value_map.iter()
-                                  .map(|(name, val)| (name.as_str(), val))
-                                  .collect();
-
-                values.sort_unstable_by_key(|&(ref name, _)| name.clone());
-                values.hash_stable(hcx, hasher);
-            }
-            ConstVal::Tuple(ref value) => {
-                value.hash_stable(hcx, hasher);
-            }
-            ConstVal::Array(ref value) => {
-                value.hash_stable(hcx, hasher);
-            }
-            ConstVal::Repeat(ref value, times) => {
-                value.hash_stable(hcx, hasher);
-                times.hash_stable(hcx, hasher);
-            }
-        }
+impl<'a, T> HashStable<StableHashingContext<'a>> for ty::steal::Steal<T>
+where
+    T: HashStable<StableHashingContext<'a>>,
+{
+    fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) {
+        self.borrow().hash_stable(hcx, hasher);
     }
 }
 
-impl_stable_hash_for!(struct ty::ClosureSubsts<'tcx> { substs });
-
-impl_stable_hash_for!(struct ty::GenericPredicates<'tcx> {
-    parent,
-    predicates
-});
-
-impl_stable_hash_for!(enum ty::Variance {
-    Covariant,
-    Invariant,
-    Contravariant,
-    Bivariant
-});
+impl<'a> HashStable<StableHashingContext<'a>>
+for crate::middle::privacy::AccessLevels {
+    fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) {
+        hcx.with_node_id_hashing_mode(NodeIdHashingMode::HashDefPath, |hcx| {
+            let crate::middle::privacy::AccessLevels {
+                ref map
+            } = *self;
 
-impl_stable_hash_for!(enum ty::adjustment::CustomCoerceUnsized {
-    Struct(index)
-});
-
-impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ty::Generics {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a, 'tcx>,
-                                          hasher: &mut StableHasher<W>) {
-        let ty::Generics {
-            parent,
-            parent_regions,
-            parent_types,
-            ref regions,
-            ref types,
-
-            // Reverse map to each `TypeParameterDef`'s `index` field, from
-            // `def_id.index` (`def_id.krate` is the same as the item's).
-            type_param_to_index: _, // Don't hash this
-            has_self,
-        } = *self;
-
-        parent.hash_stable(hcx, hasher);
-        parent_regions.hash_stable(hcx, hasher);
-        parent_types.hash_stable(hcx, hasher);
-        regions.hash_stable(hcx, hasher);
-        types.hash_stable(hcx, hasher);
-        has_self.hash_stable(hcx, hasher);
-    }
-}
-
-impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ty::RegionParameterDef {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a, 'tcx>,
-                                          hasher: &mut StableHasher<W>) {
-        let ty::RegionParameterDef {
-            name,
-            def_id,
-            index,
-            issue_32330: _,
-            pure_wrt_drop
-        } = *self;
-
-        name.hash_stable(hcx, hasher);
-        def_id.hash_stable(hcx, hasher);
-        index.hash_stable(hcx, hasher);
-        pure_wrt_drop.hash_stable(hcx, hasher);
-    }
-}
-
-impl_stable_hash_for!(struct ty::TypeParameterDef {
-    name,
-    def_id,
-    index,
-    has_default,
-    object_lifetime_default,
-    pure_wrt_drop
-});
-
-
-impl<'a, 'tcx, T> HashStable<StableHashingContext<'a, 'tcx>>
-for ::middle::resolve_lifetime::Set1<T>
-    where T: HashStable<StableHashingContext<'a, 'tcx>>
-{
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a, 'tcx>,
-                                          hasher: &mut StableHasher<W>) {
-        use middle::resolve_lifetime::Set1;
-
-        mem::discriminant(self).hash_stable(hcx, hasher);
-        match *self {
-            Set1::Empty |
-            Set1::Many => {
-                // Nothing to do.
-            }
-            Set1::One(ref value) => {
-                value.hash_stable(hcx, hasher);
-            }
-        }
-    }
-}
-
-impl_stable_hash_for!(enum ::middle::resolve_lifetime::Region {
-    Static,
-    EarlyBound(index, decl),
-    LateBound(db_index, decl),
-    LateBoundAnon(db_index, anon_index),
-    Free(call_site_scope_data, decl)
-});
-
-impl_stable_hash_for!(struct ty::DebruijnIndex {
-    depth
-});
-
-impl_stable_hash_for!(enum ty::cast::CastKind {
-    CoercionCast,
-    PtrPtrCast,
-    PtrAddrCast,
-    AddrPtrCast,
-    NumericCast,
-    EnumCast,
-    PrimIntCast,
-    U8CharCast,
-    ArrayPtrCast,
-    FnPtrPtrCast,
-    FnPtrAddrCast
-});
-
-impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ::middle::region::CodeExtent
-{
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a, 'tcx>,
-                                          hasher: &mut StableHasher<W>) {
-        use middle::region::CodeExtent;
-
-        mem::discriminant(self).hash_stable(hcx, hasher);
-        match *self {
-            CodeExtent::Misc(node_id) |
-            CodeExtent::DestructionScope(node_id) => {
-                node_id.hash_stable(hcx, hasher);
-            }
-            CodeExtent::CallSiteScope(body_id) |
-            CodeExtent::ParameterScope(body_id) => {
-                body_id.hash_stable(hcx, hasher);
-            }
-            CodeExtent::Remainder(block_remainder) => {
-                block_remainder.hash_stable(hcx, hasher);
-            }
-        }
-    }
-}
-
-impl_stable_hash_for!(struct ::middle::region::BlockRemainder {
-    block,
-    first_statement_index
-});
-
-impl_stable_hash_for!(struct ty::adjustment::CoerceUnsizedInfo {
-    custom_kind
-});
-
-impl_stable_hash_for!(struct ty::FreeRegion {
-    scope,
-    bound_region
-});
-
-impl_stable_hash_for!(enum ty::BoundRegion {
-    BrAnon(index),
-    BrNamed(def_id, name),
-    BrFresh(index),
-    BrEnv
-});
-
-impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ty::TypeVariants<'tcx>
-{
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a, 'tcx>,
-                                          hasher: &mut StableHasher<W>) {
-        use ty::TypeVariants::*;
-
-        mem::discriminant(self).hash_stable(hcx, hasher);
-        match *self {
-            TyBool  |
-            TyChar  |
-            TyStr   |
-            TyNever => {
-                // Nothing more to hash.
-            }
-            TyInt(int_ty) => {
-                int_ty.hash_stable(hcx, hasher);
-            }
-            TyUint(uint_ty) => {
-                uint_ty.hash_stable(hcx, hasher);
-            }
-            TyFloat(float_ty)  => {
-                float_ty.hash_stable(hcx, hasher);
-            }
-            TyAdt(adt_def, substs) => {
-                adt_def.hash_stable(hcx, hasher);
-                substs.hash_stable(hcx, hasher);
-            }
-            TyArray(inner_ty, len) => {
-                inner_ty.hash_stable(hcx, hasher);
-                len.hash_stable(hcx, hasher);
-            }
-            TySlice(inner_ty) => {
-                inner_ty.hash_stable(hcx, hasher);
-            }
-            TyRawPtr(pointee_ty) => {
-                pointee_ty.hash_stable(hcx, hasher);
-            }
-            TyRef(region, pointee_ty) => {
-                region.hash_stable(hcx, hasher);
-                pointee_ty.hash_stable(hcx, hasher);
-            }
-            TyFnDef(def_id, substs, ref sig) => {
-                def_id.hash_stable(hcx, hasher);
-                substs.hash_stable(hcx, hasher);
-                sig.hash_stable(hcx, hasher);
-            }
-            TyFnPtr(ref sig) => {
-                sig.hash_stable(hcx, hasher);
-            }
-            TyDynamic(ref existential_predicates, region) => {
-                existential_predicates.hash_stable(hcx, hasher);
-                region.hash_stable(hcx, hasher);
-            }
-            TyClosure(def_id, closure_substs) => {
-                def_id.hash_stable(hcx, hasher);
-                closure_substs.hash_stable(hcx, hasher);
-            }
-            TyTuple(inner_tys, from_diverging_type_var) => {
-                inner_tys.hash_stable(hcx, hasher);
-                from_diverging_type_var.hash_stable(hcx, hasher);
-            }
-            TyProjection(ref projection_ty) => {
-                projection_ty.hash_stable(hcx, hasher);
-            }
-            TyAnon(def_id, substs) => {
-                def_id.hash_stable(hcx, hasher);
-                substs.hash_stable(hcx, hasher);
-            }
-            TyParam(param_ty) => {
-                param_ty.hash_stable(hcx, hasher);
-            }
-
-            TyError     |
-            TyInfer(..) => {
-                bug!("ty::TypeVariants::hash_stable() - Unexpected variant.")
-            }
-        }
-    }
-}
-
-impl_stable_hash_for!(struct ty::ParamTy {
-    idx,
-    name
-});
-
-impl_stable_hash_for!(struct ty::TypeAndMut<'tcx> {
-    ty,
-    mutbl
-});
-
-impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ty::ExistentialPredicate<'tcx>
-{
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a, 'tcx>,
-                                          hasher: &mut StableHasher<W>) {
-        mem::discriminant(self).hash_stable(hcx, hasher);
-        match *self {
-            ty::ExistentialPredicate::Trait(ref trait_ref) => {
-                trait_ref.hash_stable(hcx, hasher);
-            }
-            ty::ExistentialPredicate::Projection(ref projection) => {
-                projection.hash_stable(hcx, hasher);
-            }
-            ty::ExistentialPredicate::AutoTrait(def_id) => {
-                def_id.hash_stable(hcx, hasher);
-            }
-        }
-    }
-}
-
-impl_stable_hash_for!(struct ty::ExistentialTraitRef<'tcx> {
-    def_id,
-    substs
-});
-
-impl_stable_hash_for!(struct ty::ExistentialProjection<'tcx> {
-    trait_ref,
-    item_name,
-    ty
-});
-
-
-impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ty::TypeckTables<'tcx> {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a, 'tcx>,
-                                          hasher: &mut StableHasher<W>) {
-        let ty::TypeckTables {
-            ref type_relative_path_defs,
-            ref node_types,
-            ref item_substs,
-            ref adjustments,
-            ref method_map,
-            ref upvar_capture_map,
-            ref closure_tys,
-            ref closure_kinds,
-            ref liberated_fn_sigs,
-            ref fru_field_types,
-
-            ref cast_kinds,
-
-            // FIXME(#41184): This is still ignored at the moment.
-            lints: _,
-            ref used_trait_imports,
-            tainted_by_errors,
-            ref free_region_map,
-        } = *self;
-
-        hcx.with_node_id_hashing_mode(NodeIdHashingMode::HashDefPath, |hcx| {
-            ich::hash_stable_nodemap(hcx, hasher, type_relative_path_defs);
-            ich::hash_stable_nodemap(hcx, hasher, node_types);
-            ich::hash_stable_nodemap(hcx, hasher, item_substs);
-            ich::hash_stable_nodemap(hcx, hasher, adjustments);
-
-            ich::hash_stable_hashmap(hcx, hasher, method_map, |hcx, method_call| {
-                let ty::MethodCall {
-                    expr_id,
-                    autoderef
-                } = *method_call;
-
-                let def_id = hcx.tcx().hir.local_def_id(expr_id);
-                (hcx.def_path_hash(def_id), autoderef)
-            });
-
-            ich::hash_stable_hashmap(hcx, hasher, upvar_capture_map, |hcx, up_var_id| {
-                let ty::UpvarId {
-                    var_id,
-                    closure_expr_id
-                } = *up_var_id;
-
-                let var_def_id = hcx.tcx().hir.local_def_id(var_id);
-                let closure_def_id = hcx.tcx().hir.local_def_id(closure_expr_id);
-                (hcx.def_path_hash(var_def_id), hcx.def_path_hash(closure_def_id))
-            });
-
-            ich::hash_stable_nodemap(hcx, hasher, closure_tys);
-            ich::hash_stable_nodemap(hcx, hasher, closure_kinds);
-            ich::hash_stable_nodemap(hcx, hasher, liberated_fn_sigs);
-            ich::hash_stable_nodemap(hcx, hasher, fru_field_types);
-            ich::hash_stable_nodemap(hcx, hasher, cast_kinds);
-
-            ich::hash_stable_hashset(hcx, hasher, used_trait_imports, |hcx, def_id| {
-                hcx.def_path_hash(*def_id)
-            });
-
-            tainted_by_errors.hash_stable(hcx, hasher);
-            free_region_map.hash_stable(hcx, hasher);
-        })
+            map.hash_stable(hcx, hasher);
+        });
     }
 }